diff options
253 files changed, 20120 insertions, 15390 deletions
diff --git a/.gitignore b/.gitignore index 98ca125e7..07601b9ec 100644 --- a/.gitignore +++ b/.gitignore @@ -66,8 +66,8 @@ guile-procedures.txt guile-config/guile-config *.go TAGS -/meta/guile-2.0.pc -/meta/guile-2.0-uninstalled.pc +/meta/guile-2.2.pc +/meta/guile-2.2-uninstalled.pc gdb-pre-inst-guile cscope.out cscope.files diff --git a/GUILE-VERSION b/GUILE-VERSION index 59654d178..acaa5666a 100644 --- a/GUILE-VERSION +++ b/GUILE-VERSION @@ -2,10 +2,10 @@ # Note: `GUILE_VERSION' is defined in `configure.ac' using `git-version-gen'. GUILE_MAJOR_VERSION=2 -GUILE_MINOR_VERSION=0 -GUILE_MICRO_VERSION=7 +GUILE_MINOR_VERSION=1 +GUILE_MICRO_VERSION=0 -GUILE_EFFECTIVE_VERSION=2.0 +GUILE_EFFECTIVE_VERSION=2.2 # All of the shared lib versioning info. Right now, for this to work @@ -18,7 +18,7 @@ GUILE_EFFECTIVE_VERSION=2.0 # See libtool info pages for more information on how and when to # change these. -LIBGUILE_INTERFACE_CURRENT=28 +LIBGUILE_INTERFACE_CURRENT=0 LIBGUILE_INTERFACE_REVISION=0 -LIBGUILE_INTERFACE_AGE=6 +LIBGUILE_INTERFACE_AGE=0 LIBGUILE_INTERFACE="${LIBGUILE_INTERFACE_CURRENT}:${LIBGUILE_INTERFACE_REVISION}:${LIBGUILE_INTERFACE_AGE}" @@ -1,14 +1,14 @@ # -*- makefile -*- -GOBJECTS = $(SOURCES:%.scm=%.go) +GOBJECTS = $(SOURCES:%.scm=%.go) $(ELISP_SOURCES:%.el=%.go) GUILE_WARNINGS = -Wunbound-variable -Warity-mismatch -Wformat moddir = $(pkgdatadir)/$(GUILE_EFFECTIVE_VERSION)/$(modpath) -nobase_mod_DATA = $(SOURCES) $(NOCOMP_SOURCES) +nobase_mod_DATA = $(SOURCES) $(ELISP_SOURCES) $(NOCOMP_SOURCES) ccachedir = $(pkglibdir)/$(GUILE_EFFECTIVE_VERSION)/ccache/$(modpath) nobase_ccache_DATA = $(GOBJECTS) -EXTRA_DIST = $(SOURCES) $(NOCOMP_SOURCES) -ETAGS_ARGS = $(SOURCES) $(NOCOMP_SOURCES) +EXTRA_DIST = $(SOURCES) $(ELISP_SOURCES) $(NOCOMP_SOURCES) +ETAGS_ARGS = $(SOURCES) $(ELISP_SOURCES) $(NOCOMP_SOURCES) CLEANFILES = $(GOBJECTS) @@ -24,7 +24,8 @@ AM_V_GUILEC = $(AM_V_GUILEC_$(V)) AM_V_GUILEC_ = $(AM_V_GUILEC_$(AM_DEFAULT_VERBOSITY)) AM_V_GUILEC_0 = @echo " GUILEC" $@; -SUFFIXES = .scm .go +SUFFIXES = .scm .el .go + .scm.go: $(AM_V_GUILEC)GUILE_AUTO_COMPILE=0 \ $(top_builddir)/meta/uninstalled-env \ @@ -32,3 +33,11 @@ SUFFIXES = .scm .go -L "$(abs_srcdir)" -L "$(abs_builddir)" \ -L "$(abs_top_srcdir)/guile-readline" \ -o "$@" "$<" + +.el.go: + $(AM_V_GUILEC)GUILE_AUTO_COMPILE=0 \ + $(top_builddir)/meta/uninstalled-env \ + guild compile --target="$(host)" $(GUILE_WARNINGS) \ + -L "$(abs_srcdir)" -L "$(abs_builddir)" \ + -L "$(abs_top_srcdir)/guile-readline" \ + --from=elisp -o "$@" "$<" diff --git a/configure.ac b/configure.ac index 8848339f8..3b532a07b 100644 --- a/configure.ac +++ b/configure.ac @@ -29,7 +29,7 @@ Floor, Boston, MA 02110-1301, USA. AC_PREREQ(2.61) AC_INIT([GNU Guile], - m4_esyscmd([build-aux/git-version-gen --match v2.0.\* .tarball-version]), + m4_esyscmd([build-aux/git-version-gen --match v2.\[12\].\* .tarball-version]), [bug-guile@gnu.org]) AC_CONFIG_AUX_DIR([build-aux]) AC_CONFIG_MACRO_DIR([m4]) @@ -1223,13 +1223,13 @@ main (int argc, char **argv) # Boehm's GC library # #-------------------------------------------------------------------- -PKG_CHECK_MODULES([BDW_GC], [bdw-gc]) +PKG_CHECK_MODULES([BDW_GC], [bdw-gc >= 7.2]) save_LIBS="$LIBS" LIBS="$BDW_GC_LIBS $LIBS" CFLAGS="$BDW_GC_CFLAGS $CFLAGS" -AC_CHECK_FUNCS([GC_do_blocking GC_call_with_gc_active GC_pthread_exit GC_pthread_cancel GC_allow_register_threads GC_pthread_sigmask GC_set_start_callback GC_get_heap_usage_safe GC_get_free_space_divisor GC_gcollect_and_unmap GC_get_unmapped_bytes GC_set_finalizer_notifier GC_set_finalize_on_demand]) +AC_CHECK_FUNCS([GC_do_blocking GC_call_with_gc_active GC_pthread_exit GC_pthread_cancel GC_allow_register_threads GC_pthread_sigmask GC_set_start_callback GC_get_suspend_signal GC_move_disappearing_link GC_get_heap_usage_safe GC_get_free_space_divisor GC_gcollect_and_unmap GC_get_unmapped_bytes GC_set_finalizer_notifier GC_set_finalize_on_demand]) # Though the `GC_do_blocking ()' symbol is present in GC 7.1, it is not # declared, and has a different type (returning void instead of @@ -1630,8 +1630,8 @@ AC_CONFIG_FILES([ module/Makefile ]) -AC_CONFIG_FILES([meta/guile-2.0.pc]) -AC_CONFIG_FILES([meta/guile-2.0-uninstalled.pc]) +AC_CONFIG_FILES([meta/guile-2.2.pc]) +AC_CONFIG_FILES([meta/guile-2.2-uninstalled.pc]) AC_CONFIG_FILES([doc/ref/effective-version.texi]) GUILE_CONFIG_SCRIPT([check-guile]) diff --git a/doc/example-smob/Makefile b/doc/example-smob/Makefile index 3736dc01f..d368d7b21 100644 --- a/doc/example-smob/Makefile +++ b/doc/example-smob/Makefile @@ -1,5 +1,5 @@ -CFLAGS = `pkg-config guile-2.0 --cflags` -LIBS = `pkg-config guile-2.0 --libs` +CFLAGS = `pkg-config guile-2.2 --cflags` +LIBS = `pkg-config guile-2.2 --libs` O_FILES = image-type.o myguile.o diff --git a/doc/guile.1 b/doc/guile.1 index e36c2aac7..5d8b4e158 100644 --- a/doc/guile.1 +++ b/doc/guile.1 @@ -4,7 +4,7 @@ .\" groff -man -Tascii foo.1 .\" .\" title section date source manual -.TH GUILE 1 "2011-03-04" GNU "GNU Guile 2.0" +.TH GUILE 1 "2011-03-04" GNU "GNU Guile 2.2" . .SH NAME guile \- The GNU Project Extension Language diff --git a/doc/ref/Makefile.am b/doc/ref/Makefile.am index 260bb1448..53cc7ce9a 100644 --- a/doc/ref/Makefile.am +++ b/doc/ref/Makefile.am @@ -44,6 +44,7 @@ guile_TEXINFOS = preface.texi \ api-foreign.texi \ api-regex.texi \ api-lalr.texi \ + api-peg.texi \ api-languages.texi \ api-evaluation.texi \ api-memory.texi \ diff --git a/doc/ref/api-control.texi b/doc/ref/api-control.texi index 95c4925a9..d8b6a45ad 100644 --- a/doc/ref/api-control.texi +++ b/doc/ref/api-control.texi @@ -494,14 +494,17 @@ those passed to @code{abort-to-prompt}. @end deffn @deffn {Scheme Procedure} make-prompt-tag [stem] -Make a new prompt tag. Currently prompt tags are generated symbols. -This may change in some future Guile version. +Make a new prompt tag. A prompt tag is simply a unique object. +Currently, a prompt tag is a fresh pair. This may change in some future +Guile version. @end deffn @deffn {Scheme Procedure} default-prompt-tag Return the default prompt tag. Having a distinguished default prompt tag allows some useful prompt and abort idioms, discussed in the next -section. +section. Note that @code{default-prompt-tag} is actually a parameter, +and so may be dynamically rebound using @code{parameterize}. +@xref{Parameters}. @end deffn @deffn {Scheme Procedure} abort-to-prompt tag val1 val2 @dots{} diff --git a/doc/ref/api-data.texi b/doc/ref/api-data.texi index 9da17d8c3..9bb674a96 100644 --- a/doc/ref/api-data.texi +++ b/doc/ref/api-data.texi @@ -4430,6 +4430,19 @@ returned is the number of bytes for @code{scm_to_latin1_stringn} and for @code{scm_to_utf32_stringn}. @end deftypefn +It is not often the case, but sometimes when you are dealing with the +implementation details of a port, you need to encode and decode strings +according to the encoding and conversion strategy of the port. There +are some convenience functions for that purpose as well. + +@deftypefn {C Function} SCM scm_from_port_string (const char *str, SCM port) +@deftypefnx {C Function} SCM scm_from_port_stringn (const char *str, size_t len, SCM port) +@deftypefnx {C Function} char* scm_to_port_string (SCM str, SCM port) +@deftypefnx {C Function} char* scm_to_port_stringn (SCM str, size_t *lenp, SCM port) +Like @code{scm_from_stringn} and friends, except they take their +encoding and conversion strategy from a given port object. +@end deftypefn + @node String Internals @subsubsection String Internals diff --git a/doc/ref/api-peg.texi b/doc/ref/api-peg.texi new file mode 100644 index 000000000..0e16aab7e --- /dev/null +++ b/doc/ref/api-peg.texi @@ -0,0 +1,1036 @@ +@c -*-texinfo-*- +@c This is part of the GNU Guile Reference Manual. +@c Copyright (C) 2006, 2010, 2011 +@c Free Software Foundation, Inc. +@c See the file guile.texi for copying conditions. + +@node PEG Parsing +@section PEG Parsing + +Parsing Expression Grammars (PEGs) are a way of specifying formal +languages for text processing. They can be used either for matching +(like regular expressions) or for building recursive descent parsers +(like lex/yacc). Guile uses a superset of PEG syntax that allows more +control over what information is preserved during parsing. + +Wikipedia has a clear and concise introduction to PEGs if you want to +familiarize yourself with the syntax: +@url{http://en.wikipedia.org/wiki/Parsing_expression_grammar}. + +The module works by compiling PEGs down to lambda expressions. These +can either be stored in variables at compile-time by the define macros +(@code{define-peg-pattern} and @code{define-peg-string-patterns}) or calculated +explicitly at runtime with the compile functions +(@code{compile-peg-pattern} and @code{peg-string-compile}). + +They can then be used for either parsing (@code{match-pattern}) or searching +(@code{search-for-pattern}). For convenience, @code{search-for-pattern} +also takes pattern literals in case you want to inline a simple search +(people often use regular expressions this way). + +The rest of this documentation consists of a syntax reference, an API +reference, and a tutorial. + +@menu +* PEG Syntax Reference:: +* PEG API Reference:: +* PEG Tutorial:: +* PEG Internals:: +@end menu + +@node PEG Syntax Reference +@subsection PEG Syntax Reference + +@subsubheading Normal PEG Syntax: + +@deftp {PEG Pattern} sequence a b +Parses @var{a}. If this succeeds, continues to parse @var{b} from the +end of the text parsed as @var{a}. Succeeds if both @var{a} and +@var{b} succeed. + +@code{"a b"} + +@code{(and a b)} +@end deftp + +@deftp {PEG Pattern} {ordered choice} a b +Parses @var{a}. If this fails, backtracks and parses @var{b}. +Succeeds if either @var{a} or @var{b} succeeds. + +@code{"a/b"} + +@code{(or a b)} +@end deftp + +@deftp {PEG Pattern} {zero or more} a +Parses @var{a} as many times in a row as it can, starting each @var{a} +at the end of the text parsed by the previous @var{a}. Always +succeeds. + +@code{"a*"} + +@code{(* a)} +@end deftp + +@deftp {PEG Pattern} {one or more} a +Parses @var{a} as many times in a row as it can, starting each @var{a} +at the end of the text parsed by the previous @var{a}. Succeeds if at +least one @var{a} was parsed. + +@code{"a+"} + +@code{(+ a)} +@end deftp + +@deftp {PEG Pattern} optional a +Tries to parse @var{a}. Succeeds if @var{a} succeeds. + +@code{"a?"} + +@code{(? a)} +@end deftp + +@deftp {PEG Pattern} {followed by} a +Makes sure it is possible to parse @var{a}, but does not actually parse +it. Succeeds if @var{a} would succeed. + +@code{"&a"} + +@code{(followed-by a)} +@end deftp + +@deftp {PEG Pattern} {not followed by} a +Makes sure it is impossible to parse @var{a}, but does not actually +parse it. Succeeds if @var{a} would fail. + +@code{"!a"} + +@code{(not-followed-by a)} +@end deftp + +@deftp {PEG Pattern} {string literal} ``abc'' +Parses the string @var{"abc"}. Succeeds if that parsing succeeds. + +@code{"'abc'"} + +@code{"abc"} +@end deftp + +@deftp {PEG Pattern} {any character} +Parses any single character. Succeeds unless there is no more text to +be parsed. + +@code{"."} + +@code{peg-any} +@end deftp + +@deftp {PEG Pattern} {character class} a b +Alternative syntax for ``Ordered Choice @var{a} @var{b}'' if @var{a} and +@var{b} are characters. + +@code{"[ab]"} + +@code{(or "a" "b")} +@end deftp + +@deftp {PEG Pattern} {range of characters} a z +Parses any character falling between @var{a} and @var{z}. + +@code{"[a-z]"} + +@code{(range #\a #\z)} +@end deftp + +Example: + +@example +"(a !b / c &d*) 'e'+" +@end example + +Would be: + +@lisp +(and + (or + (and a (not-followed-by b)) + (and c (followed-by (* d)))) + (+ "e")) +@end lisp + +@subsubheading Extended Syntax + +There is some extra syntax for S-expressions. + +@deftp {PEG Pattern} ignore a +Ignore the text matching @var{a} +@end deftp + +@deftp {PEG Pattern} capture a +Capture the text matching @var{a}. +@end deftp + +@deftp {PEG Pattern} peg a +Embed the PEG pattern @var{a} using string syntax. +@end deftp + +Example: + +@example +"!a / 'b'" +@end example + +Is equivalent to + +@lisp +(or (peg "!a") "b") +@end lisp + +and + +@lisp +(or (not-followed-by a) "b") +@end lisp + +@node PEG API Reference +@subsection PEG API Reference + +@subsubheading Define Macros + +The most straightforward way to define a PEG is by using one of the +define macros (both of these macroexpand into @code{define} +expressions). These macros bind parsing functions to variables. These +parsing functions may be invoked by @code{match-pattern} or +@code{search-for-pattern}, which return a PEG match record. Raw data can be +retrieved from this record with the PEG match deconstructor functions. +More complicated (and perhaps enlightening) examples can be found in the +tutorial. + +@deffn {Scheme Macro} define-peg-string-patterns peg-string +Defines all the nonterminals in the PEG @var{peg-string}. More +precisely, @code{define-peg-string-patterns} takes a superset of PEGs. A normal PEG +has a @code{<-} between the nonterminal and the pattern. +@code{define-peg-string-patterns} uses this symbol to determine what information it +should propagate up the parse tree. The normal @code{<-} propagates the +matched text up the parse tree, @code{<--} propagates the matched text +up the parse tree tagged with the name of the nonterminal, and @code{<} +discards that matched text and propagates nothing up the parse tree. +Also, nonterminals may consist of any alphanumeric character or a ``-'' +character (in normal PEGs nonterminals can only be alphabetic). + +For example, if we: +@lisp +(define-peg-string-patterns + "as <- 'a'+ +bs <- 'b'+ +as-or-bs <- as/bs") +(define-peg-string-patterns + "as-tag <-- 'a'+ +bs-tag <-- 'b'+ +as-or-bs-tag <-- as-tag/bs-tag") +@end lisp +Then: +@lisp +(match-pattern as-or-bs "aabbcc") @result{} +#<peg start: 0 end: 2 string: aabbcc tree: aa> +(match-pattern as-or-bs-tag "aabbcc") @result{} +#<peg start: 0 end: 2 string: aabbcc tree: (as-or-bs-tag (as-tag aa))> +@end lisp + +Note that in doing this, we have bound 6 variables at the toplevel +(@var{as}, @var{bs}, @var{as-or-bs}, @var{as-tag}, @var{bs-tag}, and +@var{as-or-bs-tag}). +@end deffn + +@deffn {Scheme Macro} define-peg-pattern name capture-type peg-sexp +Defines a single nonterminal @var{name}. @var{capture-type} determines +how much information is passed up the parse tree. @var{peg-sexp} is a +PEG in S-expression form. + +Possible values for capture-type: + +@table @code +@item all +passes the matched text up the parse tree tagged with the name of the +nonterminal. +@item body +passes the matched text up the parse tree. +@item none +passes nothing up the parse tree. +@end table + +For Example, if we: +@lisp +(define-peg-pattern as body (+ "a")) +(define-peg-pattern bs body (+ "b")) +(define-peg-pattern as-or-bs body (or as bs)) +(define-peg-pattern as-tag all (+ "a")) +(define-peg-pattern bs-tag all (+ "b")) +(define-peg-pattern as-or-bs-tag all (or as-tag bs-tag)) +@end lisp +Then: +@lisp +(match-pattern as-or-bs "aabbcc") @result{} +#<peg start: 0 end: 2 string: aabbcc tree: aa> +(match-pattern as-or-bs-tag "aabbcc") @result{} +#<peg start: 0 end: 2 string: aabbcc tree: (as-or-bs-tag (as-tag aa))> +@end lisp + +Note that in doing this, we have bound 6 variables at the toplevel +(@var{as}, @var{bs}, @var{as-or-bs}, @var{as-tag}, @var{bs-tag}, and +@var{as-or-bs-tag}). +@end deffn + +@subsubheading Compile Functions +It is sometimes useful to be able to compile anonymous PEG patterns at +runtime. These functions let you do that using either syntax. + +@deffn {Scheme Procedure} peg-string-compile peg-string capture-type +Compiles the PEG pattern in @var{peg-string} propagating according to +@var{capture-type} (capture-type can be any of the values from +@code{define-peg-pattern}). +@end deffn + + +@deffn {Scheme Procedure} compile-peg-pattern peg-sexp capture-type +Compiles the PEG pattern in @var{peg-sexp} propagating according to +@var{capture-type} (capture-type can be any of the values from +@code{define-peg-pattern}). +@end deffn + +The functions return syntax objects, which can be useful if you want to +use them in macros. If all you want is to define a new nonterminal, you +can do the following: + +@lisp +(define exp '(+ "a")) +(define as (compile (compile-peg-pattern exp 'body))) +@end lisp + +You can use this nonterminal with all of the regular PEG functions: + +@lisp +(match-pattern as "aaaaa") @result{} +#<peg start: 0 end: 5 string: bbbbb tree: bbbbb> +@end lisp + +@subsubheading Parsing & Matching Functions + +For our purposes, ``parsing'' means parsing a string into a tree +starting from the first character, while ``matching'' means searching +through the string for a substring. In practice, the only difference +between the two functions is that @code{match-pattern} gives up if it can't +find a valid substring starting at index 0 and @code{search-for-pattern} keeps +looking. They are both equally capable of ``parsing'' and ``matching'' +given those constraints. + +@deffn {Scheme Procedure} match-pattern nonterm string +Parses @var{string} using the PEG stored in @var{nonterm}. If no match +was found, @code{match-pattern} returns false. If a match was found, a PEG +match record is returned. + +The @code{capture-type} argument to @code{define-peg-pattern} allows you to +choose what information to hold on to while parsing. The options are: + +@table @code +@item all +tag the matched text with the nonterminal +@item body +just the matched text +@item none +nothing +@end table + +@lisp +(define-peg-pattern as all (+ "a")) +(match-pattern as "aabbcc") @result{} +#<peg start: 0 end: 2 string: aabbcc tree: (as aa)> + +(define-peg-pattern as body (+ "a")) +(match-pattern as "aabbcc") @result{} +#<peg start: 0 end: 2 string: aabbcc tree: aa> + +(define-peg-pattern as none (+ "a")) +(match-pattern as "aabbcc") @result{} +#<peg start: 0 end: 2 string: aabbcc tree: ()> + +(define-peg-pattern bs body (+ "b")) +(match-pattern bs "aabbcc") @result{} +#f +@end lisp +@end deffn + +@deffn {Scheme Macro} search-for-pattern nonterm-or-peg string +Searches through @var{string} looking for a matching subexpression. +@var{nonterm-or-peg} can either be a nonterminal or a literal PEG +pattern. When a literal PEG pattern is provided, @code{search-for-pattern} works +very similarly to the regular expression searches many hackers are used +to. If no match was found, @code{search-for-pattern} returns false. If a match +was found, a PEG match record is returned. + +@lisp +(define-peg-pattern as body (+ "a")) +(search-for-pattern as "aabbcc") @result{} +#<peg start: 0 end: 2 string: aabbcc tree: aa> +(search-for-pattern (+ "a") "aabbcc") @result{} +#<peg start: 0 end: 2 string: aabbcc tree: aa> +(search-for-pattern "'a'+" "aabbcc") @result{} +#<peg start: 0 end: 2 string: aabbcc tree: aa> + +(define-peg-pattern as all (+ "a")) +(search-for-pattern as "aabbcc") @result{} +#<peg start: 0 end: 2 string: aabbcc tree: (as aa)> + +(define-peg-pattern bs body (+ "b")) +(search-for-pattern bs "aabbcc") @result{} +#<peg start: 2 end: 4 string: aabbcc tree: bb> +(search-for-pattern (+ "b") "aabbcc") @result{} +#<peg start: 2 end: 4 string: aabbcc tree: bb> +(search-for-pattern "'b'+" "aabbcc") @result{} +#<peg start: 2 end: 4 string: aabbcc tree: bb> + +(define-peg-pattern zs body (+ "z")) +(search-for-pattern zs "aabbcc") @result{} +#f +(search-for-pattern (+ "z") "aabbcc") @result{} +#f +(search-for-pattern "'z'+" "aabbcc") @result{} +#f +@end lisp +@end deffn + +@subsubheading PEG Match Records +The @code{match-pattern} and @code{search-for-pattern} functions both return PEG +match records. Actual information can be extracted from these with the +following functions. + +@deffn {Scheme Procedure} peg:string match-record +Returns the original string that was parsed in the creation of +@code{match-record}. +@end deffn + +@deffn {Scheme Procedure} peg:start match-record +Returns the index of the first parsed character in the original string +(from @code{peg:string}). If this is the same as @code{peg:end}, +nothing was parsed. +@end deffn + +@deffn {Scheme Procedure} peg:end match-record +Returns one more than the index of the last parsed character in the +original string (from @code{peg:string}). If this is the same as +@code{peg:start}, nothing was parsed. +@end deffn + +@deffn {Scheme Procedure} peg:substring match-record +Returns the substring parsed by @code{match-record}. This is equivalent to +@code{(substring (peg:string match-record) (peg:start match-record) (peg:end +match-record))}. +@end deffn + +@deffn {Scheme Procedure} peg:tree match-record +Returns the tree parsed by @code{match-record}. +@end deffn + +@deffn {Scheme Procedure} peg-record? match-record +Returns true if @code{match-record} is a PEG match record, or false +otherwise. +@end deffn + +Example: +@lisp +(define-peg-pattern bs all (peg "'b'+")) + +(search-for-pattern bs "aabbcc") @result{} +#<peg start: 2 end: 4 string: aabbcc tree: (bs bb)> + +(let ((pm (search-for-pattern bs "aabbcc"))) + `((string ,(peg:string pm)) + (start ,(peg:start pm)) + (end ,(peg:end pm)) + (substring ,(peg:substring pm)) + (tree ,(peg:tree pm)) + (record? ,(peg-record? pm)))) @result{} +((string "aabbcc") + (start 2) + (end 4) + (substring "bb") + (tree (bs "bb")) + (record? #t)) +@end lisp + +@subsubheading Miscellaneous + +@deffn {Scheme Procedure} context-flatten tst lst +Takes a predicate @var{tst} and a list @var{lst}. Flattens @var{lst} +until all elements are either atoms or satisfy @var{tst}. If @var{lst} +itself satisfies @var{tst}, @code{(list lst)} is returned (this is a +flat list whose only element satisfies @var{tst}). + +@lisp +(context-flatten (lambda (x) (and (number? (car x)) (= (car x) 1))) '(2 2 (1 1 (2 2)) (2 2 (1 1)))) @result{} +(2 2 (1 1 (2 2)) 2 2 (1 1)) +(context-flatten (lambda (x) (and (number? (car x)) (= (car x) 1))) '(1 1 (1 1 (2 2)) (2 2 (1 1)))) @result{} +((1 1 (1 1 (2 2)) (2 2 (1 1)))) +@end lisp + +If you're wondering why this is here, take a look at the tutorial. +@end deffn + +@deffn {Scheme Procedure} keyword-flatten terms lst +A less general form of @code{context-flatten}. Takes a list of terminal +atoms @code{terms} and flattens @var{lst} until all elements are either +atoms, or lists which have an atom from @code{terms} as their first +element. +@lisp +(keyword-flatten '(a b) '(c a b (a c) (b c) (c (b a) (c a)))) @result{} +(c a b (a c) (b c) c (b a) c a) +@end lisp + +If you're wondering why this is here, take a look at the tutorial. +@end deffn + +@node PEG Tutorial +@subsection PEG Tutorial + +@subsubheading Parsing /etc/passwd +This example will show how to parse /etc/passwd using PEGs. + +First we define an example /etc/passwd file: + +@lisp +(define *etc-passwd* + "root:x:0:0:root:/root:/bin/bash +daemon:x:1:1:daemon:/usr/sbin:/bin/sh +bin:x:2:2:bin:/bin:/bin/sh +sys:x:3:3:sys:/dev:/bin/sh +nobody:x:65534:65534:nobody:/nonexistent:/bin/sh +messagebus:x:103:107::/var/run/dbus:/bin/false +") +@end lisp + +As a first pass at this, we might want to have all the entries in +/etc/passwd in a list. + +Doing this with string-based PEG syntax would look like this: +@lisp +(define-peg-string-patterns + "passwd <- entry* !. +entry <-- (! NL .)* NL* +NL < '\n'") +@end lisp + +A @code{passwd} file is 0 or more entries (@code{entry*}) until the end +of the file (@code{!.} (@code{.} is any character, so @code{!.} means +``not anything'')). We want to capture the data in the nonterminal +@code{passwd}, but not tag it with the name, so we use @code{<-}. + +An entry is a series of 0 or more characters that aren't newlines +(@code{(! NL .)*}) followed by 0 or more newlines (@code{NL*}). We want +to tag all the entries with @code{entry}, so we use @code{<--}. + +A newline is just a literal newline (@code{'\n'}). We don't want a +bunch of newlines cluttering up the output, so we use @code{<} to throw +away the captured data. + +Here is the same PEG defined using S-expressions: +@lisp +(define-peg-pattern passwd body (and (* entry) (not-followed-by peg-any))) +(define-peg-pattern entry all (and (* (and (not-followed-by NL) peg-any)) + (* NL))) +(define-peg-pattern NL none "\n") +@end lisp + +Obviously this is much more verbose. On the other hand, it's more +explicit, and thus easier to build automatically. However, there are +some tricks that make S-expressions easier to use in some cases. One is +the @code{ignore} keyword; the string syntax has no way to say ``throw +away this text'' except breaking it out into a separate nonterminal. +For instance, to throw away the newlines we had to define @code{NL}. In +the S-expression syntax, we could have simply written @code{(ignore +"\n")}. Also, for the cases where string syntax is really much cleaner, +the @code{peg} keyword can be used to embed string syntax in +S-expression syntax. For instance, we could have written: + +@lisp +(define-peg-pattern passwd body (peg "entry* !.")) +@end lisp + +However we define it, parsing @code{*etc-passwd*} with the @code{passwd} +nonterminal yields the same results: + +@lisp +(peg:tree (match-pattern passwd *etc-passwd*)) @result{} +((entry "root:x:0:0:root:/root:/bin/bash") + (entry "daemon:x:1:1:daemon:/usr/sbin:/bin/sh") + (entry "bin:x:2:2:bin:/bin:/bin/sh") + (entry "sys:x:3:3:sys:/dev:/bin/sh") + (entry "nobody:x:65534:65534:nobody:/nonexistent:/bin/sh") + (entry "messagebus:x:103:107::/var/run/dbus:/bin/false")) +@end lisp + +However, here is something to be wary of: + +@lisp +(peg:tree (match-pattern passwd "one entry")) @result{} +(entry "one entry") +@end lisp + +By default, the parse trees generated by PEGs are compressed as much as +possible without losing information. It may not look like this is what +you want at first, but uncompressed parse trees are an enormous headache +(there's no easy way to predict how deep particular lists will nest, +there are empty lists littered everywhere, etc. etc.). One side-effect +of this, however, is that sometimes the compressor is too aggressive. +No information is discarded when @code{((entry "one entry"))} is +compressed to @code{(entry "one entry")}, but in this particular case it +probably isn't what we want. + +There are two functions for easily dealing with this: +@code{keyword-flatten} and @code{context-flatten}. The +@code{keyword-flatten} function takes a list of keywords and a list to +flatten, then tries to coerce the list such that the first element of +all sublists is one of the keywords. The @code{context-flatten} +function is similar, but instead of a list of keywords it takes a +predicate that should indicate whether a given sublist is good enough +(refer to the API reference for more details). + +What we want here is @code{keyword-flatten}. +@lisp +(keyword-flatten '(entry) (peg:tree (match-pattern passwd *etc-passwd*))) @result{} +((entry "root:x:0:0:root:/root:/bin/bash") + (entry "daemon:x:1:1:daemon:/usr/sbin:/bin/sh") + (entry "bin:x:2:2:bin:/bin:/bin/sh") + (entry "sys:x:3:3:sys:/dev:/bin/sh") + (entry "nobody:x:65534:65534:nobody:/nonexistent:/bin/sh") + (entry "messagebus:x:103:107::/var/run/dbus:/bin/false")) +(keyword-flatten '(entry) (peg:tree (match-pattern passwd "one entry"))) @result{} +((entry "one entry")) +@end lisp + +Of course, this is a somewhat contrived example. In practice we would +probably just tag the @code{passwd} nonterminal to remove the ambiguity +(using either the @code{all} keyword for S-expressions or the @code{<--} +symbol for strings).. + +@lisp +(define-peg-pattern tag-passwd all (peg "entry* !.")) +(peg:tree (match-pattern tag-passwd *etc-passwd*)) @result{} +(tag-passwd + (entry "root:x:0:0:root:/root:/bin/bash") + (entry "daemon:x:1:1:daemon:/usr/sbin:/bin/sh") + (entry "bin:x:2:2:bin:/bin:/bin/sh") + (entry "sys:x:3:3:sys:/dev:/bin/sh") + (entry "nobody:x:65534:65534:nobody:/nonexistent:/bin/sh") + (entry "messagebus:x:103:107::/var/run/dbus:/bin/false")) +(peg:tree (match-pattern tag-passwd "one entry")) +(tag-passwd + (entry "one entry")) +@end lisp + +If you're ever uncertain about the potential results of parsing +something, remember the two absolute rules: +@enumerate +@item +No parsing information will ever be discarded. +@item +There will never be any lists with fewer than 2 elements. +@end enumerate + +For the purposes of (1), "parsing information" means things tagged with +the @code{any} keyword or the @code{<--} symbol. Plain strings will be +concatenated. + +Let's extend this example a bit more and actually pull some useful +information out of the passwd file: + +@lisp +(define-peg-string-patterns + "passwd <-- entry* !. +entry <-- login C pass C uid C gid C nameORcomment C homedir C shell NL* +login <-- text +pass <-- text +uid <-- [0-9]* +gid <-- [0-9]* +nameORcomment <-- text +homedir <-- path +shell <-- path +path <-- (SLASH pathELEMENT)* +pathELEMENT <-- (!NL !C !'/' .)* +text <- (!NL !C .)* +C < ':' +NL < '\n' +SLASH < '/'") +@end lisp + +This produces rather pretty parse trees: +@lisp +(passwd + (entry (login "root") + (pass "x") + (uid "0") + (gid "0") + (nameORcomment "root") + (homedir (path (pathELEMENT "root"))) + (shell (path (pathELEMENT "bin") (pathELEMENT "bash")))) + (entry (login "daemon") + (pass "x") + (uid "1") + (gid "1") + (nameORcomment "daemon") + (homedir + (path (pathELEMENT "usr") (pathELEMENT "sbin"))) + (shell (path (pathELEMENT "bin") (pathELEMENT "sh")))) + (entry (login "bin") + (pass "x") + (uid "2") + (gid "2") + (nameORcomment "bin") + (homedir (path (pathELEMENT "bin"))) + (shell (path (pathELEMENT "bin") (pathELEMENT "sh")))) + (entry (login "sys") + (pass "x") + (uid "3") + (gid "3") + (nameORcomment "sys") + (homedir (path (pathELEMENT "dev"))) + (shell (path (pathELEMENT "bin") (pathELEMENT "sh")))) + (entry (login "nobody") + (pass "x") + (uid "65534") + (gid "65534") + (nameORcomment "nobody") + (homedir (path (pathELEMENT "nonexistent"))) + (shell (path (pathELEMENT "bin") (pathELEMENT "sh")))) + (entry (login "messagebus") + (pass "x") + (uid "103") + (gid "107") + nameORcomment + (homedir + (path (pathELEMENT "var") + (pathELEMENT "run") + (pathELEMENT "dbus"))) + (shell (path (pathELEMENT "bin") (pathELEMENT "false"))))) +@end lisp + +Notice that when there's no entry in a field (e.g. @code{nameORcomment} +for messagebus) the symbol is inserted. This is the ``don't throw away +any information'' rule---we succesfully matched a @code{nameORcomment} +of 0 characters (since we used @code{*} when defining it). This is +usually what you want, because it allows you to e.g. use @code{list-ref} +to pull out elements (since they all have known offsets). + +If you'd prefer not to have symbols for empty matches, you can replace +the @code{*} with a @code{+} and add a @code{?} after the +@code{nameORcomment} in @code{entry}. Then it will try to parse 1 or +more characters, fail (inserting nothing into the parse tree), but +continue because it didn't have to match the nameORcomment to continue. + + +@subsubheading Embedding Arithmetic Expressions + +We can parse simple mathematical expressions with the following PEG: + +@lisp +(define-peg-string-patterns + "expr <- sum +sum <-- (product ('+' / '-') sum) / product +product <-- (value ('*' / '/') product) / value +value <-- number / '(' expr ')' +number <-- [0-9]+") +@end lisp + +Then: +@lisp +(peg:tree (match-pattern expr "1+1/2*3+(1+1)/2")) @result{} +(sum (product (value (number "1"))) + "+" + (sum (product + (value (number "1")) + "/" + (product + (value (number "2")) + "*" + (product (value (number "3"))))) + "+" + (sum (product + (value "(" + (sum (product (value (number "1"))) + "+" + (sum (product (value (number "1"))))) + ")") + "/" + (product (value (number "2"))))))) +@end lisp + +There is very little wasted effort in this PEG. The @code{number} +nonterminal has to be tagged because otherwise the numbers might run +together with the arithmetic expressions during the string concatenation +stage of parse-tree compression (the parser will see ``1'' followed by +``/'' and decide to call it ``1/''). When in doubt, tag. + +It is very easy to turn these parse trees into lisp expressions: + +@lisp +(define (parse-sum sum left . rest) + (if (null? rest) + (apply parse-product left) + (list (string->symbol (car rest)) + (apply parse-product left) + (apply parse-sum (cadr rest))))) + +(define (parse-product product left . rest) + (if (null? rest) + (apply parse-value left) + (list (string->symbol (car rest)) + (apply parse-value left) + (apply parse-product (cadr rest))))) + +(define (parse-value value first . rest) + (if (null? rest) + (string->number (cadr first)) + (apply parse-sum (car rest)))) + +(define parse-expr parse-sum) +@end lisp + +(Notice all these functions look very similar; for a more complicated +PEG, it would be worth abstracting.) + +Then: +@lisp +(apply parse-expr (peg:tree (match-pattern expr "1+1/2*3+(1+1)/2"))) @result{} +(+ 1 (+ (/ 1 (* 2 3)) (/ (+ 1 1) 2))) +@end lisp + +But wait! The associativity is wrong! Where it says @code{(/ 1 (* 2 +3))}, it should say @code{(* (/ 1 2) 3)}. + +It's tempting to try replacing e.g. @code{"sum <-- (product ('+' / '-') +sum) / product"} with @code{"sum <-- (sum ('+' / '-') product) / +product"}, but this is a Bad Idea. PEGs don't support left recursion. +To see why, imagine what the parser will do here. When it tries to +parse @code{sum}, it first has to try and parse @code{sum}. But to do +that, it first has to try and parse @code{sum}. This will continue +until the stack gets blown off. + +So how does one parse left-associative binary operators with PEGs? +Honestly, this is one of their major shortcomings. There's no +general-purpose way of doing this, but here the repetition operators are +a good choice: + +@lisp +(use-modules (srfi srfi-1)) + +(define-peg-string-patterns + "expr <- sum +sum <-- (product ('+' / '-'))* product +product <-- (value ('*' / '/'))* value +value <-- number / '(' expr ')' +number <-- [0-9]+") + +;; take a deep breath... +(define (make-left-parser next-func) + (lambda (sum first . rest) ;; general form, comments below assume + ;; that we're dealing with a sum expression + (if (null? rest) ;; form (sum (product ...)) + (apply next-func first) + (if (string? (cadr first));; form (sum ((product ...) "+") (product ...)) + (list (string->symbol (cadr first)) + (apply next-func (car first)) + (apply next-func (car rest))) + ;; form (sum (((product ...) "+") ((product ...) "+")) (product ...)) + (car + (reduce ;; walk through the list and build a left-associative tree + (lambda (l r) + (list (list (cadr r) (car r) (apply next-func (car l))) + (string->symbol (cadr l)))) + 'ignore + (append ;; make a list of all the products + ;; the first one should be pre-parsed + (list (list (apply next-func (caar first)) + (string->symbol (cadar first)))) + (cdr first) + ;; the last one has to be added in + (list (append rest '("done")))))))))) + +(define (parse-value value first . rest) + (if (null? rest) + (string->number (cadr first)) + (apply parse-sum (car rest)))) +(define parse-product (make-left-parser parse-value)) +(define parse-sum (make-left-parser parse-product)) +(define parse-expr parse-sum) +@end lisp + +Then: +@lisp +(apply parse-expr (peg:tree (match-pattern expr "1+1/2*3+(1+1)/2"))) @result{} +(+ (+ 1 (* (/ 1 2) 3)) (/ (+ 1 1) 2)) +@end lisp + +As you can see, this is much uglier (it could be made prettier by using +@code{context-flatten}, but the way it's written above makes it clear +how we deal with the three ways the zero-or-more @code{*} expression can +parse). Fortunately, most of the time we can get away with only using +right-associativity. + +@subsubheading Simplified Functions + +For a more tantalizing example, consider the following grammar that +parses (highly) simplified C functions: + +@lisp +(define-peg-string-patterns + "cfunc <-- cSP ctype cSP cname cSP cargs cLB cSP cbody cRB +ctype <-- cidentifier +cname <-- cidentifier +cargs <-- cLP (! (cSP cRP) carg cSP (cCOMMA / cRP) cSP)* cSP +carg <-- cSP ctype cSP cname +cbody <-- cstatement * +cidentifier <- [a-zA-z][a-zA-Z0-9_]* +cstatement <-- (!';'.)*cSC cSP +cSC < ';' +cCOMMA < ',' +cLP < '(' +cRP < ')' +cLB < '@{' +cRB < '@}' +cSP < [ \t\n]*") +@end lisp + +Then: +@lisp +(match-pattern cfunc "int square(int a) @{ return a*a;@}") @result{} +(32 + (cfunc (ctype "int") + (cname "square") + (cargs (carg (ctype "int") (cname "a"))) + (cbody (cstatement "return a*a")))) +@end lisp + +And: +@lisp +(match-pattern cfunc "int mod(int a, int b) @{ int c = a/b;return a-b*c; @}") @result{} +(52 + (cfunc (ctype "int") + (cname "mod") + (cargs (carg (ctype "int") (cname "a")) + (carg (ctype "int") (cname "b"))) + (cbody (cstatement "int c = a/b") + (cstatement "return a- b*c")))) +@end lisp + +By wrapping all the @code{carg} nonterminals in a @code{cargs} +nonterminal, we were able to remove any ambiguity in the parsing +structure and avoid having to call @code{context-flatten} on the output +of @code{match-pattern}. We used the same trick with the @code{cstatement} +nonterminals, wrapping them in a @code{cbody} nonterminal. + +The whitespace nonterminal @code{cSP} used here is a (very) useful +instantiation of a common pattern for matching syntactically irrelevant +information. Since it's tagged with @code{<} and ends with @code{*} it +won't clutter up the parse trees (all the empty lists will be discarded +during the compression step) and it will never cause parsing to fail. + +@node PEG Internals +@subsection PEG Internals + +A PEG parser takes a string as input and attempts to parse it as a given +nonterminal. The key idea of the PEG implementation is that every +nonterminal is just a function that takes a string as an argument and +attempts to parse that string as its nonterminal. The functions always +start from the beginning, but a parse is considered successful if there +is material left over at the end. + +This makes it easy to model different PEG parsing operations. For +instance, consider the PEG grammar @code{"ab"}, which could also be +written @code{(and "a" "b")}. It matches the string ``ab''. Here's how +that might be implemented in the PEG style: + +@lisp +(define (match-and-a-b str) + (match-a str) + (match-b str)) +@end lisp + +As you can see, the use of functions provides an easy way to model +sequencing. In a similar way, one could model @code{(or a b)} with +something like the following: + +@lisp +(define (match-or-a-b str) + (or (match-a str) (match-b str))) +@end lisp + +Here the semantics of a PEG @code{or} expression map naturally onto +Scheme's @code{or} operator. This function will attempt to run +@code{(match-a str)}, and return its result if it succeeds. Otherwise it +will run @code{(match-b str)}. + +Of course, the code above wouldn't quite work. We need some way for the +parsing functions to communicate. The actual interface used is below. + +@subsubheading Parsing Function Interface + +A parsing function takes three arguments - a string, the length of that +string, and the position in that string it should start parsing at. In +effect, the parsing functions pass around substrings in pieces - the +first argument is a buffer of characters, and the second two give a +range within that buffer that the parsing function should look at. + +Parsing functions return either #f, if they failed to match their +nonterminal, or a list whose first element must be an integer +representing the final position in the string they matched and whose cdr +can be any other data the function wishes to return, or '() if it +doesn't have any more data. + +The one caveat is that if the extra data it returns is a list, any +adjacent strings in that list will be appended by @code{match-pattern}. For +instance, if a parsing function returns @code{(13 ("a" "b" "c"))}, +@code{match-pattern} will take @code{(13 ("abc"))} as its value. + +For example, here is a function to match ``ab'' using the actual +interface. + +@lisp +(define (match-a-b str len pos) + (and (<= (+ pos 2) len) + (string= str "ab" pos (+ pos 2)) + (list (+ pos 2) '()))) ; we return no extra information +@end lisp + +The above function can be used to match a string by running +@code{(match-pattern match-a-b "ab")}. + +@subsubheading Code Generators and Extensible Syntax + +PEG expressions, such as those in a @code{define-peg-pattern} form, are +interpreted internally in two steps. + +First, any string PEG is expanded into an s-expression PEG by the code +in the @code{(ice-9 peg string-peg)} module. + +Then, then s-expression PEG that results is compiled into a parsing +function by the @code{(ice-9 peg codegen)} module. In particular, the +function @code{compile-peg-pattern} is called on the s-expression. It then +decides what to do based on the form it is passed. + +The PEG syntax can be expanded by providing @code{compile-peg-pattern} more +options for what to do with its forms. The extended syntax will be +associated with a symbol, for instance @code{my-parsing-form}, and will +be called on all PEG expressions of the form +@lisp +(my-parsing-form ...) +@end lisp + +The parsing function should take two arguments. The first will be a +syntax object containing a list with all of the arguments to the form +(but not the form's name), and the second will be the +@code{capture-type} argument that is passed to @code{define-peg-pattern}. + +New functions can be registered by calling @code{(add-peg-compiler! +symbol function)}, where @code{symbol} is the symbol that will indicate +a form of this type and @code{function} is the code generating function +described above. The function @code{add-peg-compiler!} is exported from +the @code{(ice-9 peg codegen)} module. diff --git a/doc/ref/compiler.texi b/doc/ref/compiler.texi index 0fe75e3e3..1d730b79c 100644 --- a/doc/ref/compiler.texi +++ b/doc/ref/compiler.texi @@ -1,6 +1,6 @@ @c -*-texinfo-*- @c This is part of the GNU Guile Reference Manual. -@c Copyright (C) 2008, 2009, 2010, 2013 +@c Copyright (C) 2008, 2009, 2010, 2011, 2012, 2013 @c Free Software Foundation, Inc. @c See the file guile.texi for copying conditions. @@ -160,12 +160,11 @@ different worlds indefinitely, as shown by the following quine: @node The Scheme Compiler @subsection The Scheme Compiler -The job of the Scheme compiler is to expand all macros and all of -Scheme to its most primitive expressions. The definition of -``primitive'' is given by the inventory of constructs provided by -Tree-IL, the target language of the Scheme compiler: procedure -applications, conditionals, lexical references, etc. This is described -more fully in the next section. +The job of the Scheme compiler is to expand all macros and all of Scheme +to its most primitive expressions. The definition of ``primitive'' is +given by the inventory of constructs provided by Tree-IL, the target +language of the Scheme compiler: procedure calls, conditionals, lexical +references, etc. This is described more fully in the next section. The tricky and amusing thing about the Scheme-to-Tree-IL compiler is that it is completely implemented by the macro expander. Since the @@ -183,10 +182,10 @@ The Scheme-to-Tree-IL expander may be invoked using the generic @lisp (compile '(+ 1 2) #:from 'scheme #:to 'tree-il) @result{} - #<<application> src: #f - proc: #<<toplevel-ref> src: #f name: +> - args: (#<<const> src: #f exp: 1> - #<<const> src: #f exp: 2>)> + #<<call> src: #f + proc: #<<toplevel-ref> src: #f name: +> + args: (#<<const> src: #f exp: 1> + #<<const> src: #f exp: 2>)> @end lisp Or, since Tree-IL is so close to Scheme, it is often useful to expand @@ -341,9 +340,9 @@ instruction. Compilation of Tree-IL usually begins with a pass that resolves some @code{<module-ref>} and @code{<toplevel-ref>} expressions to -@code{<primitive-ref>} expressions. The actual compilation pass -has special cases for applications of certain primitives, like -@code{apply} or @code{cons}. +@code{<primitive-ref>} expressions. The actual compilation pass has +special cases for calls to certain primitives, like @code{apply} or +@code{cons}. @end deftp @deftp {Scheme Variable} <lexical-ref> src name gensym @deftpx {External Representation} (lexical @var{name} @var{gensym}) @@ -387,10 +386,19 @@ Defines a new top-level variable in the current procedure's module. @deftpx {External Representation} (if @var{test} @var{then} @var{else}) A conditional. Note that @var{else} is not optional. @end deftp -@deftp {Scheme Variable} <application> src proc args -@deftpx {External Representation} (apply @var{proc} . @var{args}) +@deftp {Scheme Variable} <call> src proc args +@deftpx {External Representation} (call @var{proc} . @var{args}) A procedure call. @end deftp +@deftp {Scheme Variable} <primcall> src name args +@deftpx {External Representation} (primcall @var{name} . @var{args}) +A call to a primitive. Equivalent to @code{(call (primitive @var{name}) +. @var{args})}. This construct is often more convenient to generate and +analyze than @code{<call>}. + +As part of the compilation process, instances of @code{(call (primitive +@var{name}) . @var{args})} are transformed into primcalls. +@end deftp @deftp {Scheme Variable} <sequence> src exps @deftpx {External Representation} (begin . @var{exps}) Like Scheme's @code{begin}. @@ -467,12 +475,15 @@ expression evaluating to a fluid. A dynamic variable set. @var{fluid}, a Tree-IL expression evaluating to a fluid, will be set to the result of evaluating @var{exp}. @end deftp -@deftp {Scheme Variable} <dynwind> winder body unwinder -@deftpx {External Representation} (dynwind @var{winder} @var{body} @var{unwinder}) +@deftp {Scheme Variable} <dynwind> winder pre body post unwinder +@deftpx {External Representation} (dynwind @var{winder} @var{pre} @var{body} @var{post} @var{unwinder}) A @code{dynamic-wind}. @var{winder} and @var{unwinder} should both -evaluate to thunks. Ensure that the winder and the unwinder are called -before entering and after leaving @var{body}. Note that @var{body} is -an expression, without a thunk wrapper. +evaluate to thunks. Ensure that the winder and the unwinder are called +before entering and after leaving @var{body}. Note that @var{body} is +an expression, without a thunk wrapper. Guile actually inlines the +bodies of @var{winder} and @var{unwinder} for the case of normal control +flow, compiling the expressions in @var{pre} and @var{post}, +respectively. @end deftp @deftp {Scheme Variable} <prompt> tag body handler @deftpx {External Representation} (prompt @var{tag} @var{body} @var{handler}) @@ -508,7 +519,7 @@ Like Scheme's @code{receive} -- binds the values returned by evaluating @code{exp} to the @code{lambda}-like bindings described by @var{gensyms}. That is to say, @var{gensyms} may be an improper list. -@code{<let-values>} is an optimization of @code{<application>} of the +@code{<let-values>} is an optimization of a @code{<call>} to the primitive, @code{call-with-values}. @end deftp @deftp {Scheme Variable} <fix> src names gensyms vals body @@ -791,29 +802,36 @@ objcode)} module. Returns @code{#f} iff @var{obj} is object code, @code{#f} otherwise. @end deffn -@deffn {Scheme Procedure} bytecode->objcode bytecode +@deffn {Scheme Procedure} bytecode->objcode bytecode [endianness] @deffnx {C Function} scm_bytecode_to_objcode (bytecode) Makes a bytecode object from @var{bytecode}, which should be a -bytevector. @xref{Bytevectors}. +bytevector. @xref{Bytevectors}. By default, the embedded length fields +in the bytevector are interpreted in the native byte order. @end deffn -@deffn {Scheme Variable} load-objcode file -@deffnx {C Function} scm_load_objcode (file) +@deffn {Scheme Variable} load-thunk-from-file file +@deffnx {C Function} scm_load_thunk_from_file (file) Load object code from a file named @var{file}. The file will be mapped into memory via @code{mmap}, so this is a very fast operation. -On disk, object code has an sixteen-byte cookie prepended to it, to -prevent accidental loading of arbitrary garbage. +On disk, object code is embedded in ELF, a flexible container format +created for use in UNIX systems. Guile has its own ELF linker and +loader, so it uses the ELF format on all systems. @end deffn @deffn {Scheme Variable} write-objcode objcode file @deffnx {C Function} scm_write_objcode (objcode) -Write object code out to a file, prepending the sixteen-byte cookie. +Embed object code into an ELF container, and write it out to a file. + +This procedure is part of a separate module, @code{(language objcode +elf)}. @end deffn -@deffn {Scheme Variable} objcode->bytecode objcode +@deffn {Scheme Variable} objcode->bytecode objcode [endianness] @deffnx {C Function} scm_objcode_to_bytecode (objcode) -Copy object code out to a bytevector for analysis by Scheme. +Copy object code out to a bytevector for analysis by Scheme. By +default, the length fields in the @code{struct scm_objcode} are +interpreted in the native byte order. @end deffn The following procedure is actually in @code{(system vm program)}, but diff --git a/doc/ref/guile.texi b/doc/ref/guile.texi index a6e3e7d0c..262cd645f 100644 --- a/doc/ref/guile.texi +++ b/doc/ref/guile.texi @@ -308,6 +308,7 @@ available through both Scheme and C interfaces. * Input and Output:: Ports, reading and writing. * Regular Expressions:: Pattern matching and substitution. * LALR(1) Parsing:: Generating LALR(1) parsers. +* PEG Parsing:: Parsing Expression Grammars. * Read/Load/Eval/Compile:: Reading and evaluating Scheme code. * Memory Management:: Memory management and garbage collection. * Modules:: Designing reusable code libraries. @@ -336,6 +337,7 @@ available through both Scheme and C interfaces. @include api-io.texi @include api-regex.texi @include api-lalr.texi +@include api-peg.texi @include api-evaluation.texi @include api-memory.texi @include api-modules.texi diff --git a/doc/ref/libguile-concepts.texi b/doc/ref/libguile-concepts.texi index 50c435584..0103ad173 100644 --- a/doc/ref/libguile-concepts.texi +++ b/doc/ref/libguile-concepts.texi @@ -1,7 +1,7 @@ @c -*-texinfo-*- @c This is part of the GNU Guile Reference Manual. -@c Copyright (C) 1996, 1997, 2000, 2001, 2002, 2003, 2004, 2005, 2010, 2013 -@c Free Software Foundation, Inc. +@c Copyright (C) 1996, 1997, 2000, 2001, 2002, 2003, 2004, 2005, 2010, +@c 2011, 2013 Free Software Foundation, Inc. @c See the file guile.texi for copying conditions. @node General Libguile Concepts @@ -449,16 +449,18 @@ that are stored in local variables. When a thread puts itself into guile mode for the first time, it gets a Scheme representation and is listed by @code{all-threads}, for example. -Threads in guile mode can block (e.g., do blocking I/O) without causing any -problems@footnote{In Guile 1.8, a thread blocking in guile mode would prevent -garbage collection to occur. Thus, threads had to leave guile mode whenever -they could block. This is no longer needed with Guile 2.0.}; temporarily -leaving guile mode with @code{scm_without_guile} before blocking slightly -improves GC performance, though. For some common blocking operations, Guile -provides convenience functions. For example, if you want to lock a pthread -mutex while in guile mode, you might want to use @code{scm_pthread_mutex_lock} -which is just like @code{pthread_mutex_lock} except that it leaves guile mode -while blocking. +Threads in guile mode can block (e.g., do blocking I/O) without causing +any problems@footnote{In Guile 1.8, a thread blocking in guile mode +would prevent garbage collection to occur. Thus, threads had to leave +guile mode whenever they could block. This is no longer needed with +Guile 2.@var{x}.}; temporarily leaving guile mode with +@code{scm_without_guile} before blocking slightly improves GC +performance, though. For some common blocking operations, Guile +provides convenience functions. For example, if you want to lock a +pthread mutex while in guile mode, you might want to use +@code{scm_pthread_mutex_lock} which is just like +@code{pthread_mutex_lock} except that it leaves guile mode while +blocking. All libguile functions are (intended to be) robust in the face of diff --git a/doc/ref/posix.texi b/doc/ref/posix.texi index 18aadca85..a019f4edd 100644 --- a/doc/ref/posix.texi +++ b/doc/ref/posix.texi @@ -1788,10 +1788,11 @@ the integer process ID of the child. Note that it is unsafe to fork a process that has multiple threads running, as only the thread that calls @code{primitive-fork} will persist in the child. Any resources that other threads held, such as -locked mutexes or open file descriptors, are lost. Indeed, @acronym{POSIX} -specifies that only async-signal-safe procedures are safe to call after -a multithreaded fork, which is a very limited set. Guile issues a -warning if it detects a fork from a multi-threaded program. +locked mutexes or open file descriptors, are lost. Indeed, +@acronym{POSIX} specifies that only async-signal-safe procedures are +safe to call after a multithreaded fork, which is a very limited set. +Guile issues a warning if it detects a fork from a multi-threaded +program. If you are going to @code{exec} soon after forking, the procedures in @code{(ice-9 popen)} may be useful to you, as they fork and exec within diff --git a/doc/ref/srfi-modules.texi b/doc/ref/srfi-modules.texi index dff8ca986..17b1918bf 100644 --- a/doc/ref/srfi-modules.texi +++ b/doc/ref/srfi-modules.texi @@ -172,8 +172,8 @@ how to load it with the Guile mechanism. @cindex @code{guile-2} SRFI-0 feature @cindex portability between 2.0 and older versions Likewise, testing the @code{guile-2} feature allows code to be portable -between Guile 2.0 and previous versions of Guile. For instance, it -makes it possible to write code that accounts for Guile 2.0's compiler, +between Guile 2.@var{x} and previous versions of Guile. For instance, it +makes it possible to write code that accounts for Guile 2.@var{x}'s compiler, yet be correctly interpreted on 1.8 and earlier versions: @example diff --git a/doc/ref/vm.texi b/doc/ref/vm.texi index 9936ad97d..76e3ab9ff 100644 --- a/doc/ref/vm.texi +++ b/doc/ref/vm.texi @@ -1,6 +1,6 @@ @c -*-texinfo-*- @c This is part of the GNU Guile Reference Manual. -@c Copyright (C) 2008,2009,2010,2013 +@c Copyright (C) 2008,2009,2010,2011,2013 @c Free Software Foundation, Inc. @c See the file guile.texi for copying conditions. @@ -79,9 +79,9 @@ but it is not normally used at runtime.) The upside of implementing the interpreter in Scheme is that we preserve tail calls and multiple-value handling between interpreted and compiled -code. The downside is that the interpreter in Guile 2.0 is slower than -the interpreter in 1.8. We hope the that the compiler's speed makes up -for the loss! +code. The downside is that the interpreter in Guile 2.@var{x} is slower +than the interpreter in 1.8. We hope the that the compiler's speed makes +up for the loss! Also note that this decision to implement a bytecode compiler does not preclude native compilation. We can compile from bytecode to native diff --git a/guile-readline/readline.c b/guile-readline/readline.c index 0e4ad2902..1e697eb5d 100644 --- a/guile-readline/readline.c +++ b/guile-readline/readline.c @@ -1,6 +1,6 @@ /* readline.c --- line editing support for Guile */ -/* Copyright (C) 1997,1999,2000,2001, 2002, 2003, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. +/* Copyright (C) 1997,1999,2000,2001, 2002, 2003, 2006, 2007, 2008, 2009, 2010, 2013 Free Software Foundation, Inc. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -257,12 +257,7 @@ internal_readline (SCM text) promptp = 1; s = readline (prompt); if (s) - { - scm_t_port *pt = SCM_PTAB_ENTRY (output_port); - - ret = scm_from_stringn (s, strlen (s), pt->encoding, - SCM_FAILED_CONVERSION_ESCAPE_SEQUENCE); - } + ret = scm_from_port_string (s, output_port); else ret = SCM_EOF_VAL; diff --git a/libguile.h b/libguile.h index fefca435b..9a9742919 100644 --- a/libguile.h +++ b/libguile.h @@ -116,7 +116,9 @@ extern "C" { #include "libguile/srfi-4.h" #include "libguile/version.h" #include "libguile/vports.h" -#include "libguile/weaks.h" +#include "libguile/weak-set.h" +#include "libguile/weak-table.h" +#include "libguile/weak-vector.h" #include "libguile/backtrace.h" #include "libguile/debug.h" #include "libguile/stacks.h" diff --git a/libguile/Makefile.am b/libguile/Makefile.am index f020595e2..d42c650ae 100644 --- a/libguile/Makefile.am +++ b/libguile/Makefile.am @@ -133,6 +133,7 @@ libguile_@GUILE_EFFECTIVE_VERSION@_la_SOURCES = \ debug.c \ deprecated.c \ deprecation.c \ + dynstack.c \ dynwind.c \ eq.c \ error.c \ @@ -219,7 +220,9 @@ libguile_@GUILE_EFFECTIVE_VERSION@_la_SOURCES = \ version.c \ vm.c \ vports.c \ - weaks.c + weak-set.c \ + weak-table.c \ + weak-vector.c DOT_X_FILES = \ alist.x \ @@ -315,7 +318,9 @@ DOT_X_FILES = \ vectors.x \ version.x \ vports.x \ - weaks.x + weak-set.x \ + weak-table.x \ + weak-vector.x # vm-related snarfs DOT_X_FILES += frames.x instructions.x objcodes.x programs.x vm.x @@ -416,7 +421,9 @@ DOT_DOC_FILES = \ vectors.doc \ version.doc \ vports.doc \ - weaks.doc + weak-set.doc \ + weak-table.doc \ + weak-vector.doc EXTRA_DOT_DOC_FILES = @EXTRA_DOT_DOC_FILES@ @@ -448,6 +455,7 @@ install-exec-hook: ## Perhaps we can deal with them normally once the merge seems to be ## working. noinst_HEADERS = conv-integer.i.c conv-uinteger.i.c \ + elf.h \ srfi-14.i.c \ quicksort.i.c \ win32-uname.h win32-socket.h \ @@ -524,6 +532,7 @@ modinclude_HEADERS = \ deprecated.h \ deprecation.h \ dynl.h \ + dynstack.h \ dynwind.h \ eq.h \ error.h \ @@ -620,7 +629,9 @@ modinclude_HEADERS = \ vm-expand.h \ vm.h \ vports.h \ - weaks.h + weak-set.h \ + weak-table.h \ + weak-vector.h nodist_modinclude_HEADERS = version.h scmconfig.h diff --git a/libguile/__scm.h b/libguile/__scm.h index 47ed12b75..b42b82397 100644 --- a/libguile/__scm.h +++ b/libguile/__scm.h @@ -146,37 +146,6 @@ #endif -/* {Supported Options} - * - * These may be defined or undefined. - */ - -/* #define GUILE_DEBUG_FREELIST */ - - -/* Use engineering notation when converting numbers strings? - */ -#undef ENGNOT - - -/* {Unsupported Options} - * - * These must be defined as given here. - */ - - -/* Guile Scheme supports the #f/() distinction; Guile Lisp won't. We - have horrible plans for their unification. */ -#undef SICP - - - -/* Random options (not yet supported or in final form). */ - -#define STACK_CHECKING -#undef NO_CEVAL_STACK_CHECKING - - /* SCM_API is a macro prepended to all function and data definitions which should be exported from libguile. */ @@ -279,14 +248,6 @@ #define SCM_DEBUG 0 #endif -/* For debugging purposes: define this is to ensure nobody is using - * the mark bits outside of the marking phase. This is meant for - * debugging purposes only. - */ -#ifndef SCM_DEBUG_MARKING_API -#define SCM_DEBUG_MARKING_API 0 -#endif - /* If SCM_DEBUG_CELL_ACCESSES is set to 1, cell accesses will perform * exhaustive parameter checking: It will be verified that cell parameters * actually point to a valid heap cell. Note: If this option is enabled, @@ -296,13 +257,6 @@ #define SCM_DEBUG_CELL_ACCESSES SCM_DEBUG #endif -/* If SCM_DEBUG_INTERRUPTS is set to 1, with every deferring and allowing of - * interrupts a consistency check will be performed. - */ -#ifndef SCM_DEBUG_INTERRUPTS -#define SCM_DEBUG_INTERRUPTS SCM_DEBUG -#endif - /* If SCM_DEBUG_PAIR_ACCESSES is set to 1, accesses to cons cells will be * exhaustively checked. Note: If this option is enabled, guile will run * slower than normally. @@ -345,22 +299,6 @@ #define SCM_DEBUG_TYPING_STRICTNESS 1 #endif -/* If SCM_DEBUG_DEBUGGING_SUPPORT is set to 1, guile will provide a set of - * special functions that support debugging with a debugger like gdb or - * debugging of guile internals on the scheme level. The behaviour of guile - * is not changed by this macro, only the set of functions that are available - * will differ. All functions that are introduced this way have the prefix - * 'scm_dbg_' on the C level and the prefix 'dbg-' on the scheme level. This - * allows to easily determine the set of support functions, given that your - * debugger or repl provide automatic name completion. Note that these - * functions are intended to be used during interactive debugging sessions - * only. They are not considered part of guile's official API. They may - * change or disappear without notice or deprecation phase. - */ -#ifndef SCM_DEBUG_DEBUGGING_SUPPORT -#define SCM_DEBUG_DEBUGGING_SUPPORT SCM_DEBUG -#endif - /* {Feature Options} @@ -456,12 +394,6 @@ #define SCM_T_INT64_MIN SCM_I_TYPE_MIN(scm_t_int64,SCM_T_UINT64_MAX) #define SCM_T_INT64_MAX SCM_I_TYPE_MAX(scm_t_int64,SCM_T_UINT64_MAX) -#if SCM_SIZEOF_LONG_LONG -#define SCM_I_ULLONG_MAX SCM_I_UTYPE_MAX(unsigned long long) -#define SCM_I_LLONG_MIN SCM_I_TYPE_MIN(long long,SCM_I_ULLONG_MAX) -#define SCM_I_LLONG_MAX SCM_I_TYPE_MAX(long long,SCM_I_ULLONG_MAX) -#endif - #define SCM_T_UINTMAX_MAX SCM_I_UTYPE_MAX(scm_t_uintmax) #define SCM_T_INTMAX_MIN SCM_I_TYPE_MIN(scm_t_intmax,SCM_T_UINTMAX_MAX) #define SCM_T_INTMAX_MAX SCM_I_TYPE_MAX(scm_t_intmax,SCM_T_UINTMAX_MAX) @@ -470,10 +402,6 @@ #define SCM_T_INTPTR_MIN SCM_I_TYPE_MIN(scm_t_intptr,SCM_T_UINTPTR_MAX) #define SCM_T_INTPTR_MAX SCM_I_TYPE_MAX(scm_t_intptr,SCM_T_UINTPTR_MAX) -#define SCM_I_SIZE_MAX SCM_I_UTYPE_MAX(size_t) -#define SCM_I_SSIZE_MIN SCM_I_TYPE_MIN(ssize_t,SCM_I_SIZE_MAX) -#define SCM_I_SSIZE_MAX SCM_I_TYPE_MAX(ssize_t,SCM_I_SIZE_MAX) - #include "libguile/tags.h" @@ -492,64 +420,35 @@ typedef void *scm_t_subr; #endif -#ifdef vms -# ifndef CHEAP_CONTINUATIONS - typedef int jmp_buf[17]; - extern int setjump(jmp_buf env); - extern int longjump(jmp_buf env, int ret); -# define setjmp setjump -# define longjmp longjump -# else -# include <setjmp.h> -# endif -#else /* ndef vms */ -# ifdef _CRAY1 - typedef int jmp_buf[112]; - extern int setjump(jmp_buf env); - extern int longjump(jmp_buf env, int ret); -# define setjmp setjump -# define longjmp longjump -# else /* ndef _CRAY1 */ -# if defined (__ia64__) -/* For IA64, emulate the setjmp API using getcontext. */ -# include <signal.h> -# include <ucontext.h> - typedef struct { - ucontext_t ctx; - int fresh; - } scm_i_jmp_buf; -# define SCM_I_SETJMP(JB) \ - ( (JB).fresh = 1, \ - getcontext (&((JB).ctx)), \ - ((JB).fresh ? ((JB).fresh = 0, 0) : 1) ) -# define SCM_I_LONGJMP(JB,VAL) scm_ia64_longjmp (&(JB), VAL) - void scm_ia64_longjmp (scm_i_jmp_buf *, int); -# else /* ndef __ia64__ */ -# include <setjmp.h> -# endif /* ndef __ia64__ */ -# endif /* ndef _CRAY1 */ -#endif /* ndef vms */ - -/* For any platform where SCM_I_SETJMP hasn't been defined in some - special way above, map SCM_I_SETJMP, SCM_I_LONGJMP and - scm_i_jmp_buf to setjmp, longjmp and jmp_buf. */ -#ifndef SCM_I_SETJMP -#define scm_i_jmp_buf jmp_buf -#define SCM_I_SETJMP setjmp -#define SCM_I_LONGJMP longjmp -#endif -/* James Clark came up with this neat one instruction fix for - * continuations on the SPARC. It flushes the register windows so - * that all the state of the process is contained in the stack. +/* scm_i_jmp_buf + * + * The corresponding SCM_I_SETJMP and SCM_I_LONGJMP are defined in the + * _scm.h private header. */ -#if defined (sparc) || defined (__sparc__) || defined (__sparc) -# define SCM_FLUSH_REGISTER_WINDOWS asm("ta 3") +#if defined (vms) +typedef int scm_i_jmp_buf[17]; + +#elif defined (_CRAY1) +typedef int scm_i_jmp_buf[112]; + +#elif defined (__ia64__) +# include <signal.h> +# include <ucontext.h> +typedef struct { + ucontext_t ctx; + int fresh; +} scm_i_jmp_buf; + #else -# define SCM_FLUSH_REGISTER_WINDOWS /* empty */ +# include <setjmp.h> +typedef jmp_buf scm_i_jmp_buf; #endif + + + /* If stack is not longword aligned then */ @@ -575,147 +474,14 @@ typedef long SCM_STACKITEM; #define SCM_STACK_PTR(ptr) ((SCM_STACKITEM *) (void *) (ptr)) -SCM_API void scm_async_tick (void); - #ifdef BUILDING_LIBGUILE - -/* FIXME: should change names */ -# define SCM_ASYNC_TICK \ - do \ - { \ - if (SCM_UNLIKELY (SCM_I_CURRENT_THREAD->pending_asyncs)) \ - scm_async_click (); \ - } \ - while (0) - -/* SCM_ASYNC_TICK_WITH_CODE is only available to Guile itself */ -# define SCM_ASYNC_TICK_WITH_CODE(thr, stmt) \ - do \ - { \ - if (SCM_UNLIKELY (thr->pending_asyncs)) \ - { \ - stmt; \ - scm_async_click (); \ - } \ - } \ - while (0) - -#else /* !BUILDING_LIBGUILE */ - -# define SCM_ASYNC_TICK (scm_async_tick ()) - -#endif /* !BUILDING_LIBGUILE */ - - -/* Anthony Green writes: - When the compiler sees... - DEFER_INTS; - [critical code here] - ALLOW_INTS; - ...it doesn't actually promise to keep the critical code within the - boundries of the DEFER/ALLOW_INTS instructions. It may very well - schedule it outside of the magic defined in those macros. - - However, GCC's volatile asm feature forms a barrier over which code is - never moved. So if you add... - asm (""); - ...to each of the DEFER_INTS and ALLOW_INTS macros, the critical - code will always remain in place. asm's without inputs or outputs - are implicitly volatile. */ -#ifdef __GNUC__ -#define SCM_FENCE asm /* volatile */ ("") -#elif defined (__INTEL_COMPILER) && defined (__ia64) -#define SCM_FENCE __memory_barrier() +#define SCM_TICK SCM_ASYNC_TICK #else -#define SCM_FENCE +#define SCM_TICK scm_async_tick () #endif -#define SCM_TICK \ -do { \ - SCM_ASYNC_TICK; \ - SCM_THREAD_SWITCHING_CODE; \ -} while (0) - -/** SCM_ASSERT - ** - **/ - - -#ifdef SCM_RECKLESS -#define SCM_ASSERT(_cond, _arg, _pos, _subr) -#define SCM_ASSERT_TYPE(_cond, _arg, _pos, _subr, _msg) -#else -#define SCM_ASSERT(_cond, _arg, _pos, _subr) \ - do { if (SCM_UNLIKELY (!(_cond))) \ - scm_wrong_type_arg (_subr, _pos, _arg); } while (0) -#define SCM_ASSERT_TYPE(_cond, _arg, _pos, _subr, _msg) \ - do { if (SCM_UNLIKELY (!(_cond))) \ - scm_wrong_type_arg_msg(_subr, _pos, _arg, _msg); } while (0) -#endif - -/* - * SCM_WTA_DISPATCH - */ - -/* Dirk:FIXME:: In all of the SCM_WTA_DISPATCH_* macros it is assumed that - * 'gf' is zero if uninitialized. It would be cleaner if some valid SCM value - * like SCM_BOOL_F or SCM_UNDEFINED was chosen. - */ - -SCM_API SCM scm_call_generic_0 (SCM gf); - -#define SCM_WTA_DISPATCH_0(gf, subr) \ - return (SCM_UNPACK (gf) \ - ? scm_call_generic_0 ((gf)) \ - : (scm_error_num_args_subr ((subr)), SCM_UNSPECIFIED)) -#define SCM_GASSERT0(cond, gf, subr) \ - if (SCM_UNLIKELY(!(cond))) \ - SCM_WTA_DISPATCH_0((gf), (subr)) - -SCM_API SCM scm_call_generic_1 (SCM gf, SCM a1); - -#define SCM_WTA_DISPATCH_1(gf, a1, pos, subr) \ - return (SCM_UNPACK (gf) \ - ? scm_call_generic_1 ((gf), (a1)) \ - : (scm_wrong_type_arg ((subr), (pos), (a1)), SCM_UNSPECIFIED)) - -/* This form is for dispatching a subroutine. */ -#define SCM_WTA_DISPATCH_1_SUBR(subr, a1, pos) \ - return (SCM_UNPACK ((*SCM_SUBR_GENERIC (subr))) \ - ? scm_call_generic_1 ((*SCM_SUBR_GENERIC (subr)), (a1)) \ - : (scm_i_wrong_type_arg_symbol (SCM_SUBR_NAME (subr), (pos), (a1)), SCM_UNSPECIFIED)) - -#define SCM_GASSERT1(cond, gf, a1, pos, subr) \ - if (SCM_UNLIKELY (!(cond))) \ - SCM_WTA_DISPATCH_1((gf), (a1), (pos), (subr)) - -SCM_API SCM scm_call_generic_2 (SCM gf, SCM a1, SCM a2); - -#define SCM_WTA_DISPATCH_2(gf, a1, a2, pos, subr) \ - return (SCM_UNPACK (gf) \ - ? scm_call_generic_2 ((gf), (a1), (a2)) \ - : (scm_wrong_type_arg ((subr), (pos), \ - (pos) == SCM_ARG1 ? (a1) : (a2)), \ - SCM_UNSPECIFIED)) -#define SCM_GASSERT2(cond, gf, a1, a2, pos, subr) \ - if (SCM_UNLIKELY (!(cond))) \ - SCM_WTA_DISPATCH_2((gf), (a1), (a2), (pos), (subr)) - -SCM_API SCM scm_apply_generic (SCM gf, SCM args); - -#define SCM_WTA_DISPATCH_n(gf, args, pos, subr) \ - return (SCM_UNPACK (gf) \ - ? scm_apply_generic ((gf), (args)) \ - : (scm_wrong_type_arg ((subr), (pos), \ - scm_list_ref ((args), \ - scm_from_int ((pos) - 1))), \ - SCM_UNSPECIFIED)) -#define SCM_GASSERTn(cond, gf, args, pos, subr) \ - if (SCM_UNLIKELY (!(cond))) \ - SCM_WTA_DISPATCH_n((gf), (args), (pos), (subr)) - #ifndef SCM_MAGIC_SNARFER /* Let these macros pass through if we are snarfing; thus we can tell the @@ -738,27 +504,6 @@ SCM_API SCM scm_apply_generic (SCM gf, SCM args); -/* SCM_EXIT_SUCCESS is the default code to return from SCM if no errors - * were encountered. SCM_EXIT_FAILURE is the default code to return from - * SCM if errors were encountered. The return code can be explicitly - * specified in a SCM program with (scm_quit <n>). - */ - -#ifndef SCM_EXIT_SUCCESS -#ifdef vms -#define SCM_EXIT_SUCCESS 1 -#else -#define SCM_EXIT_SUCCESS 0 -#endif /* def vms */ -#endif /* ndef SCM_EXIT_SUCCESS */ -#ifndef SCM_EXIT_FAILURE -#ifdef vms -#define SCM_EXIT_FAILURE 2 -#else -#define SCM_EXIT_FAILURE 1 -#endif /* def vms */ -#endif /* ndef SCM_EXIT_FAILURE */ - /* Define SCM_C_INLINE_KEYWORD so that it can be used as a replacement for the "inline" keyword, expanding to nothing when "inline" is not available. diff --git a/libguile/_scm.h b/libguile/_scm.h index 5b4f3b7a9..7dd188d33 100644 --- a/libguile/_scm.h +++ b/libguile/_scm.h @@ -190,12 +190,71 @@ #define scm_to_off64_t scm_to_int64 #define scm_from_off64_t scm_from_int64 + + + +#if defined (vms) +/* VMS: Implement SCM_I_SETJMP in terms of setjump. */ +extern int setjump(scm_i_jmp_buf env); +extern int longjump(scm_i_jmp_buf env, int ret); +#define SCM_I_SETJMP setjump +#define SCM_I_LONGJMP longjump + +#elif defined (_CRAY1) +/* Cray: Implement SCM_I_SETJMP in terms of setjump. */ +extern int setjump(scm_i_jmp_buf env); +extern int longjump(scm_i_jmp_buf env, int ret); +#define SCM_I_SETJMP setjump +#define SCM_I_LONGJMP longjump + +#elif defined (__ia64__) +/* IA64: Implement SCM_I_SETJMP in terms of getcontext. */ +# define SCM_I_SETJMP(JB) \ + ( (JB).fresh = 1, \ + getcontext (&((JB).ctx)), \ + ((JB).fresh ? ((JB).fresh = 0, 0) : 1) ) +# define SCM_I_LONGJMP(JB,VAL) scm_ia64_longjmp (&(JB), VAL) +void scm_ia64_longjmp (scm_i_jmp_buf *, int); + +#else +/* All other systems just use setjmp and longjmp. */ + +#define SCM_I_SETJMP setjmp +#define SCM_I_LONGJMP longjmp +#endif + + + +#define SCM_ASYNC_TICK \ + do \ + { \ + if (SCM_UNLIKELY (SCM_I_CURRENT_THREAD->pending_asyncs)) \ + scm_async_tick (); \ + } \ + while (0) + +#define SCM_ASYNC_TICK_WITH_CODE(thr, stmt) \ + do \ + { \ + if (SCM_UNLIKELY (thr->pending_asyncs)) \ + { \ + stmt; \ + scm_async_tick (); \ + } \ + } \ + while (0) + + + + #if (defined __GNUC__) # define SCM_NOINLINE __attribute__ ((__noinline__)) #else # define SCM_NOINLINE /* noinline */ #endif + + /* The endianness marker in objcode. */ #ifdef WORDS_BIGENDIAN # define SCM_OBJCODE_ENDIANNESS "BE" @@ -210,8 +269,8 @@ #define SCM_OBJCODE_WORD_SIZE SCM_CPP_STRINGIFY (SIZEOF_VOID_P) /* Major and minor versions must be single characters. */ -#define SCM_OBJCODE_MAJOR_VERSION 2 -#define SCM_OBJCODE_MINOR_VERSION 0 +#define SCM_OBJCODE_MAJOR_VERSION 3 +#define SCM_OBJCODE_MINOR_VERSION 1 #define SCM_OBJCODE_MAJOR_VERSION_STRING \ SCM_CPP_STRINGIFY(SCM_OBJCODE_MAJOR_VERSION) #define SCM_OBJCODE_MINOR_VERSION_STRING \ diff --git a/libguile/alist.c b/libguile/alist.c index f33aa4146..82c70a03c 100644 --- a/libguile/alist.c +++ b/libguile/alist.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995, 96, 97, 98, 99, 2000, 2001, 2004, 2006, 2008, 2010 Free Software Foundation, Inc. +/* Copyright (C) 1995, 96, 97, 98, 99, 2000, 2001, 2004, 2006, 2008, 2010, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -40,9 +40,7 @@ SCM_DEFINE (scm_acons, "acons", 3, 0, 0, "function is @emph{not} destructive; @var{alist} is not modified.") #define FUNC_NAME s_scm_acons { - return scm_cell (SCM_UNPACK (scm_cell (SCM_UNPACK (key), - SCM_UNPACK (value))), - SCM_UNPACK (alist)); + return scm_cons (scm_cons (key, value), alist); } #undef FUNC_NAME diff --git a/libguile/arbiters.c b/libguile/arbiters.c index 5923c718a..831e0a230 100644 --- a/libguile/arbiters.c +++ b/libguile/arbiters.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995,1996, 1997, 2000, 2001, 2004, 2005, 2006, 2008 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996, 1997, 2000, 2001, 2004, 2005, 2006, 2008, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -89,11 +89,11 @@ static scm_t_bits scm_tc16_arbiter; static int arbiter_print (SCM exp, SCM port, scm_print_state *pstate) { - scm_puts ("#<arbiter ", port); + scm_puts_unlocked ("#<arbiter ", port); if (SCM_ARB_LOCKED (exp)) - scm_puts ("locked ", port); + scm_puts_unlocked ("locked ", port); scm_iprin1 (SCM_PACK (SCM_SMOB_DATA (exp)), port, pstate); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); return !0; } diff --git a/libguile/array-handle.c b/libguile/array-handle.c index 08778f369..62d8520f3 100644 --- a/libguile/array-handle.c +++ b/libguile/array-handle.c @@ -1,4 +1,5 @@ -/* Copyright (C) 1995,1996,1997,1998,2000,2001,2002,2003,2004, 2005, 2006, 2009, 2013 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1997,1998,2000,2001,2002,2003,2004, 2005, + * 2006, 2009, 2011, 2013 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -173,7 +174,7 @@ void scm_init_array_handle (void) { #define DEFINE_ARRAY_TYPE(tag, TAG) \ - scm_i_array_element_types[SCM_ARRAY_ELEMENT_TYPE_##TAG] = scm_from_locale_symbol (#tag) + scm_i_array_element_types[SCM_ARRAY_ELEMENT_TYPE_##TAG] = scm_from_utf8_symbol (#tag) scm_i_array_element_types[SCM_ARRAY_ELEMENT_TYPE_SCM] = SCM_BOOL_T; DEFINE_ARRAY_TYPE (a, CHAR); diff --git a/libguile/array-map.c b/libguile/array-map.c index d4da152ed..c0f0f00bc 100644 --- a/libguile/array-map.c +++ b/libguile/array-map.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1996,1998,2000,2001,2004,2005, 2006, 2008, 2009, 2010, 2012 Free Software Foundation, Inc. +/* Copyright (C) 1996,1998,2000,2001,2004,2005, 2006, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -99,7 +99,7 @@ scm_ra_matchp (SCM ra0, SCM ras) else return 0; - while (SCM_NIMP (ras)) + while (scm_is_pair (ras)) { ra1 = SCM_CAR (ras); @@ -204,7 +204,7 @@ scm_ramapc (void *cproc_ptr, SCM data, SCM ra0, SCM lra, const char *what) } lvra = SCM_EOL; plvra = &lvra; - for (z = lra; SCM_NIMP (z); z = SCM_CDR (z)) + for (z = lra; scm_is_pair (z); z = SCM_CDR (z)) { ra1 = SCM_CAR (z); vra1 = scm_i_make_array (1); @@ -262,7 +262,7 @@ scm_ramapc (void *cproc_ptr, SCM data, SCM ra0, SCM lra, const char *what) } lvra = SCM_EOL; plvra = &lvra; - for (z = lra; SCM_NIMP (z); z = SCM_CDR (z)) + for (z = lra; scm_is_pair (z); z = SCM_CDR (z)) { ra1 = SCM_CAR (z); vra1 = scm_i_make_array (1); @@ -295,7 +295,7 @@ scm_ramapc (void *cproc_ptr, SCM data, SCM ra0, SCM lra, const char *what) { SCM y = lra; SCM_I_ARRAY_BASE (vra0) = cind (ra0, vinds); - for (z = lvra; SCM_NIMP (z); z = SCM_CDR (z), y = SCM_CDR (y)) + for (z = lvra; scm_is_pair (z); z = SCM_CDR (z), y = SCM_CDR (y)) SCM_I_ARRAY_BASE (SCM_CAR (z)) = cind (SCM_CAR (y), vinds); if (0 == (SCM_UNBNDP (data) ? cproc(vra0, lvra) : cproc(vra0, data, lvra))) return 0; diff --git a/libguile/arrays.c b/libguile/arrays.c index 1eb10b981..83d7db2b9 100644 --- a/libguile/arrays.c +++ b/libguile/arrays.c @@ -472,7 +472,7 @@ SCM_DEFINE (scm_transpose_array, "transpose-array", 1, 0, 1, int ndim, i, k; SCM_VALIDATE_REST_ARGUMENT (args); - SCM_ASSERT (SCM_NIMP (ra), ra, SCM_ARG1, FUNC_NAME); + SCM_ASSERT (SCM_HEAP_OBJECT_P (ra), ra, SCM_ARG1, FUNC_NAME); if (scm_is_generalized_vector (ra)) { @@ -727,15 +727,15 @@ scm_i_print_array_dimension (scm_t_array_handle *h, int dim, int pos, else { ssize_t i; - scm_putc ('(', port); + scm_putc_unlocked ('(', port); for (i = h->dims[dim].lbnd; i <= h->dims[dim].ubnd; i++, pos += h->dims[dim].inc) { scm_i_print_array_dimension (h, dim+1, pos, port, pstate); if (i < h->dims[dim].ubnd) - scm_putc (' ', port); + scm_putc_unlocked (' ', port); } - scm_putc (')', port); + scm_putc_unlocked (')', port); } return 1; } @@ -752,7 +752,7 @@ scm_i_print_array (SCM array, SCM port, scm_print_state *pstate) scm_array_get_handle (array, &h); - scm_putc ('#', port); + scm_putc_unlocked ('#', port); if (h.ndims != 1 || h.dims[0].lbnd != 0) scm_intprint (h.ndims, 10, port); if (h.element_type != SCM_ARRAY_ELEMENT_TYPE_SCM) @@ -773,12 +773,12 @@ scm_i_print_array (SCM array, SCM port, scm_print_state *pstate) { if (print_lbnds) { - scm_putc ('@', port); + scm_putc_unlocked ('@', port); scm_intprint (h.dims[i].lbnd, 10, port); } if (print_lens) { - scm_putc (':', port); + scm_putc_unlocked (':', port); scm_intprint (h.dims[i].ubnd - h.dims[i].lbnd + 1, 10, port); } @@ -806,9 +806,9 @@ scm_i_print_array (SCM array, SCM port, scm_print_state *pstate) not really the same as Scheme values since they are boxed and can be modified with array-set!, say. */ - scm_putc ('(', port); + scm_putc_unlocked ('(', port); scm_i_print_array_dimension (&h, 0, 0, port, pstate); - scm_putc (')', port); + scm_putc_unlocked (')', port); return 1; } else diff --git a/libguile/async.c b/libguile/async.c index 66f0b04cd..80f561d10 100644 --- a/libguile/async.c +++ b/libguile/async.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995,1996,1997,1998,2000,2001, 2002, 2004, 2006, 2008, 2009, 2010 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1997,1998,2000,2001, 2002, 2004, 2006, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -22,8 +22,6 @@ # include <config.h> #endif -#define SCM_BUILDING_DEPRECATED_CODE - #include "libguile/_scm.h" #include "libguile/eval.h" #include "libguile/throw.h" @@ -139,7 +137,7 @@ static scm_i_pthread_mutex_t async_mutex = SCM_I_PTHREAD_MUTEX_INITIALIZER; /* System asyncs. */ void -scm_async_click () +scm_async_tick (void) { scm_i_thread *t = SCM_I_CURRENT_THREAD; SCM asyncs; @@ -170,23 +168,6 @@ scm_async_click () } } -#if (SCM_ENABLE_DEPRECATED == 1) - -SCM_DEFINE (scm_system_async, "system-async", 1, 0, 0, - (SCM thunk), - "This function is deprecated. You can use @var{thunk} directly\n" - "instead of explicitly creating an async object.\n") -#define FUNC_NAME s_scm_system_async -{ - scm_c_issue_deprecation_warning - ("'system-async' is deprecated. " - "Use the procedure directly with 'system-async-mark'."); - return thunk; -} -#undef FUNC_NAME - -#endif /* SCM_ENABLE_DEPRECATED == 1 */ - void scm_i_queue_async_cell (SCM c, scm_i_thread *t) { @@ -341,47 +322,6 @@ SCM_DEFINE (scm_noop, "noop", 0, 0, 1, -#if (SCM_ENABLE_DEPRECATED == 1) - -SCM_DEFINE (scm_unmask_signals, "unmask-signals", 0, 0, 0, - (), - "Unmask signals. The returned value is not specified.") -#define FUNC_NAME s_scm_unmask_signals -{ - scm_i_thread *t = SCM_I_CURRENT_THREAD; - - scm_c_issue_deprecation_warning - ("'unmask-signals' is deprecated. " - "Use 'call-with-blocked-asyncs' instead."); - - if (t->block_asyncs == 0) - SCM_MISC_ERROR ("signals already unmasked", SCM_EOL); - t->block_asyncs = 0; - scm_async_click (); - return SCM_UNSPECIFIED; -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_mask_signals, "mask-signals", 0, 0, 0, - (), - "Mask signals. The returned value is not specified.") -#define FUNC_NAME s_scm_mask_signals -{ - scm_i_thread *t = SCM_I_CURRENT_THREAD; - - scm_c_issue_deprecation_warning - ("'mask-signals' is deprecated. Use 'call-with-blocked-asyncs' instead."); - - if (t->block_asyncs > 0) - SCM_MISC_ERROR ("signals already masked", SCM_EOL); - t->block_asyncs = 1; - return SCM_UNSPECIFIED; -} -#undef FUNC_NAME - -#endif /* SCM_ENABLE_DEPRECATED == 1 */ - static void increase_block (void *data) { @@ -394,7 +334,7 @@ decrease_block (void *data) { scm_i_thread *t = data; if (--t->block_asyncs == 0) - scm_async_click (); + scm_async_tick (); } void @@ -504,12 +444,6 @@ scm_critical_section_end (void) SCM_CRITICAL_SECTION_END; } -void -scm_async_tick (void) -{ - SCM_ASYNC_TICK; -} - void diff --git a/libguile/async.h b/libguile/async.h index ceb2b960b..68952b055 100644 --- a/libguile/async.h +++ b/libguile/async.h @@ -3,7 +3,7 @@ #ifndef SCM_ASYNC_H #define SCM_ASYNC_H -/* Copyright (C) 1995,1996,1997,1998,2000,2001, 2002, 2004, 2005, 2006, 2008, 2009 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1997,1998,2000,2001, 2002, 2004, 2005, 2006, 2008, 2009, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -29,7 +29,7 @@ -SCM_API void scm_async_click (void); +SCM_API void scm_async_tick (void); SCM_API void scm_switch (void); SCM_API SCM scm_async (SCM thunk); SCM_API SCM scm_async_mark (SCM a); @@ -75,7 +75,7 @@ SCM_API void scm_critical_section_end (void); SCM_I_CURRENT_THREAD->critical_section_level--; \ SCM_I_CURRENT_THREAD->block_asyncs--; \ scm_i_pthread_mutex_unlock (&scm_i_critical_section_mutex); \ - scm_async_click (); \ + scm_async_tick (); \ } while (0) #else /* !BUILDING_LIBGUILE */ @@ -87,14 +87,6 @@ SCM_API void scm_critical_section_end (void); SCM_INTERNAL void scm_init_async (void); -#if (SCM_ENABLE_DEPRECATED == 1) - -SCM_DEPRECATED SCM scm_system_async (SCM thunk); -SCM_DEPRECATED SCM scm_unmask_signals (void); -SCM_DEPRECATED SCM scm_mask_signals (void); - -#endif - #endif /* SCM_ASYNC_H */ /* diff --git a/libguile/backtrace.c b/libguile/backtrace.c index 7dd66ad2e..11a0cb1ee 100644 --- a/libguile/backtrace.c +++ b/libguile/backtrace.c @@ -59,9 +59,9 @@ static SCM boot_print_exception (SCM port, SCM frame, SCM key, SCM args) #define FUNC_NAME "boot-print-exception" { - scm_puts ("Throw to key ", port); + scm_puts_unlocked ("Throw to key ", port); scm_write (key, port); - scm_puts (" with args ", port); + scm_puts_unlocked (" with args ", port); scm_write (args, port); return SCM_UNSPECIFIED; } @@ -220,14 +220,14 @@ indent (int n, SCM port) { int i; for (i = 0; i < n; ++i) - scm_putc (' ', port); + scm_putc_unlocked (' ', port); } static void display_frame_expr (char *hdr, SCM exp, char *tlr, int indentation, SCM sport, SCM port, scm_print_state *pstate) { int i = 0, n; - scm_t_ptob_descriptor *ptob = scm_ptobs + SCM_PTOBNUM (sport); + scm_t_ptob_descriptor *ptob = SCM_PORT_DESCRIPTOR (sport); do { pstate->length = print_params[i].length; @@ -236,7 +236,7 @@ display_frame_expr (char *hdr, SCM exp, char *tlr, int indentation, SCM sport, S { pstate->level = print_params[i].level - 1; scm_iprlist (hdr, exp, tlr[0], sport, pstate); - scm_puts (&tlr[1], sport); + scm_puts_unlocked (&tlr[1], sport); } else { @@ -341,19 +341,19 @@ display_backtrace_file (frame, last_file, port, pstate) *last_file = file; - scm_puts ("In ", port); + scm_puts_unlocked ("In ", port); if (scm_is_false (file)) if (scm_is_false (line)) - scm_puts ("unknown file", port); + scm_puts_unlocked ("unknown file", port); else - scm_puts ("current input", port); + scm_puts_unlocked ("current input", port); else { pstate->writingp = 0; scm_iprin1 (file, port, pstate); pstate->writingp = 1; } - scm_puts (":\n", port); + scm_puts_unlocked (":\n", port); } static void @@ -368,9 +368,9 @@ display_backtrace_file_and_line (SCM frame, SCM port, scm_print_state *pstate) if (scm_is_false (file)) { if (scm_is_false (line)) - scm_putc ('?', port); + scm_putc_unlocked ('?', port); else - scm_puts ("<stdin>", port); + scm_puts_unlocked ("<stdin>", port); } else { @@ -385,7 +385,7 @@ display_backtrace_file_and_line (SCM frame, SCM port, scm_print_state *pstate) pstate -> writingp = 1; } - scm_putc (':', port); + scm_putc_unlocked (':', port); } else if (scm_is_true (line)) { @@ -396,10 +396,10 @@ display_backtrace_file_and_line (SCM frame, SCM port, scm_print_state *pstate) } if (scm_is_false (line)) - scm_puts (" ?", port); + scm_puts_unlocked (" ?", port); else scm_intprint (scm_to_int (line) + 1, 10, port); - scm_puts (": ", port); + scm_puts_unlocked (": ", port); } static void @@ -426,7 +426,7 @@ display_frame (SCM frame, int n, int nfield, int indentation, /* Display an application. */ display_application (frame, nfield + 1 + indentation, sport, port, pstate); - scm_putc ('\n', port); + scm_putc_unlocked ('\n', port); } struct display_backtrace_args { @@ -524,9 +524,9 @@ display_backtrace_body (struct display_backtrace_args *a) static SCM error_during_backtrace (void *data, SCM tag, SCM throw_args) { - SCM port = PTR2SCM (data); + SCM port = SCM_PACK_POINTER (data); - scm_puts ("Exception thrown while printing backtrace:\n", port); + scm_puts_unlocked ("Exception thrown while printing backtrace:\n", port); scm_print_exception (port, SCM_BOOL_F, tag, throw_args); return SCM_UNSPECIFIED; @@ -557,7 +557,7 @@ SCM_DEFINE (scm_display_backtrace_with_highlights, "display-backtrace", 2, 3, 0, scm_internal_catch (SCM_BOOL_T, (scm_t_catch_body) display_backtrace_body, &a, - (scm_t_catch_handler) error_during_backtrace, SCM2PTR (port)); + (scm_t_catch_handler) error_during_backtrace, SCM_UNPACK_POINTER (port)); return SCM_UNSPECIFIED; } @@ -587,7 +587,7 @@ SCM_DEFINE (scm_backtrace_with_highlights, "backtrace", 0, 1, 0, highlights = SCM_EOL; scm_newline (port); - scm_puts ("Backtrace:\n", port); + scm_puts_unlocked ("Backtrace:\n", port); scm_display_backtrace_with_highlights (stack, port, SCM_BOOL_F, SCM_BOOL_F, highlights); scm_newline (port); diff --git a/libguile/bitvectors.c b/libguile/bitvectors.c index 01584906c..ffea6d182 100644 --- a/libguile/bitvectors.c +++ b/libguile/bitvectors.c @@ -50,12 +50,12 @@ scm_i_print_bitvector (SCM vec, SCM port, scm_print_state *pstate) scm_t_uint32 *bits = BITVECTOR_BITS (vec); size_t i, j; - scm_puts ("#*", port); + scm_puts_unlocked ("#*", port); for (i = 0; i < word_len; i++, bit_len -= 32) { scm_t_uint32 mask = 1; for (j = 0; j < 32 && j < bit_len; j++, mask <<= 1) - scm_putc ((bits[i] & mask)? '1' : '0', port); + scm_putc_unlocked ((bits[i] & mask)? '1' : '0', port); } return 1; diff --git a/libguile/boolean.c b/libguile/boolean.c index 3bf672d6d..f8c773839 100644 --- a/libguile/boolean.c +++ b/libguile/boolean.c @@ -62,6 +62,14 @@ SCM_DEFINE (scm_not, "not", 1, 0, 0, } #undef FUNC_NAME +SCM_DEFINE (scm_nil_p, "nil?", 1, 0, 0, + (SCM x), + "Return @code{#t} iff @var{x} is nil, else return @code{#f}.") +#define FUNC_NAME s_scm_nil_p +{ + return scm_from_bool (scm_is_lisp_false (x)); +} +#undef FUNC_NAME SCM_DEFINE (scm_boolean_p, "boolean?", 1, 0, 0, (SCM obj), diff --git a/libguile/bytevectors.c b/libguile/bytevectors.c index cf41f2fb5..9093f49c3 100644 --- a/libguile/bytevectors.c +++ b/libguile/bytevectors.c @@ -1,4 +1,4 @@ -/* Copyright (C) 2009, 2010, 2011, 2012 Free Software Foundation, Inc. +/* Copyright (C) 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -192,6 +192,9 @@ SCM_SET_BYTEVECTOR_FLAGS ((bv), \ (hint) \ | (SCM_BYTEVECTOR_CONTIGUOUS_P (bv) << 8UL)) +#define SCM_BYTEVECTOR_SET_PARENT(_bv, _parent) \ + SCM_SET_CELL_OBJECT_3 ((_bv), (_parent)) + #define SCM_BYTEVECTOR_TYPE_SIZE(var) \ (scm_i_array_element_type_sizes[SCM_BYTEVECTOR_ELEMENT_TYPE (var)]/8) #define SCM_BYTEVECTOR_TYPED_LENGTH(var) \ @@ -209,7 +212,7 @@ make_bytevector (size_t len, scm_t_array_element_type element_type) if (SCM_UNLIKELY (element_type > SCM_ARRAY_ELEMENT_TYPE_LAST || scm_i_array_element_type_sizes[element_type] < 8 - || len >= (SCM_I_SIZE_MAX + || len >= (((size_t) -1) / (scm_i_array_element_type_sizes[element_type]/8)))) /* This would be an internal Guile programming error */ abort (); @@ -225,13 +228,14 @@ make_bytevector (size_t len, scm_t_array_element_type element_type) contents = scm_gc_malloc_pointerless (SCM_BYTEVECTOR_HEADER_BYTES + c_len, SCM_GC_BYTEVECTOR); - ret = PTR2SCM (contents); + ret = SCM_PACK_POINTER (contents); contents += SCM_BYTEVECTOR_HEADER_BYTES; SCM_BYTEVECTOR_SET_LENGTH (ret, c_len); SCM_BYTEVECTOR_SET_CONTENTS (ret, contents); SCM_BYTEVECTOR_SET_CONTIGUOUS_P (ret, 1); SCM_BYTEVECTOR_SET_ELEMENT_TYPE (ret, element_type); + SCM_BYTEVECTOR_SET_PARENT (ret, SCM_BOOL_F); } return ret; @@ -252,7 +256,7 @@ make_bytevector_from_buffer (size_t len, void *contents, { size_t c_len; - ret = PTR2SCM (scm_gc_malloc (SCM_BYTEVECTOR_HEADER_BYTES, + ret = SCM_PACK_POINTER (scm_gc_malloc (SCM_BYTEVECTOR_HEADER_BYTES, SCM_GC_BYTEVECTOR)); c_len = len * (scm_i_array_element_type_sizes[element_type] / 8); @@ -261,6 +265,7 @@ make_bytevector_from_buffer (size_t len, void *contents, SCM_BYTEVECTOR_SET_CONTENTS (ret, contents); SCM_BYTEVECTOR_SET_CONTIGUOUS_P (ret, 0); SCM_BYTEVECTOR_SET_ELEMENT_TYPE (ret, element_type); + SCM_BYTEVECTOR_SET_PARENT (ret, SCM_BOOL_F); } return ret; @@ -281,19 +286,31 @@ scm_i_make_typed_bytevector (size_t len, scm_t_array_element_type element_type) return make_bytevector (len, element_type); } -/* Return a bytevector of size LEN made up of CONTENTS. The area pointed to - by CONTENTS must have been allocated using `scm_gc_malloc ()'. */ +/* Return a bytevector of size LEN made up of CONTENTS. The area + pointed to by CONTENTS must be protected from GC somehow: either + because it was allocated using `scm_gc_malloc ()', or because it is + part of PARENT. */ SCM -scm_c_take_gc_bytevector (signed char *contents, size_t len) +scm_c_take_gc_bytevector (signed char *contents, size_t len, SCM parent) { - return make_bytevector_from_buffer (len, contents, SCM_ARRAY_ELEMENT_TYPE_VU8); + SCM ret; + + ret = make_bytevector_from_buffer (len, contents, SCM_ARRAY_ELEMENT_TYPE_VU8); + SCM_BYTEVECTOR_SET_PARENT (ret, parent); + + return ret; } SCM scm_c_take_typed_bytevector (signed char *contents, size_t len, - scm_t_array_element_type element_type) + scm_t_array_element_type element_type, SCM parent) { - return make_bytevector_from_buffer (len, contents, element_type); + SCM ret; + + ret = make_bytevector_from_buffer (len, contents, element_type); + SCM_BYTEVECTOR_SET_PARENT (ret, parent); + + return ret; } /* Shrink BV to C_NEW_LEN (which is assumed to be smaller than its current @@ -397,17 +414,17 @@ scm_i_print_bytevector (SCM bv, SCM port, scm_print_state *pstate SCM_UNUSED) scm_array_get_handle (bv, &h); - scm_putc ('#', port); + scm_putc_unlocked ('#', port); scm_write (scm_array_handle_element_type (&h), port); - scm_putc ('(', port); + scm_putc_unlocked ('(', port); for (i = h.dims[0].lbnd, ubnd = h.dims[0].ubnd, inc = h.dims[0].inc; i <= ubnd; i += inc) { if (i > 0) - scm_putc (' ', port); + scm_putc_unlocked (' ', port); scm_write (scm_array_handle_ref (&h, i), port); } - scm_putc (')', port); + scm_putc_unlocked (')', port); return 1; } @@ -2011,8 +2028,7 @@ SCM_DEFINE (scm_string_to_utf32, "string->utf32", scm_list_1 (utf), err); \ else \ { \ - str = scm_from_stringn (c_str, c_strlen, "UTF-8", \ - SCM_FAILED_CONVERSION_ERROR); \ + str = scm_from_utf8_stringn (c_str, c_strlen); \ free (c_str); \ } \ return (str); @@ -2033,8 +2049,7 @@ SCM_DEFINE (scm_utf8_to_string, "utf8->string", c_utf_len = SCM_BYTEVECTOR_LENGTH (utf); c_utf = (char *) SCM_BYTEVECTOR_CONTENTS (utf); - str = scm_from_stringn (c_utf, c_utf_len, "UTF-8", - SCM_FAILED_CONVERSION_ERROR); + str = scm_from_utf8_stringn (c_utf, c_utf_len); return (str); } diff --git a/libguile/bytevectors.h b/libguile/bytevectors.h index 8bafff3a3..a5eeaea0c 100644 --- a/libguile/bytevectors.h +++ b/libguile/bytevectors.h @@ -28,12 +28,14 @@ /* The size in words of the bytevector header (type tag and flags, length, and pointer to the underlying buffer). */ -#define SCM_BYTEVECTOR_HEADER_SIZE 3U +#define SCM_BYTEVECTOR_HEADER_SIZE 4U #define SCM_BYTEVECTOR_LENGTH(_bv) \ ((size_t) SCM_CELL_WORD_1 (_bv)) #define SCM_BYTEVECTOR_CONTENTS(_bv) \ ((signed char *) SCM_CELL_WORD_2 (_bv)) +#define SCM_BYTEVECTOR_PARENT(_bv) \ + (SCM_CELL_OBJECT_3 (_bv)) SCM_API SCM scm_endianness_big; @@ -115,7 +117,7 @@ SCM_API SCM scm_utf32_to_string (SCM, SCM); /* Internal API. */ #define SCM_BYTEVECTOR_P(x) \ - (!SCM_IMP (x) && SCM_TYP7(x) == scm_tc7_bytevector) + (SCM_HAS_TYP7 (x, scm_tc7_bytevector)) #define SCM_BYTEVECTOR_FLAGS(_bv) \ (SCM_CELL_TYPE (_bv) >> 7UL) #define SCM_SET_BYTEVECTOR_FLAGS(_bv, _f) \ @@ -132,13 +134,13 @@ SCM_API SCM scm_utf32_to_string (SCM, SCM); SCM_INTERNAL SCM scm_i_make_typed_bytevector (size_t, scm_t_array_element_type); SCM_INTERNAL SCM scm_c_take_typed_bytevector (signed char *, size_t, - scm_t_array_element_type); + scm_t_array_element_type, SCM); SCM_INTERNAL void scm_bootstrap_bytevectors (void); SCM_INTERNAL void scm_init_bytevectors (void); SCM_INTERNAL SCM scm_i_native_endianness; -SCM_INTERNAL SCM scm_c_take_gc_bytevector (signed char *, size_t); +SCM_INTERNAL SCM scm_c_take_gc_bytevector (signed char *, size_t, SCM); SCM_INTERNAL int scm_i_print_bytevector (SCM, SCM, scm_print_state *); diff --git a/libguile/chars.c b/libguile/chars.c index 2e1610566..fbedb0fe2 100644 --- a/libguile/chars.c +++ b/libguile/chars.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995,1996,1998, 2000, 2001, 2004, 2006, 2008, 2009, 2010 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1998, 2000, 2001, 2004, 2006, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -492,7 +492,7 @@ SCM_DEFINE (scm_char_general_category, "char-general-category", 1, 0, 0, sym = uc_general_category_name (cat); if (sym != NULL) - return scm_from_locale_symbol (sym); + return scm_from_utf8_symbol (sym); return SCM_BOOL_F; } #undef FUNC_NAME diff --git a/libguile/continuations.c b/libguile/continuations.c index d9912783d..fe7618f5e 100644 --- a/libguile/continuations.c +++ b/libguile/continuations.c @@ -24,6 +24,7 @@ #include "libguile/_scm.h" +#include <assert.h> #include <string.h> #include <stdio.h> @@ -33,7 +34,7 @@ #include "libguile/stackchk.h" #include "libguile/smob.h" #include "libguile/ports.h" -#include "libguile/dynwind.h" +#include "libguile/dynstack.h" #include "libguile/eval.h" #include "libguile/vm.h" #include "libguile/instructions.h" @@ -52,7 +53,6 @@ static scm_t_bits tc16_continuation; #define SCM_SET_CONTINUATION_LENGTH(x, n)\ (SCM_CONTREGS (x)->num_stack_items = (n)) #define SCM_JMPBUF(x) ((SCM_CONTREGS (x))->jmpbuf) -#define SCM_DYNENV(x) ((SCM_CONTREGS (x))->dynenv) #define SCM_CONTINUATION_ROOT(x) ((SCM_CONTREGS (x))->root) #define SCM_DFRAME(x) ((SCM_CONTREGS (x))->dframe) @@ -173,14 +173,25 @@ continuation_print (SCM obj, SCM port, scm_print_state *state SCM_UNUSED) { scm_t_contregs *continuation = SCM_CONTREGS (obj); - scm_puts ("#<continuation ", port); + scm_puts_unlocked ("#<continuation ", port); scm_intprint (continuation->num_stack_items, 10, port); - scm_puts (" @ ", port); + scm_puts_unlocked (" @ ", port); scm_uintprint (SCM_SMOB_DATA_1 (obj), 16, port); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); return 1; } +/* James Clark came up with this neat one instruction fix for + * continuations on the SPARC. It flushes the register windows so + * that all the state of the process is contained in the stack. + */ + +#if defined (sparc) || defined (__sparc__) || defined (__sparc) +# define SCM_FLUSH_REGISTER_WINDOWS asm("ta 3") +#else +# define SCM_FLUSH_REGISTER_WINDOWS /* empty */ +#endif + /* this may return more than once: the first time with the escape procedure, then subsequently with SCM_UNDEFINED (the vals already having been placed on the VM stack). */ @@ -200,7 +211,6 @@ scm_i_make_continuation (int *first, SCM vm, SCM vm_cont) + (stack_size - 1) * sizeof (SCM_STACKITEM), "continuation"); continuation->num_stack_items = stack_size; - continuation->dynenv = scm_i_dynwinds (); continuation->root = thread->continuation_root; src = thread->continuation_base; #if ! SCM_STACK_GROWS_UP @@ -323,33 +333,25 @@ grow_stack (SCM cont) * own frame are overwritten. Thus, memcpy can be used for best performance. */ -typedef struct { - scm_t_contregs *continuation; - SCM_STACKITEM *dst; -} copy_stack_data; - -static void -copy_stack (void *data) -{ - copy_stack_data *d = (copy_stack_data *)data; - memcpy (d->dst, d->continuation->stack, - sizeof (SCM_STACKITEM) * d->continuation->num_stack_items); -#ifdef __ia64__ - SCM_I_CURRENT_THREAD->pending_rbs_continuation = d->continuation; -#endif -} - static void copy_stack_and_call (scm_t_contregs *continuation, SCM_STACKITEM * dst) { - long delta; - copy_stack_data data; + scm_t_dynstack *dynstack; + scm_t_bits *joint; + scm_i_thread *thread = SCM_I_CURRENT_THREAD; + + dynstack = SCM_VM_CONT_DATA (continuation->vm_cont)->dynstack; + + joint = scm_dynstack_unwind_fork (&thread->dynstack, dynstack); + + memcpy (dst, continuation->stack, + sizeof (SCM_STACKITEM) * continuation->num_stack_items); +#ifdef __ia64__ + thread->pending_rbs_continuation = continuation; +#endif - delta = scm_ilength (scm_i_dynwinds ()) - scm_ilength (continuation->dynenv); - data.continuation = continuation; - data.dst = dst; - scm_i_dowinds (continuation->dynenv, delta, copy_stack, &data); + scm_dynstack_wind (&thread->dynstack, joint); SCM_I_LONGJMP (continuation->jmpbuf, 1); } @@ -486,7 +488,7 @@ print_exception_and_backtrace (SCM port, SCM tag, SCM args) if (should_print_backtrace (tag, stack)) { - scm_puts ("Backtrace:\n", port); + scm_puts_unlocked ("Backtrace:\n", port); scm_display_backtrace_with_highlights (stack, port, SCM_BOOL_F, SCM_BOOL_F, SCM_EOL); @@ -531,7 +533,7 @@ pre_unwind_handler (void *error_port, SCM tag, SCM args) { /* Print the exception unless TAG is `quit'. */ if (!scm_is_eq (tag, scm_from_latin1_symbol ("quit"))) - print_exception_and_backtrace (PTR2SCM (error_port), tag, args); + print_exception_and_backtrace (SCM_PACK_POINTER (error_port), tag, args); return SCM_UNSPECIFIED; } @@ -545,7 +547,7 @@ scm_c_with_continuation_barrier (void *(*func) (void *), void *data) scm_i_with_continuation_barrier (c_body, &c_data, c_handler, &c_data, pre_unwind_handler, - SCM2PTR (scm_current_error_port ())); + SCM_UNPACK_POINTER (scm_current_error_port ())); return c_data.result; } @@ -589,7 +591,7 @@ SCM_DEFINE (scm_with_continuation_barrier, "with-continuation-barrier", 1,0,0, return scm_i_with_continuation_barrier (scm_body, &scm_data, scm_handler, &scm_data, pre_unwind_handler, - SCM2PTR (scm_current_error_port ())); + SCM_UNPACK_POINTER (scm_current_error_port ())); } #undef FUNC_NAME diff --git a/libguile/continuations.h b/libguile/continuations.h index e0a455632..29ea1c1a1 100644 --- a/libguile/continuations.h +++ b/libguile/continuations.h @@ -3,7 +3,7 @@ #ifndef SCM_CONTINUATIONS_H #define SCM_CONTINUATIONS_H -/* Copyright (C) 1995,1996,2000,2001, 2006, 2008, 2009, 2010 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,2000,2001, 2006, 2008, 2009, 2010, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -45,7 +45,6 @@ typedef struct { scm_i_jmp_buf jmpbuf; - SCM dynenv; #ifdef __ia64__ void *backing_store; unsigned long backing_store_size; diff --git a/libguile/control.c b/libguile/control.c index f8d2d60ae..54c1cd3f4 100644 --- a/libguile/control.c +++ b/libguile/control.c @@ -30,30 +30,14 @@ +#define PROMPT_ESCAPE_P(p) \ + (SCM_DYNSTACK_TAG_FLAGS (SCM_DYNSTACK_TAG (p)) \ + & SCM_F_DYNSTACK_PROMPT_ESCAPE_ONLY) -SCM -scm_c_make_prompt (SCM k, SCM *fp, SCM *sp, scm_t_uint8 *abort_ip, - scm_t_uint8 escape_only_p, scm_t_int64 vm_cookie, - SCM winds) -{ - scm_t_bits tag; - struct scm_prompt_registers *regs; - - tag = scm_tc7_prompt; - if (escape_only_p) - tag |= (SCM_F_PROMPT_ESCAPE<<8); - - regs = scm_gc_malloc_pointerless (sizeof (*regs), "prompt registers"); - regs->fp = fp; - regs->sp = sp; - regs->ip = abort_ip; - regs->cookie = vm_cookie; + - return scm_double_cell (tag, SCM_UNPACK (k), (scm_t_bits)regs, - SCM_UNPACK (winds)); -} -/* Only to be called if the SCM_PROMPT_SETJMP returns 1 */ +/* Only to be called if the SCM_I_SETJMP returns 1 */ SCM scm_i_prompt_pop_abort_args_x (SCM vm) { @@ -115,9 +99,9 @@ SCM_STATIC_OBJCODE (cont_objcode) = { OBJCODE_HEADER (8, 19), /* leave args on the stack */ /* 0 */ scm_op_object_ref, 0, /* push scm_vm_cont object */ - /* 2 */ scm_op_object_ref, 1, /* push internal winds */ - /* 4 */ scm_op_partial_cont_call, /* and go! */ - /* 5 */ scm_op_nop, scm_op_nop, scm_op_nop, /* pad to 8 bytes */ + /* 2 */ scm_op_partial_cont_call, /* and go! */ + /* 3 */ scm_op_nop, + /* 4 */ scm_op_nop, scm_op_nop, scm_op_nop, scm_op_nop, /* pad to 8 bytes */ /* 8 */ /* We could put some meta-info to say that this proc is a continuation. Not sure @@ -125,7 +109,7 @@ SCM_STATIC_OBJCODE (cont_objcode) = { META_HEADER (19), /* 0 */ scm_op_make_eol, /* bindings */ /* 1 */ scm_op_make_eol, /* sources */ - /* 2 */ scm_op_make_int8, 0, scm_op_make_int8, 5, /* arity: from ip 0 to ip 7 */ + /* 2 */ scm_op_make_int8, 0, scm_op_make_int8, 3, /* arity: from ip 0 to ip 3 */ /* 6 */ scm_op_make_int8_0, /* the arity is 0 required args */ /* 7 */ scm_op_make_int8_0, /* 0 optionals */ /* 8 */ scm_op_make_true, /* and a rest arg */ @@ -138,45 +122,41 @@ SCM_STATIC_OBJCODE (cont_objcode) = { static SCM -reify_partial_continuation (SCM vm, SCM prompt, SCM extwinds, - scm_t_int64 cookie) +reify_partial_continuation (SCM vm, + SCM *saved_fp, SCM *saved_sp, scm_t_uint8 *saved_ip, + scm_i_jmp_buf *saved_registers, + scm_t_dynstack *dynstack, + scm_i_jmp_buf *current_registers) { - SCM vm_cont, dynwinds, intwinds = SCM_EOL, ret; + SCM vm_cont, ret; scm_t_uint32 flags; - /* No need to reify if the continuation is never referenced in the handler. */ - if (SCM_PROMPT_ESCAPE_P (prompt)) - return SCM_BOOL_F; - - dynwinds = scm_i_dynwinds (); - while (!scm_is_eq (dynwinds, extwinds)) - { - intwinds = scm_cons (scm_car (dynwinds), intwinds); - dynwinds = scm_cdr (dynwinds); - } - flags = SCM_F_VM_CONT_PARTIAL; - if (cookie >= 0 && SCM_PROMPT_REGISTERS (prompt)->cookie == cookie) + /* If we are aborting to a prompt that has the same registers as those + of the abort, it means there are no intervening C frames on the + stack, and so the continuation can be relocated elsewhere on the + stack: it is rewindable. */ + if (saved_registers && saved_registers == current_registers) flags |= SCM_F_VM_CONT_REWINDABLE; /* Since non-escape continuations should begin with a thunk application, the first bit of the stack should be a frame, with the saved fp equal to the fp that was current when the prompt was made. */ - if ((SCM*)SCM_UNPACK (SCM_PROMPT_REGISTERS (prompt)->sp[1]) - != SCM_PROMPT_REGISTERS (prompt)->fp) + if ((SCM*)SCM_UNPACK (saved_sp[1]) != saved_fp) abort (); /* Capture from the top of the thunk application frame up to the end. Set an MVRA only, as the post-abort code is in an MV context. */ - vm_cont = scm_i_vm_capture_stack (SCM_PROMPT_REGISTERS (prompt)->sp + 4, + vm_cont = scm_i_vm_capture_stack (saved_sp + 4, SCM_VM_DATA (vm)->fp, SCM_VM_DATA (vm)->sp, NULL, SCM_VM_DATA (vm)->ip, + dynstack, flags); ret = scm_make_program (cont_objcode, - scm_vector (scm_list_2 (vm_cont, intwinds)), + scm_c_make_vector (1, vm_cont), SCM_BOOL_F); SCM_SET_CELL_WORD_0 (ret, SCM_CELL_WORD_0 (ret) | SCM_F_PROGRAM_IS_PARTIAL_CONTINUATION); @@ -184,48 +164,49 @@ reify_partial_continuation (SCM vm, SCM prompt, SCM extwinds, } void -scm_c_abort (SCM vm, SCM tag, size_t n, SCM *argv, scm_t_int64 cookie) +scm_c_abort (SCM vm, SCM tag, size_t n, SCM *argv, + scm_i_jmp_buf *current_registers) { - SCM cont, winds, prompt = SCM_BOOL_F; - long delta; + SCM cont; + scm_t_dynstack *dynstack = &SCM_I_CURRENT_THREAD->dynstack; + scm_t_bits *prompt; + scm_t_dynstack_prompt_flags flags; + SCM *fp, *sp; + scm_t_uint8 *ip; + scm_i_jmp_buf *registers; size_t i; - /* Search the wind list for an appropriate prompt. - "Waiter, please bring us the wind list." */ - for (winds = scm_i_dynwinds (), delta = 0; - scm_is_pair (winds); - winds = SCM_CDR (winds), delta++) - { - SCM elt = SCM_CAR (winds); - if (SCM_PROMPT_P (elt) && scm_is_eq (SCM_PROMPT_TAG (elt), tag)) - { - prompt = elt; - break; - } - } - - /* If we didn't find anything, raise an error. */ - if (scm_is_false (prompt)) + prompt = scm_dynstack_find_prompt (dynstack, tag, + &flags, &fp, &sp, &ip, ®isters); + + if (!prompt) scm_misc_error ("abort", "Abort to unknown prompt", scm_list_1 (tag)); - cont = reify_partial_continuation (vm, prompt, winds, cookie); + /* Only reify if the continuation referenced in the handler. */ + if (flags & SCM_F_DYNSTACK_PROMPT_ESCAPE_ONLY) + cont = SCM_BOOL_F; + else + { + scm_t_dynstack *captured; - /* Unwind once more, beyond the prompt. */ - winds = SCM_CDR (winds), delta++; + captured = scm_dynstack_capture (dynstack, SCM_DYNSTACK_NEXT (prompt)); + cont = reify_partial_continuation (vm, fp, sp, ip, registers, captured, + current_registers); + } - /* Unwind */ - scm_dowinds (winds, delta); + /* Unwind. */ + scm_dynstack_unwind (dynstack, prompt); /* Unwinding may have changed the current thread's VM, so use the new one. */ vm = scm_the_vm (); /* Restore VM regs */ - SCM_VM_DATA (vm)->fp = SCM_PROMPT_REGISTERS (prompt)->fp; - SCM_VM_DATA (vm)->sp = SCM_PROMPT_REGISTERS (prompt)->sp; - SCM_VM_DATA (vm)->ip = SCM_PROMPT_REGISTERS (prompt)->ip; + SCM_VM_DATA (vm)->fp = fp; + SCM_VM_DATA (vm)->sp = sp; + SCM_VM_DATA (vm)->ip = ip; - /* Since we're jumping down, we should always have enough space */ + /* Since we're jumping down, we should always have enough space. */ if (SCM_VM_DATA (vm)->sp + n + 1 >= SCM_VM_DATA (vm)->stack_limit) abort (); @@ -236,7 +217,7 @@ scm_c_abort (SCM vm, SCM tag, size_t n, SCM *argv, scm_t_int64 cookie) *(++(SCM_VM_DATA (vm)->sp)) = scm_from_size_t (n+1); /* +1 for continuation */ /* Jump! */ - SCM_I_LONGJMP (SCM_PROMPT_REGISTERS (prompt)->regs, 1); + SCM_I_LONGJMP (*registers, 1); /* Shouldn't get here */ abort (); @@ -255,7 +236,7 @@ SCM_DEFINE (scm_at_abort, "@abort", 2, 0, 0, (SCM tag, SCM args), for (i = 0; i < n; i++, args = scm_cdr (args)) argv[i] = scm_car (args); - scm_c_abort (scm_the_vm (), tag, n, argv, -1); + scm_c_abort (scm_the_vm (), tag, n, argv, NULL); /* Oh, what, you're still here? The abort must have been reinstated. Actually, that's quite impossible, given that we're already in C-land here, so... @@ -266,14 +247,6 @@ SCM_DEFINE (scm_at_abort, "@abort", 2, 0, 0, (SCM tag, SCM args), #undef FUNC_NAME void -scm_i_prompt_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED) -{ - scm_puts ("#<prompt ", port); - scm_intprint (SCM_UNPACK (exp), 16, port); - scm_putc ('>', port); -} - -void scm_init_control (void) { #include "libguile/control.x" diff --git a/libguile/control.h b/libguile/control.h index 2167ffa08..470919472 100644 --- a/libguile/control.h +++ b/libguile/control.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2010, 2011 Free Software Foundation, Inc. +/* Copyright (C) 2010, 2011, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -20,40 +20,13 @@ #define SCM_CONTROL_H -#define SCM_F_PROMPT_ESCAPE 0x1 - -#define SCM_PROMPT_P(x) (!SCM_IMP (x) && SCM_TYP7(x) == scm_tc7_prompt) -#define SCM_PROMPT_FLAGS(x) (SCM_CELL_WORD ((x), 0) >> 8) -#define SCM_PROMPT_ESCAPE_P(x) (SCM_PROMPT_FLAGS (x) & SCM_F_PROMPT_ESCAPE) -#define SCM_PROMPT_TAG(x) (SCM_CELL_OBJECT ((x), 1)) -#define SCM_PROMPT_REGISTERS(x) ((struct scm_prompt_registers*)SCM_CELL_WORD ((x), 2)) -#define SCM_PROMPT_DYNWINDS(x) (SCM_CELL_OBJECT ((x), 3)) - -#define SCM_PROMPT_SETJMP(p) (SCM_I_SETJMP (SCM_PROMPT_REGISTERS (p)->regs)) - -struct scm_prompt_registers -{ - scm_t_uint8 *ip; - SCM *sp; - SCM *fp; - scm_t_int64 cookie; - scm_i_jmp_buf regs; -}; - - -SCM_INTERNAL SCM scm_c_make_prompt (SCM k, SCM *fp, SCM *sp, - scm_t_uint8 *abort_ip, - scm_t_uint8 escape_only_p, - scm_t_int64 vm_cookie, - SCM winds); SCM_INTERNAL SCM scm_i_prompt_pop_abort_args_x (SCM vm); SCM_INTERNAL void scm_c_abort (SCM vm, SCM tag, size_t n, SCM *argv, - scm_t_int64 cookie) SCM_NORETURN; + scm_i_jmp_buf *registers) SCM_NORETURN; SCM_INTERNAL SCM scm_at_abort (SCM tag, SCM args) SCM_NORETURN; -SCM_INTERNAL void scm_i_prompt_print (SCM exp, SCM port, scm_print_state *pstate); SCM_INTERNAL void scm_init_control (void); diff --git a/libguile/debug.c b/libguile/debug.c index b1a90d84d..87513bf48 100644 --- a/libguile/debug.c +++ b/libguile/debug.c @@ -108,9 +108,7 @@ SCM_DEFINE (scm_debug_options, "debug-options-interface", 0, 1, 0, scm_dynwind_critical_section (SCM_BOOL_F); ans = scm_options (setting, scm_debug_opts, FUNC_NAME); -#ifdef STACK_CHECKING scm_stack_checking_enabled_p = SCM_STACK_CHECKING_P; -#endif scm_dynwind_end (); return ans; @@ -146,16 +144,9 @@ SCM_DEFINE (scm_procedure_source, "procedure-source", 1, 0, 0, if (scm_is_true (src)) return src; - switch (SCM_TYP7 (proc)) { - case scm_tcs_struct: - if (!SCM_STRUCT_APPLICABLE_P (proc) - || SCM_IMP (SCM_STRUCT_PROCEDURE (proc))) - break; - proc = SCM_STRUCT_PROCEDURE (proc); + if (SCM_STRUCTP (proc) && SCM_STRUCT_APPLICABLE_P (proc) + && SCM_HEAP_OBJECT_P ((proc = SCM_STRUCT_PROCEDURE (proc)))) continue; - default: - break; - } } while (0); diff --git a/libguile/debug.h b/libguile/debug.h index 4155d1981..362d9b7e2 100644 --- a/libguile/debug.h +++ b/libguile/debug.h @@ -3,7 +3,7 @@ #ifndef SCM_DEBUG_H #define SCM_DEBUG_H -/* Copyright (C) 1995,1996,1998,1999,2000,2001,2002,2004,2008,2009,2010,2012 +/* Copyright (C) 1995,1996,1998,1999,2000,2001,2002,2004,2008,2009,2010,2011,2012 * Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or @@ -54,18 +54,6 @@ SCM_INTERNAL void scm_init_debug (void); SCM_API SCM scm_debug_hang (SCM obj); #endif /*GUILE_DEBUG*/ -#if SCM_ENABLE_DEPRECATED == 1 - -#define CHECK_ENTRY scm_check_entry_p -#define CHECK_APPLY scm_check_apply_p -#define CHECK_EXIT scm_check_exit_p - -/* Deprecated in guile 1.7.0 on 2004-03-29. */ -#define SCM_DEBUGGINGP scm_debug_mode_p -#define scm_debug_mode scm_debug_mode_p - -#endif - #endif /* SCM_DEBUG_H */ /* diff --git a/libguile/deprecated.c b/libguile/deprecated.c index b5e7cf395..cca145414 100644 --- a/libguile/deprecated.c +++ b/libguile/deprecated.c @@ -27,2559 +27,10 @@ #define SCM_BUILDING_DEPRECATED_CODE #include "libguile/_scm.h" -#include "libguile/async.h" -#include "libguile/arrays.h" -#include "libguile/array-map.h" -#include "libguile/generalized-arrays.h" -#include "libguile/bytevectors.h" -#include "libguile/bitvectors.h" -#include "libguile/deprecated.h" #include "libguile/deprecation.h" -#include "libguile/snarf.h" -#include "libguile/validate.h" -#include "libguile/strings.h" -#include "libguile/srfi-13.h" -#include "libguile/modules.h" -#include "libguile/eval.h" -#include "libguile/smob.h" -#include "libguile/procprop.h" -#include "libguile/vectors.h" -#include "libguile/hashtab.h" -#include "libguile/struct.h" -#include "libguile/variable.h" -#include "libguile/fluids.h" -#include "libguile/ports.h" -#include "libguile/eq.h" -#include "libguile/read.h" -#include "libguile/r6rs-ports.h" -#include "libguile/strports.h" -#include "libguile/smob.h" -#include "libguile/alist.h" -#include "libguile/keywords.h" -#include "libguile/socket.h" -#include "libguile/feature.h" -#include "libguile/uniform.h" - -#include <math.h> -#include <stdio.h> -#include <string.h> - -#include <arpa/inet.h> #if (SCM_ENABLE_DEPRECATED == 1) -/* From print.c: Internal symbol names of isyms. Deprecated in guile 1.7.0 on - * 2004-04-22. */ -char *scm_isymnames[] = -{ - "#@<deprecated>" -}; - - -SCM_REGISTER_PROC(s_substring_move_left_x, "substring-move-left!", 5, 0, 0, scm_substring_move_x); - -SCM_REGISTER_PROC(s_substring_move_right_x, "substring-move-right!", 5, 0, 0, scm_substring_move_x); - -SCM -scm_wta (SCM arg, const char *pos, const char *s_subr) -{ - if (!s_subr || !*s_subr) - s_subr = NULL; - if ((~0x1fL) & (long) pos) - { - /* error string supplied. */ - scm_misc_error (s_subr, pos, scm_list_1 (arg)); - } - else - { - /* numerical error code. */ - scm_t_bits error = (scm_t_bits) pos; - - switch (error) - { - case SCM_ARGn: - scm_wrong_type_arg (s_subr, 0, arg); - case SCM_ARG1: - scm_wrong_type_arg (s_subr, 1, arg); - case SCM_ARG2: - scm_wrong_type_arg (s_subr, 2, arg); - case SCM_ARG3: - scm_wrong_type_arg (s_subr, 3, arg); - case SCM_ARG4: - scm_wrong_type_arg (s_subr, 4, arg); - case SCM_ARG5: - scm_wrong_type_arg (s_subr, 5, arg); - case SCM_ARG6: - scm_wrong_type_arg (s_subr, 6, arg); - case SCM_ARG7: - scm_wrong_type_arg (s_subr, 7, arg); - case SCM_WNA: - scm_wrong_num_args (arg); - case SCM_OUTOFRANGE: - scm_out_of_range (s_subr, arg); - case SCM_NALLOC: - scm_memory_error (s_subr); - default: - /* this shouldn't happen. */ - scm_misc_error (s_subr, "Unknown error", SCM_EOL); - } - } - return SCM_UNSPECIFIED; -} - -/* Module registry - */ - -/* We can't use SCM objects here. One should be able to call - SCM_REGISTER_MODULE from a C++ constructor for a static - object. This happens before main and thus before libguile is - initialized. */ - -struct moddata { - struct moddata *link; - char *module_name; - void *init_func; -}; - -static struct moddata *registered_mods = NULL; - -void -scm_register_module_xxx (char *module_name, void *init_func) -{ - struct moddata *md; - - scm_c_issue_deprecation_warning - ("`scm_register_module_xxx' is deprecated. Use extensions instead."); - - /* XXX - should we (and can we) DEFER_INTS here? */ - - for (md = registered_mods; md; md = md->link) - if (!strcmp (md->module_name, module_name)) - { - md->init_func = init_func; - return; - } - - md = (struct moddata *) malloc (sizeof (struct moddata)); - if (md == NULL) - { - fprintf (stderr, - "guile: can't register module (%s): not enough memory", - module_name); - return; - } - - md->module_name = module_name; - md->init_func = init_func; - md->link = registered_mods; - registered_mods = md; -} - -SCM_DEFINE (scm_registered_modules, "c-registered-modules", 0, 0, 0, - (), - "Return a list of the object code modules that have been imported into\n" - "the current Guile process. Each element of the list is a pair whose\n" - "car is the name of the module, and whose cdr is the function handle\n" - "for that module's initializer function. The name is the string that\n" - "has been passed to scm_register_module_xxx.") -#define FUNC_NAME s_scm_registered_modules -{ - SCM res; - struct moddata *md; - - res = SCM_EOL; - for (md = registered_mods; md; md = md->link) - res = scm_cons (scm_cons (scm_from_locale_string (md->module_name), - scm_from_ulong ((unsigned long) md->init_func)), - res); - return res; -} -#undef FUNC_NAME - -SCM_DEFINE (scm_clear_registered_modules, "c-clear-registered-modules", 0, 0, 0, - (), - "Destroy the list of modules registered with the current Guile process.\n" - "The return value is unspecified. @strong{Warning:} this function does\n" - "not actually unlink or deallocate these modules, but only destroys the\n" - "records of which modules have been loaded. It should therefore be used\n" - "only by module bookkeeping operations.") -#define FUNC_NAME s_scm_clear_registered_modules -{ - struct moddata *md1, *md2; - - SCM_CRITICAL_SECTION_START; - - for (md1 = registered_mods; md1; md1 = md2) - { - md2 = md1->link; - free (md1); - } - registered_mods = NULL; - - SCM_CRITICAL_SECTION_END; - return SCM_UNSPECIFIED; -} -#undef FUNC_NAME - -void -scm_remember (SCM *ptr) -{ - scm_c_issue_deprecation_warning ("`scm_remember' is deprecated. " - "Use the `scm_remember_upto_here*' family of functions instead."); -} - -SCM -scm_protect_object (SCM obj) -{ - scm_c_issue_deprecation_warning ("`scm_protect_object' is deprecated. " - "Use `scm_gc_protect_object' instead."); - return scm_gc_protect_object (obj); -} - -SCM -scm_unprotect_object (SCM obj) -{ - scm_c_issue_deprecation_warning ("`scm_unprotect_object' is deprecated. " - "Use `scm_gc_unprotect_object' instead."); - return scm_gc_unprotect_object (obj); -} - -SCM_SYMBOL (scm_sym_app, "app"); -SCM_SYMBOL (scm_sym_modules, "modules"); -static SCM module_prefix = SCM_BOOL_F; -static SCM make_modules_in_var; -static SCM beautify_user_module_x_var; -static SCM try_module_autoload_var; - -static void -init_module_stuff () -{ - if (scm_is_false (module_prefix)) - { - module_prefix = scm_list_2 (scm_sym_app, scm_sym_modules); - make_modules_in_var = scm_c_lookup ("make-modules-in"); - beautify_user_module_x_var = - scm_c_lookup ("beautify-user-module!"); - try_module_autoload_var = scm_c_lookup ("try-module-autoload"); - } -} - -static SCM -scm_module_full_name (SCM name) -{ - init_module_stuff (); - if (scm_is_eq (SCM_CAR (name), scm_sym_app)) - return name; - else - return scm_append (scm_list_2 (module_prefix, name)); -} - -SCM -scm_make_module (SCM name) -{ - init_module_stuff (); - scm_c_issue_deprecation_warning ("`scm_make_module' is deprecated. " - "Use `scm_c_define_module instead."); - - return scm_call_2 (SCM_VARIABLE_REF (make_modules_in_var), - scm_the_root_module (), - scm_module_full_name (name)); -} - -SCM -scm_ensure_user_module (SCM module) -{ - init_module_stuff (); - scm_c_issue_deprecation_warning ("`scm_ensure_user_module' is deprecated. " - "Use `scm_c_define_module instead."); - - scm_call_1 (SCM_VARIABLE_REF (beautify_user_module_x_var), module); - return SCM_UNSPECIFIED; -} - -SCM -scm_load_scheme_module (SCM name) -{ - init_module_stuff (); - scm_c_issue_deprecation_warning ("`scm_load_scheme_module' is deprecated. " - "Use `scm_c_resolve_module instead."); - - return scm_call_1 (SCM_VARIABLE_REF (try_module_autoload_var), name); -} - -/* This is implemented in C solely for SCM_COERCE_OUTPORT ... */ - -static void -maybe_close_port (void *data, SCM port) -{ - SCM except_set = PTR2SCM (data); - - while (!scm_is_null (except_set)) - { - SCM p = SCM_COERCE_OUTPORT (SCM_CAR (except_set)); - if (scm_is_eq (p, port)) - return; - except_set = SCM_CDR (except_set); - } - - scm_close_port (port); -} - -SCM_DEFINE (scm_close_all_ports_except, "close-all-ports-except", 0, 0, 1, - (SCM ports), - "[DEPRECATED] Close all open file ports used by the interpreter\n" - "except for those supplied as arguments. This procedure\n" - "was intended to be used before an exec call to close file descriptors\n" - "which are not needed in the new process. However it has the\n" - "undesirable side effect of flushing buffers, so it's deprecated.\n" - "Use port-for-each instead.") -#define FUNC_NAME s_scm_close_all_ports_except -{ - SCM p; - SCM_VALIDATE_REST_ARGUMENT (ports); - - for (p = ports; !scm_is_null (p); p = SCM_CDR (p)) - SCM_VALIDATE_OPPORT (SCM_ARG1, SCM_COERCE_OUTPORT (SCM_CAR (p))); - - scm_c_port_for_each (maybe_close_port, SCM2PTR (ports)); - - return SCM_UNSPECIFIED; -} -#undef FUNC_NAME - -SCM_DEFINE (scm_variable_set_name_hint, "variable-set-name-hint!", 2, 0, 0, - (SCM var, SCM hint), - "Do not use this function.") -#define FUNC_NAME s_scm_variable_set_name_hint -{ - SCM_VALIDATE_VARIABLE (1, var); - SCM_VALIDATE_SYMBOL (2, hint); - scm_c_issue_deprecation_warning - ("'variable-set-name-hint!' is deprecated. Do not use it."); - return SCM_UNSPECIFIED; -} -#undef FUNC_NAME - -SCM_DEFINE (scm_builtin_variable, "builtin-variable", 1, 0, 0, - (SCM name), - "Do not use this function.") -#define FUNC_NAME s_scm_builtin_variable -{ - SCM_VALIDATE_SYMBOL (1,name); - scm_c_issue_deprecation_warning ("`builtin-variable' is deprecated. " - "Use module system operations instead."); - return scm_sym2var (name, SCM_BOOL_F, SCM_BOOL_T); -} -#undef FUNC_NAME - -SCM -scm_makstr (size_t len, int dummy) -{ - scm_c_issue_deprecation_warning - ("'scm_makstr' is deprecated. Use 'scm_c_make_string' instead."); - return scm_c_make_string (len, SCM_UNDEFINED); -} - -SCM -scm_makfromstr (const char *src, size_t len, int dummy SCM_UNUSED) -{ - scm_c_issue_deprecation_warning ("`scm_makfromstr' is deprecated. " - "Use `scm_from_locale_stringn' instead."); - - return scm_from_locale_stringn (src, len); -} - -SCM -scm_internal_with_fluids (SCM fluids, SCM values, SCM (*cproc) (), void *cdata) -{ - scm_c_issue_deprecation_warning ("`scm_internal_with_fluids' is deprecated. " - "Use `scm_c_with_fluids' instead."); - - return scm_c_with_fluids (fluids, values, cproc, cdata); -} - -SCM -scm_make_gsubr (const char *name, int req, int opt, int rst, SCM (*fcn)()) -{ - scm_c_issue_deprecation_warning - ("`scm_make_gsubr' is deprecated. Use `scm_c_define_gsubr' instead."); - - return scm_c_define_gsubr (name, req, opt, rst, fcn); -} - -SCM -scm_make_gsubr_with_generic (const char *name, - int req, int opt, int rst, - SCM (*fcn)(), SCM *gf) -{ - scm_c_issue_deprecation_warning - ("`scm_make_gsubr_with_generic' is deprecated. " - "Use `scm_c_define_gsubr_with_generic' instead."); - - return scm_c_define_gsubr_with_generic (name, req, opt, rst, fcn, gf); -} - -SCM -scm_create_hook (const char *name, int n_args) -{ - scm_c_issue_deprecation_warning - ("'scm_create_hook' is deprecated. " - "Use 'scm_make_hook' and 'scm_c_define' instead."); - { - SCM hook = scm_make_hook (scm_from_int (n_args)); - scm_c_define (name, hook); - return hook; - } -} - -SCM_DEFINE (scm_sloppy_memq, "sloppy-memq", 2, 0, 0, - (SCM x, SCM lst), - "This procedure behaves like @code{memq}, but does no type or error checking.\n" - "Its use is recommended only in writing Guile internals,\n" - "not for high-level Scheme programs.") -#define FUNC_NAME s_scm_sloppy_memq -{ - scm_c_issue_deprecation_warning - ("'sloppy-memq' is deprecated. Use 'memq' instead."); - - for(; scm_is_pair (lst); lst = SCM_CDR(lst)) - { - if (scm_is_eq (SCM_CAR (lst), x)) - return lst; - } - return lst; -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_sloppy_memv, "sloppy-memv", 2, 0, 0, - (SCM x, SCM lst), - "This procedure behaves like @code{memv}, but does no type or error checking.\n" - "Its use is recommended only in writing Guile internals,\n" - "not for high-level Scheme programs.") -#define FUNC_NAME s_scm_sloppy_memv -{ - scm_c_issue_deprecation_warning - ("'sloppy-memv' is deprecated. Use 'memv' instead."); - - for(; scm_is_pair (lst); lst = SCM_CDR(lst)) - { - if (! scm_is_false (scm_eqv_p (SCM_CAR (lst), x))) - return lst; - } - return lst; -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_sloppy_member, "sloppy-member", 2, 0, 0, - (SCM x, SCM lst), - "This procedure behaves like @code{member}, but does no type or error checking.\n" - "Its use is recommended only in writing Guile internals,\n" - "not for high-level Scheme programs.") -#define FUNC_NAME s_scm_sloppy_member -{ - scm_c_issue_deprecation_warning - ("'sloppy-member' is deprecated. Use 'member' instead."); - - for(; scm_is_pair (lst); lst = SCM_CDR(lst)) - { - if (! scm_is_false (scm_equal_p (SCM_CAR (lst), x))) - return lst; - } - return lst; -} -#undef FUNC_NAME - -SCM_SYMBOL (scm_end_of_file_key, "end-of-file"); - -SCM_DEFINE (scm_read_and_eval_x, "read-and-eval!", 0, 1, 0, - (SCM port), - "Read a form from @var{port} (standard input by default), and evaluate it\n" - "(memoizing it in the process) in the top-level environment. If no data\n" - "is left to be read from @var{port}, an @code{end-of-file} error is\n" - "signalled.") -#define FUNC_NAME s_scm_read_and_eval_x -{ - SCM form; - - scm_c_issue_deprecation_warning - ("'read-and-eval!' is deprecated. Use 'read' and 'eval' instead."); - - form = scm_read (port); - if (SCM_EOF_OBJECT_P (form)) - scm_ithrow (scm_end_of_file_key, SCM_EOL, 1); - return scm_eval_x (form, scm_current_module ()); -} -#undef FUNC_NAME - -/* Call thunk(closure) underneath a top-level error handler. - * If an error occurs, pass the exitval through err_filter and return it. - * If no error occurs, return the value of thunk. - */ - -#ifdef _UNICOS -typedef int setjmp_type; -#else -typedef long setjmp_type; -#endif - -struct cce_handler_data { - SCM (*err_filter) (); - void *closure; -}; - -static SCM -invoke_err_filter (void *d, SCM tag, SCM args) -{ - struct cce_handler_data *data = (struct cce_handler_data *)d; - return data->err_filter (SCM_BOOL_F, data->closure); -} - -SCM -scm_call_catching_errors (SCM (*thunk)(), SCM (*err_filter)(), void *closure) -{ - scm_c_issue_deprecation_warning - ("'scm_call_catching_errors' is deprecated. " - "Use 'scm_internal_catch' instead."); - - { - struct cce_handler_data data; - data.err_filter = err_filter; - data.closure = closure; - return scm_internal_catch (SCM_BOOL_T, - (scm_t_catch_body)thunk, closure, - (scm_t_catch_handler)invoke_err_filter, &data); - } -} - -long -scm_make_smob_type_mfpe (char *name, size_t size, - SCM (*mark) (SCM), - size_t (*free) (SCM), - int (*print) (SCM, SCM, scm_print_state *), - SCM (*equalp) (SCM, SCM)) -{ - scm_c_issue_deprecation_warning - ("'scm_make_smob_type_mfpe' is deprecated. " - "Use 'scm_make_smob_type' plus 'scm_set_smob_*' instead."); - - { - long answer = scm_make_smob_type (name, size); - scm_set_smob_mfpe (answer, mark, free, print, equalp); - return answer; - } -} - -void -scm_set_smob_mfpe (long tc, - SCM (*mark) (SCM), - size_t (*free) (SCM), - int (*print) (SCM, SCM, scm_print_state *), - SCM (*equalp) (SCM, SCM)) -{ - scm_c_issue_deprecation_warning - ("'scm_set_smob_mfpe' is deprecated. " - "Use 'scm_set_smob_mark' instead, for example."); - - if (mark) scm_set_smob_mark (tc, mark); - if (free) scm_set_smob_free (tc, free); - if (print) scm_set_smob_print (tc, print); - if (equalp) scm_set_smob_equalp (tc, equalp); -} - -size_t -scm_smob_free (SCM obj) -{ - long n = SCM_SMOBNUM (obj); - - scm_c_issue_deprecation_warning - ("`scm_smob_free' is deprecated. " - "It is no longer needed."); - - if (scm_smobs[n].size > 0) - scm_gc_free ((void *) SCM_SMOB_DATA_1 (obj), - scm_smobs[n].size, SCM_SMOBNAME (n)); - return 0; -} - -SCM -scm_read_0str (char *expr) -{ - scm_c_issue_deprecation_warning - ("scm_read_0str is deprecated. Use scm_c_read_string instead."); - - return scm_c_read_string (expr); -} - -SCM -scm_eval_0str (const char *expr) -{ - scm_c_issue_deprecation_warning - ("scm_eval_0str is deprecated. Use scm_c_eval_string instead."); - - return scm_c_eval_string (expr); -} - -SCM -scm_strprint_obj (SCM obj) -{ - scm_c_issue_deprecation_warning - ("scm_strprint_obj is deprecated. Use scm_object_to_string instead."); - return scm_object_to_string (obj, SCM_UNDEFINED); -} - -char * -scm_i_object_chars (SCM obj) -{ - scm_c_issue_deprecation_warning - ("SCM_CHARS is deprecated. See the manual for alternatives."); - if (SCM_STRINGP (obj)) - return SCM_STRING_CHARS (obj); - if (SCM_SYMBOLP (obj)) - return SCM_SYMBOL_CHARS (obj); - abort (); -} - -long -scm_i_object_length (SCM obj) -{ - scm_c_issue_deprecation_warning - ("SCM_LENGTH is deprecated. " - "Use scm_c_string_length instead, for example, or see the manual."); - if (SCM_STRINGP (obj)) - return SCM_STRING_LENGTH (obj); - if (SCM_SYMBOLP (obj)) - return SCM_SYMBOL_LENGTH (obj); - if (SCM_VECTORP (obj)) - return SCM_VECTOR_LENGTH (obj); - abort (); -} - -SCM -scm_sym2ovcell_soft (SCM sym, SCM obarray) -{ - SCM lsym, z; - size_t hash = scm_i_symbol_hash (sym) % SCM_VECTOR_LENGTH (obarray); - - scm_c_issue_deprecation_warning ("`scm_sym2ovcell_soft' is deprecated. " - "Use hashtables instead."); - - SCM_CRITICAL_SECTION_START; - for (lsym = SCM_VECTOR_REF (obarray, hash); - SCM_NIMP (lsym); - lsym = SCM_CDR (lsym)) - { - z = SCM_CAR (lsym); - if (scm_is_eq (SCM_CAR (z), sym)) - { - SCM_CRITICAL_SECTION_END; - return z; - } - } - SCM_CRITICAL_SECTION_END; - return SCM_BOOL_F; -} - - -SCM -scm_sym2ovcell (SCM sym, SCM obarray) -#define FUNC_NAME "scm_sym2ovcell" -{ - SCM answer; - - scm_c_issue_deprecation_warning ("`scm_sym2ovcell' is deprecated. " - "Use hashtables instead."); - - answer = scm_sym2ovcell_soft (sym, obarray); - if (scm_is_true (answer)) - return answer; - SCM_MISC_ERROR ("uninterned symbol: ~S", scm_list_1 (sym)); - return SCM_UNSPECIFIED; /* not reached */ -} -#undef FUNC_NAME - - -/* Intern a symbol whose name is the LEN characters at NAME in OBARRAY. - - OBARRAY should be a vector of lists, indexed by the name's hash - value, modulo OBARRAY's length. Each list has the form - ((SYMBOL . VALUE) ...), where SYMBOL is a symbol, and VALUE is the - value associated with that symbol (in the current module? in the - system module?) - - To "intern" a symbol means: if OBARRAY already contains a symbol by - that name, return its (SYMBOL . VALUE) pair; otherwise, create a - new symbol, add the pair (SYMBOL . SCM_UNDEFINED) to the - appropriate list of the OBARRAY, and return the pair. - - If softness is non-zero, don't create a symbol if it isn't already - in OBARRAY; instead, just return #f. - - If OBARRAY is SCM_BOOL_F, create a symbol listed in no obarray and - return (SYMBOL . SCM_UNDEFINED). */ - - -static SCM -intern_obarray_soft (SCM symbol, SCM obarray, unsigned int softness) -{ - size_t raw_hash = scm_i_symbol_hash (symbol); - size_t hash; - SCM lsym; - - if (scm_is_false (obarray)) - { - if (softness) - return SCM_BOOL_F; - else - return scm_cons (symbol, SCM_UNDEFINED); - } - - hash = raw_hash % SCM_VECTOR_LENGTH (obarray); - - for (lsym = SCM_VECTOR_REF(obarray, hash); - SCM_NIMP (lsym); lsym = SCM_CDR (lsym)) - { - SCM a = SCM_CAR (lsym); - SCM z = SCM_CAR (a); - if (scm_is_eq (z, symbol)) - return a; - } - - if (softness) - { - return SCM_BOOL_F; - } - else - { - SCM cell = scm_cons (symbol, SCM_UNDEFINED); - SCM slot = SCM_VECTOR_REF (obarray, hash); - - SCM_VECTOR_SET (obarray, hash, scm_cons (cell, slot)); - - return cell; - } -} - - -SCM -scm_intern_obarray_soft (const char *name, size_t len, SCM obarray, - unsigned int softness) -{ - SCM symbol = scm_from_locale_symboln (name, len); - - scm_c_issue_deprecation_warning ("`scm_intern_obarray_soft' is deprecated. " - "Use hashtables instead."); - - return intern_obarray_soft (symbol, obarray, softness); -} - -SCM -scm_intern_obarray (const char *name,size_t len,SCM obarray) -{ - scm_c_issue_deprecation_warning ("`scm_intern_obarray' is deprecated. " - "Use hashtables instead."); - - return scm_intern_obarray_soft (name, len, obarray, 0); -} - -/* Lookup the value of the symbol named by the nul-terminated string - NAME in the current module. */ -SCM -scm_symbol_value0 (const char *name) -{ - scm_c_issue_deprecation_warning ("`scm_symbol_value0' is deprecated. " - "Use `scm_lookup' instead."); - - return scm_variable_ref (scm_c_lookup (name)); -} - -SCM_DEFINE (scm_string_to_obarray_symbol, "string->obarray-symbol", 2, 1, 0, - (SCM o, SCM s, SCM softp), - "Intern a new symbol in @var{obarray}, a symbol table, with name\n" - "@var{string}.\n\n" - "If @var{obarray} is @code{#f}, use the default system symbol table. If\n" - "@var{obarray} is @code{#t}, the symbol should not be interned in any\n" - "symbol table; merely return the pair (@var{symbol}\n" - ". @var{#<undefined>}).\n\n" - "The @var{soft?} argument determines whether new symbol table entries\n" - "should be created when the specified symbol is not already present in\n" - "@var{obarray}. If @var{soft?} is specified and is a true value, then\n" - "new entries should not be added for symbols not already present in the\n" - "table; instead, simply return @code{#f}.") -#define FUNC_NAME s_scm_string_to_obarray_symbol -{ - SCM vcell; - SCM answer; - int softness; - - SCM_VALIDATE_STRING (2, s); - SCM_ASSERT (scm_is_bool (o) || SCM_VECTORP (o), o, SCM_ARG1, FUNC_NAME); - - scm_c_issue_deprecation_warning ("`string->obarray-symbol' is deprecated. " - "Use hashtables instead."); - - softness = (!SCM_UNBNDP (softp) && scm_is_true(softp)); - /* iron out some screwy calling conventions */ - if (scm_is_false (o)) - { - /* nothing interesting to do here. */ - return scm_string_to_symbol (s); - } - else if (scm_is_eq (o, SCM_BOOL_T)) - o = SCM_BOOL_F; - - vcell = intern_obarray_soft (scm_string_to_symbol (s), o, softness); - if (scm_is_false (vcell)) - return vcell; - answer = SCM_CAR (vcell); - return answer; -} -#undef FUNC_NAME - -SCM_DEFINE (scm_intern_symbol, "intern-symbol", 2, 0, 0, - (SCM o, SCM s), - "Add a new symbol to @var{obarray} with name @var{string}, bound to an\n" - "unspecified initial value. The symbol table is not modified if a symbol\n" - "with this name is already present.") -#define FUNC_NAME s_scm_intern_symbol -{ - size_t hval; - SCM_VALIDATE_SYMBOL (2,s); - if (scm_is_false (o)) - return SCM_UNSPECIFIED; - - scm_c_issue_deprecation_warning ("`intern-symbol' is deprecated. " - "Use hashtables instead."); - - SCM_VALIDATE_VECTOR (1,o); - hval = scm_i_symbol_hash (s) % SCM_VECTOR_LENGTH (o); - /* If the symbol is already interned, simply return. */ - SCM_CRITICAL_SECTION_START; - { - SCM lsym; - SCM sym; - for (lsym = SCM_VECTOR_REF (o, hval); - SCM_NIMP (lsym); - lsym = SCM_CDR (lsym)) - { - sym = SCM_CAR (lsym); - if (scm_is_eq (SCM_CAR (sym), s)) - { - SCM_CRITICAL_SECTION_END; - return SCM_UNSPECIFIED; - } - } - SCM_VECTOR_SET (o, hval, - scm_acons (s, SCM_UNDEFINED, - SCM_VECTOR_REF (o, hval))); - } - SCM_CRITICAL_SECTION_END; - return SCM_UNSPECIFIED; -} -#undef FUNC_NAME - -SCM_DEFINE (scm_unintern_symbol, "unintern-symbol", 2, 0, 0, - (SCM o, SCM s), - "Remove the symbol with name @var{string} from @var{obarray}. This\n" - "function returns @code{#t} if the symbol was present and @code{#f}\n" - "otherwise.") -#define FUNC_NAME s_scm_unintern_symbol -{ - size_t hval; - - scm_c_issue_deprecation_warning ("`unintern-symbol' is deprecated. " - "Use hashtables instead."); - - SCM_VALIDATE_SYMBOL (2,s); - if (scm_is_false (o)) - return SCM_BOOL_F; - SCM_VALIDATE_VECTOR (1,o); - hval = scm_i_symbol_hash (s) % SCM_VECTOR_LENGTH (o); - SCM_CRITICAL_SECTION_START; - { - SCM lsym_follow; - SCM lsym; - SCM sym; - for (lsym = SCM_VECTOR_REF (o, hval), lsym_follow = SCM_BOOL_F; - SCM_NIMP (lsym); - lsym_follow = lsym, lsym = SCM_CDR (lsym)) - { - sym = SCM_CAR (lsym); - if (scm_is_eq (SCM_CAR (sym), s)) - { - /* Found the symbol to unintern. */ - if (scm_is_false (lsym_follow)) - SCM_VECTOR_SET (o, hval, lsym); - else - SCM_SETCDR (lsym_follow, SCM_CDR(lsym)); - SCM_CRITICAL_SECTION_END; - return SCM_BOOL_T; - } - } - } - SCM_CRITICAL_SECTION_END; - return SCM_BOOL_F; -} -#undef FUNC_NAME - -SCM_DEFINE (scm_symbol_binding, "symbol-binding", 2, 0, 0, - (SCM o, SCM s), - "Look up in @var{obarray} the symbol whose name is @var{string}, and\n" - "return the value to which it is bound. If @var{obarray} is @code{#f},\n" - "use the global symbol table. If @var{string} is not interned in\n" - "@var{obarray}, an error is signalled.") -#define FUNC_NAME s_scm_symbol_binding -{ - SCM vcell; - - scm_c_issue_deprecation_warning ("`symbol-binding' is deprecated. " - "Use hashtables instead."); - - SCM_VALIDATE_SYMBOL (2,s); - if (scm_is_false (o)) - return scm_variable_ref (scm_lookup (s)); - SCM_VALIDATE_VECTOR (1,o); - vcell = scm_sym2ovcell (s, o); - return SCM_CDR(vcell); -} -#undef FUNC_NAME - -#if 0 -SCM_DEFINE (scm_symbol_interned_p, "symbol-interned?", 2, 0, 0, - (SCM o, SCM s), - "Return @code{#t} if @var{obarray} contains a symbol with name\n" - "@var{string}, and @code{#f} otherwise.") -#define FUNC_NAME s_scm_symbol_interned_p -{ - SCM vcell; - - scm_c_issue_deprecation_warning ("`symbol-interned?' is deprecated. " - "Use hashtables instead."); - - SCM_VALIDATE_SYMBOL (2,s); - if (scm_is_false (o)) - { - SCM var = scm_sym2var (s, SCM_BOOL_F, SCM_BOOL_F); - if (var != SCM_BOOL_F) - return SCM_BOOL_T; - return SCM_BOOL_F; - } - SCM_VALIDATE_VECTOR (1,o); - vcell = scm_sym2ovcell_soft (s, o); - return (SCM_NIMP(vcell) - ? SCM_BOOL_T - : SCM_BOOL_F); -} -#undef FUNC_NAME -#endif - -SCM_DEFINE (scm_symbol_bound_p, "symbol-bound?", 2, 0, 0, - (SCM o, SCM s), - "Return @code{#t} if @var{obarray} contains a symbol with name\n" - "@var{string} bound to a defined value. This differs from\n" - "@var{symbol-interned?} in that the mere mention of a symbol\n" - "usually causes it to be interned; @code{symbol-bound?}\n" - "determines whether a symbol has been given any meaningful\n" - "value.") -#define FUNC_NAME s_scm_symbol_bound_p -{ - SCM vcell; - - scm_c_issue_deprecation_warning ("`symbol-bound?' is deprecated. " - "Use hashtables instead."); - - SCM_VALIDATE_SYMBOL (2,s); - if (scm_is_false (o)) - { - SCM var = scm_sym2var (s, SCM_BOOL_F, SCM_BOOL_F); - if (SCM_VARIABLEP(var) && !SCM_UNBNDP(SCM_VARIABLE_REF(var))) - return SCM_BOOL_T; - return SCM_BOOL_F; - } - SCM_VALIDATE_VECTOR (1,o); - vcell = scm_sym2ovcell_soft (s, o); - return scm_from_bool (SCM_NIMP (vcell) && !SCM_UNBNDP (SCM_CDR (vcell))); -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_symbol_set_x, "symbol-set!", 3, 0, 0, - (SCM o, SCM s, SCM v), - "Find the symbol in @var{obarray} whose name is @var{string}, and rebind\n" - "it to @var{value}. An error is signalled if @var{string} is not present\n" - "in @var{obarray}.") -#define FUNC_NAME s_scm_symbol_set_x -{ - SCM vcell; - - scm_c_issue_deprecation_warning ("`symbol-set!' is deprecated. " - "Use the module system instead."); - - SCM_VALIDATE_SYMBOL (2,s); - if (scm_is_false (o)) - { - scm_define (s, v); - return SCM_UNSPECIFIED; - } - SCM_VALIDATE_VECTOR (1,o); - vcell = scm_sym2ovcell (s, o); - SCM_SETCDR (vcell, v); - return SCM_UNSPECIFIED; -} -#undef FUNC_NAME - -#define MAX_PREFIX_LENGTH 30 - -static int gentemp_counter; - -SCM_DEFINE (scm_gentemp, "gentemp", 0, 2, 0, - (SCM prefix, SCM obarray), - "Create a new symbol with a name unique in an obarray.\n" - "The name is constructed from an optional string @var{prefix}\n" - "and a counter value. The default prefix is @code{t}. The\n" - "@var{obarray} is specified as a second optional argument.\n" - "Default is the system obarray where all normal symbols are\n" - "interned. The counter is increased by 1 at each\n" - "call. There is no provision for resetting the counter.") -#define FUNC_NAME s_scm_gentemp -{ - char buf[MAX_PREFIX_LENGTH + SCM_INTBUFLEN]; - char *name = buf; - int n_digits; - size_t len; - - scm_c_issue_deprecation_warning ("`gentemp' is deprecated. " - "Use `gensym' instead."); - - if (SCM_UNBNDP (prefix)) - { - name[0] = 't'; - len = 1; - } - else - { - SCM_VALIDATE_STRING (1, prefix); - len = scm_i_string_length (prefix); - name = scm_to_locale_stringn (prefix, &len); - name = scm_realloc (name, len + SCM_INTBUFLEN); - } - - if (SCM_UNBNDP (obarray)) - return scm_gensym (prefix); - else - SCM_ASSERT ((scm_is_vector (obarray) || SCM_I_WVECTP (obarray)), - obarray, - SCM_ARG2, - FUNC_NAME); - do - n_digits = scm_iint2str (gentemp_counter++, 10, &name[len]); - while (scm_is_true (scm_intern_obarray_soft (name, - len + n_digits, - obarray, - 1))); - { - SCM vcell = scm_intern_obarray_soft (name, - len + n_digits, - obarray, - 0); - if (name != buf) - free (name); - return SCM_CAR (vcell); - } -} -#undef FUNC_NAME - -SCM -scm_i_makinum (scm_t_signed_bits val) -{ - scm_c_issue_deprecation_warning - ("SCM_MAKINUM is deprecated. Use scm_from_int or similar instead."); - return SCM_I_MAKINUM (val); -} - -int -scm_i_inump (SCM obj) -{ - scm_c_issue_deprecation_warning - ("SCM_INUMP is deprecated. Use scm_is_integer or similar instead."); - return SCM_I_INUMP (obj); -} - -scm_t_signed_bits -scm_i_inum (SCM obj) -{ - scm_c_issue_deprecation_warning - ("SCM_INUM is deprecated. Use scm_to_int or similar instead."); - return scm_to_intmax (obj); -} - -char * -scm_c_string2str (SCM obj, char *str, size_t *lenp) -{ - scm_c_issue_deprecation_warning - ("scm_c_string2str is deprecated. Use scm_to_locale_stringbuf or similar instead."); - - if (str == NULL) - { - char *result = scm_to_locale_string (obj); - if (lenp) - *lenp = scm_i_string_length (obj); - return result; - } - else - { - /* Pray that STR is large enough. - */ - size_t len = scm_to_locale_stringbuf (obj, str, SCM_I_SIZE_MAX); - str[len] = '\0'; - if (lenp) - *lenp = len; - return str; - } -} - -char * -scm_c_substring2str (SCM obj, char *str, size_t start, size_t len) -{ - scm_c_issue_deprecation_warning - ("scm_c_substring2str is deprecated. Use scm_substring plus scm_to_locale_stringbuf instead."); - - if (start) - obj = scm_substring (obj, scm_from_size_t (start), SCM_UNDEFINED); - - scm_to_locale_stringbuf (obj, str, len); - return str; -} - -/* Converts the given Scheme symbol OBJ into a C string, containing a copy - of OBJ's content with a trailing null byte. If LENP is non-NULL, set - *LENP to the string's length. - - When STR is non-NULL it receives the copy and is returned by the function, - otherwise new memory is allocated and the caller is responsible for - freeing it via free(). If out of memory, NULL is returned. - - Note that Scheme symbols may contain arbitrary data, including null - characters. This means that null termination is not a reliable way to - determine the length of the returned value. However, the function always - copies the complete contents of OBJ, and sets *LENP to the length of the - scheme symbol (if LENP is non-null). */ -char * -scm_c_symbol2str (SCM obj, char *str, size_t *lenp) -{ - return scm_c_string2str (scm_symbol_to_string (obj), str, lenp); -} - -double -scm_truncate (double x) -{ - scm_c_issue_deprecation_warning - ("scm_truncate is deprecated. Use scm_c_truncate instead."); - return scm_c_truncate (x); -} - -double -scm_round (double x) -{ - scm_c_issue_deprecation_warning - ("scm_round is deprecated. Use scm_c_round instead."); - return scm_c_round (x); -} - -SCM -scm_sys_expt (SCM x, SCM y) -{ - scm_c_issue_deprecation_warning - ("scm_sys_expt is deprecated. Use scm_expt instead."); - return scm_expt (x, y); -} - -double -scm_asinh (double x) -{ - scm_c_issue_deprecation_warning - ("scm_asinh is deprecated. Use asinh instead."); -#if HAVE_ASINH - return asinh (x); -#else - return log (x + sqrt (x * x + 1)); -#endif -} - -double -scm_acosh (double x) -{ - scm_c_issue_deprecation_warning - ("scm_acosh is deprecated. Use acosh instead."); -#if HAVE_ACOSH - return acosh (x); -#else - return log (x + sqrt (x * x - 1)); -#endif -} - -double -scm_atanh (double x) -{ - scm_c_issue_deprecation_warning - ("scm_atanh is deprecated. Use atanh instead."); -#if HAVE_ATANH - return atanh (x); -#else - return 0.5 * log ((1 + x) / (1 - x)); -#endif -} - -SCM -scm_sys_atan2 (SCM z1, SCM z2) -{ - scm_c_issue_deprecation_warning - ("scm_sys_atan2 is deprecated. Use scm_atan instead."); - return scm_atan (z1, z2); -} - -char * -scm_i_deprecated_symbol_chars (SCM sym) -{ - scm_c_issue_deprecation_warning - ("SCM_SYMBOL_CHARS is deprecated. Use scm_symbol_to_string."); - - return (char *)scm_i_symbol_chars (sym); -} - -size_t -scm_i_deprecated_symbol_length (SCM sym) -{ - scm_c_issue_deprecation_warning - ("SCM_SYMBOL_LENGTH is deprecated. Use scm_symbol_to_string."); - return scm_i_symbol_length (sym); -} - -int -scm_i_keywordp (SCM obj) -{ - scm_c_issue_deprecation_warning - ("SCM_KEYWORDP is deprecated. Use scm_is_keyword instead."); - return scm_is_keyword (obj); -} - -SCM -scm_i_keywordsym (SCM keyword) -{ - scm_c_issue_deprecation_warning - ("SCM_KEYWORDSYM is deprecated. See scm_keyword_to_symbol instead."); - return scm_keyword_dash_symbol (keyword); -} - -int -scm_i_vectorp (SCM x) -{ - scm_c_issue_deprecation_warning - ("SCM_VECTORP is deprecated. Use scm_is_vector instead."); - return SCM_I_IS_VECTOR (x); -} - -unsigned long -scm_i_vector_length (SCM x) -{ - scm_c_issue_deprecation_warning - ("SCM_VECTOR_LENGTH is deprecated. Use scm_c_vector_length instead."); - return SCM_I_VECTOR_LENGTH (x); -} - -const SCM * -scm_i_velts (SCM x) -{ - scm_c_issue_deprecation_warning - ("SCM_VELTS is deprecated. Use scm_vector_elements instead."); - return SCM_I_VECTOR_ELTS (x); -} - -SCM * -scm_i_writable_velts (SCM x) -{ - scm_c_issue_deprecation_warning - ("SCM_WRITABLE_VELTS is deprecated. " - "Use scm_vector_writable_elements instead."); - return SCM_I_VECTOR_WELTS (x); -} - -SCM -scm_i_vector_ref (SCM x, size_t idx) -{ - scm_c_issue_deprecation_warning - ("SCM_VECTOR_REF is deprecated. " - "Use scm_c_vector_ref or scm_vector_elements instead."); - return scm_c_vector_ref (x, idx); -} - -void -scm_i_vector_set (SCM x, size_t idx, SCM val) -{ - scm_c_issue_deprecation_warning - ("SCM_VECTOR_SET is deprecated. " - "Use scm_c_vector_set_x or scm_vector_writable_elements instead."); - scm_c_vector_set_x (x, idx, val); -} - -SCM -scm_vector_equal_p (SCM x, SCM y) -{ - scm_c_issue_deprecation_warning - ("scm_vector_euqal_p is deprecated. " - "Use scm_equal_p instead."); - return scm_equal_p (x, y); -} - -SCM_DEFINE (scm_uniform_vector_read_x, "uniform-vector-read!", 1, 3, 0, - (SCM uvec, SCM port_or_fd, SCM start, SCM end), - "Fill the elements of @var{uvec} by reading\n" - "raw bytes from @var{port-or-fdes}, using host byte order.\n\n" - "The optional arguments @var{start} (inclusive) and @var{end}\n" - "(exclusive) allow a specified region to be read,\n" - "leaving the remainder of the vector unchanged.\n\n" - "When @var{port-or-fdes} is a port, all specified elements\n" - "of @var{uvec} are attempted to be read, potentially blocking\n" - "while waiting for more input or end-of-file.\n" - "When @var{port-or-fd} is an integer, a single call to\n" - "read(2) is made.\n\n" - "An error is signalled when the last element has only\n" - "been partially filled before reaching end-of-file or in\n" - "the single call to read(2).\n\n" - "@code{uniform-vector-read!} returns the number of elements\n" - "read.\n\n" - "@var{port-or-fdes} may be omitted, in which case it defaults\n" - "to the value returned by @code{(current-input-port)}.") -#define FUNC_NAME s_scm_uniform_vector_read_x -{ - SCM result; - size_t c_width, c_start, c_end; - - SCM_VALIDATE_BYTEVECTOR (SCM_ARG1, uvec); - - scm_c_issue_deprecation_warning - ("`uniform-vector-read!' is deprecated. Use `get-bytevector-n!' from\n" - "`(rnrs io ports)' instead."); - - if (SCM_UNBNDP (port_or_fd)) - port_or_fd = scm_current_input_port (); - - c_width = scm_to_size_t (scm_uniform_vector_element_size (uvec)); - - c_start = SCM_UNBNDP (start) ? 0 : scm_to_size_t (start); - c_start *= c_width; - - c_end = SCM_UNBNDP (end) ? SCM_BYTEVECTOR_LENGTH (uvec) : scm_to_size_t (end); - c_end *= c_width; - - result = scm_get_bytevector_n_x (port_or_fd, uvec, - scm_from_size_t (c_start), - scm_from_size_t (c_end - c_start)); - - if (SCM_EOF_OBJECT_P (result)) - result = SCM_INUM0; - - return result; -} -#undef FUNC_NAME - -SCM_DEFINE (scm_uniform_vector_write, "uniform-vector-write", 1, 3, 0, - (SCM uvec, SCM port_or_fd, SCM start, SCM end), - "Write the elements of @var{uvec} as raw bytes to\n" - "@var{port-or-fdes}, in the host byte order.\n\n" - "The optional arguments @var{start} (inclusive)\n" - "and @var{end} (exclusive) allow\n" - "a specified region to be written.\n\n" - "When @var{port-or-fdes} is a port, all specified elements\n" - "of @var{uvec} are attempted to be written, potentially blocking\n" - "while waiting for more room.\n" - "When @var{port-or-fd} is an integer, a single call to\n" - "write(2) is made.\n\n" - "An error is signalled when the last element has only\n" - "been partially written in the single call to write(2).\n\n" - "The number of objects actually written is returned.\n" - "@var{port-or-fdes} may be\n" - "omitted, in which case it defaults to the value returned by\n" - "@code{(current-output-port)}.") -#define FUNC_NAME s_scm_uniform_vector_write -{ - size_t c_width, c_start, c_end; - - SCM_VALIDATE_BYTEVECTOR (SCM_ARG1, uvec); - - scm_c_issue_deprecation_warning - ("`uniform-vector-write' is deprecated. Use `put-bytevector' from\n" - "`(rnrs io ports)' instead."); - - if (SCM_UNBNDP (port_or_fd)) - port_or_fd = scm_current_output_port (); - - port_or_fd = SCM_COERCE_OUTPORT (port_or_fd); - - c_width = scm_to_size_t (scm_uniform_vector_element_size (uvec)); - - c_start = SCM_UNBNDP (start) ? 0 : scm_to_size_t (start); - c_start *= c_width; - - c_end = SCM_UNBNDP (end) ? SCM_BYTEVECTOR_LENGTH (uvec) : scm_to_size_t (end); - c_end *= c_width; - - return scm_put_bytevector (port_or_fd, uvec, - scm_from_size_t (c_start), - scm_from_size_t (c_end - c_start)); -} -#undef FUNC_NAME - -static SCM -scm_ra2contig (SCM ra, int copy) -{ - SCM ret; - long inc = 1; - size_t k, len = 1; - for (k = SCM_I_ARRAY_NDIM (ra); k--;) - len *= SCM_I_ARRAY_DIMS (ra)[k].ubnd - SCM_I_ARRAY_DIMS (ra)[k].lbnd + 1; - k = SCM_I_ARRAY_NDIM (ra); - if (SCM_I_ARRAY_CONTP (ra) && ((0 == k) || (1 == SCM_I_ARRAY_DIMS (ra)[k - 1].inc))) - { - if (!scm_is_bitvector (SCM_I_ARRAY_V (ra))) - return ra; - if ((len == scm_c_bitvector_length (SCM_I_ARRAY_V (ra)) && - 0 == SCM_I_ARRAY_BASE (ra) % SCM_LONG_BIT && - 0 == len % SCM_LONG_BIT)) - return ra; - } - ret = scm_i_make_array (k); - SCM_I_ARRAY_BASE (ret) = 0; - while (k--) - { - SCM_I_ARRAY_DIMS (ret)[k].lbnd = SCM_I_ARRAY_DIMS (ra)[k].lbnd; - SCM_I_ARRAY_DIMS (ret)[k].ubnd = SCM_I_ARRAY_DIMS (ra)[k].ubnd; - SCM_I_ARRAY_DIMS (ret)[k].inc = inc; - inc *= SCM_I_ARRAY_DIMS (ra)[k].ubnd - SCM_I_ARRAY_DIMS (ra)[k].lbnd + 1; - } - SCM_I_ARRAY_V (ret) = - scm_make_generalized_vector (scm_array_type (ra), scm_from_size_t (inc), - SCM_UNDEFINED); - if (copy) - scm_array_copy_x (ra, ret); - return ret; -} - -SCM_DEFINE (scm_uniform_array_read_x, "uniform-array-read!", 1, 3, 0, - (SCM ura, SCM port_or_fd, SCM start, SCM end), - "@deffnx {Scheme Procedure} uniform-vector-read! uve [port-or-fdes] [start] [end]\n" - "Attempt to read all elements of @var{ura}, in lexicographic order, as\n" - "binary objects from @var{port-or-fdes}.\n" - "If an end of file is encountered,\n" - "the objects up to that point are put into @var{ura}\n" - "(starting at the beginning) and the remainder of the array is\n" - "unchanged.\n\n" - "The optional arguments @var{start} and @var{end} allow\n" - "a specified region of a vector (or linearized array) to be read,\n" - "leaving the remainder of the vector unchanged.\n\n" - "@code{uniform-array-read!} returns the number of objects read.\n" - "@var{port-or-fdes} may be omitted, in which case it defaults to the value\n" - "returned by @code{(current-input-port)}.") -#define FUNC_NAME s_scm_uniform_array_read_x -{ - if (SCM_UNBNDP (port_or_fd)) - port_or_fd = scm_current_input_port (); - - if (scm_is_uniform_vector (ura)) - { - return scm_uniform_vector_read_x (ura, port_or_fd, start, end); - } - else if (SCM_I_ARRAYP (ura)) - { - size_t base, vlen, cstart, cend; - SCM cra, ans; - - cra = scm_ra2contig (ura, 0); - base = SCM_I_ARRAY_BASE (cra); - vlen = SCM_I_ARRAY_DIMS (cra)->inc * - (SCM_I_ARRAY_DIMS (cra)->ubnd - SCM_I_ARRAY_DIMS (cra)->lbnd + 1); - - cstart = 0; - cend = vlen; - if (!SCM_UNBNDP (start)) - { - cstart = scm_to_unsigned_integer (start, 0, vlen); - if (!SCM_UNBNDP (end)) - cend = scm_to_unsigned_integer (end, cstart, vlen); - } - - ans = scm_uniform_vector_read_x (SCM_I_ARRAY_V (cra), port_or_fd, - scm_from_size_t (base + cstart), - scm_from_size_t (base + cend)); - - if (!scm_is_eq (cra, ura)) - scm_array_copy_x (cra, ura); - return ans; - } - else - scm_wrong_type_arg_msg (NULL, 0, ura, "array"); -} -#undef FUNC_NAME - -SCM_DEFINE (scm_uniform_array_write, "uniform-array-write", 1, 3, 0, - (SCM ura, SCM port_or_fd, SCM start, SCM end), - "Writes all elements of @var{ura} as binary objects to\n" - "@var{port-or-fdes}.\n\n" - "The optional arguments @var{start}\n" - "and @var{end} allow\n" - "a specified region of a vector (or linearized array) to be written.\n\n" - "The number of objects actually written is returned.\n" - "@var{port-or-fdes} may be\n" - "omitted, in which case it defaults to the value returned by\n" - "@code{(current-output-port)}.") -#define FUNC_NAME s_scm_uniform_array_write -{ - if (SCM_UNBNDP (port_or_fd)) - port_or_fd = scm_current_output_port (); - - if (scm_is_uniform_vector (ura)) - { - return scm_uniform_vector_write (ura, port_or_fd, start, end); - } - else if (SCM_I_ARRAYP (ura)) - { - size_t base, vlen, cstart, cend; - SCM cra, ans; - - cra = scm_ra2contig (ura, 1); - base = SCM_I_ARRAY_BASE (cra); - vlen = SCM_I_ARRAY_DIMS (cra)->inc * - (SCM_I_ARRAY_DIMS (cra)->ubnd - SCM_I_ARRAY_DIMS (cra)->lbnd + 1); - - cstart = 0; - cend = vlen; - if (!SCM_UNBNDP (start)) - { - cstart = scm_to_unsigned_integer (start, 0, vlen); - if (!SCM_UNBNDP (end)) - cend = scm_to_unsigned_integer (end, cstart, vlen); - } - - ans = scm_uniform_vector_write (SCM_I_ARRAY_V (cra), port_or_fd, - scm_from_size_t (base + cstart), - scm_from_size_t (base + cend)); - - return ans; - } - else - scm_wrong_type_arg_msg (NULL, 0, ura, "array"); -} -#undef FUNC_NAME - -SCM -scm_i_cur_inp (void) -{ - scm_c_issue_deprecation_warning - ("scm_cur_inp is deprecated. Use scm_current_input_port instead."); - return scm_current_input_port (); -} - -SCM -scm_i_cur_outp (void) -{ - scm_c_issue_deprecation_warning - ("scm_cur_outp is deprecated. Use scm_current_output_port instead."); - return scm_current_output_port (); -} - -SCM -scm_i_cur_errp (void) -{ - scm_c_issue_deprecation_warning - ("scm_cur_errp is deprecated. Use scm_current_error_port instead."); - return scm_current_error_port (); -} - -SCM -scm_i_cur_loadp (void) -{ - scm_c_issue_deprecation_warning - ("scm_cur_loadp is deprecated. Use scm_current_load_port instead."); - return scm_current_load_port (); -} - -SCM -scm_i_progargs (void) -{ - scm_c_issue_deprecation_warning - ("scm_progargs is deprecated. Use scm_program_arguments instead."); - return scm_program_arguments (); -} - -SCM -scm_i_deprecated_dynwinds (void) -{ - scm_c_issue_deprecation_warning - ("scm_dynwinds is deprecated. Do not use it."); - return scm_i_dynwinds (); -} - -SCM_STACKITEM * -scm_i_stack_base (void) -{ - scm_c_issue_deprecation_warning - ("scm_stack_base is deprecated. Do not use it."); - return SCM_I_CURRENT_THREAD->base; -} - -int -scm_i_fluidp (SCM x) -{ - scm_c_issue_deprecation_warning - ("SCM_FLUIDP is deprecated. Use scm_is_fluid instead."); - return scm_is_fluid (x); -} - - -/* Networking. */ - -#ifdef HAVE_NETWORKING - -SCM_DEFINE (scm_inet_aton, "inet-aton", 1, 0, 0, - (SCM address), - "Convert an IPv4 Internet address from printable string\n" - "(dotted decimal notation) to an integer. E.g.,\n\n" - "@lisp\n" - "(inet-aton \"127.0.0.1\") @result{} 2130706433\n" - "@end lisp") -#define FUNC_NAME s_scm_inet_aton -{ - scm_c_issue_deprecation_warning - ("`inet-aton' is deprecated. Use `inet-pton' instead."); - - return scm_inet_pton (scm_from_int (AF_INET), address); -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_inet_ntoa, "inet-ntoa", 1, 0, 0, - (SCM inetid), - "Convert an IPv4 Internet address to a printable\n" - "(dotted decimal notation) string. E.g.,\n\n" - "@lisp\n" - "(inet-ntoa 2130706433) @result{} \"127.0.0.1\"\n" - "@end lisp") -#define FUNC_NAME s_scm_inet_ntoa -{ - scm_c_issue_deprecation_warning - ("`inet-ntoa' is deprecated. Use `inet-ntop' instead."); - - return scm_inet_ntop (scm_from_int (AF_INET), inetid); -} -#undef FUNC_NAME - -#endif /* HAVE_NETWORKING */ - - -void -scm_i_defer_ints_etc () -{ - scm_c_issue_deprecation_warning - ("SCM_DEFER_INTS etc are deprecated. " - "Use a mutex instead if appropriate."); -} - -int -scm_i_mask_ints (void) -{ - scm_c_issue_deprecation_warning ("`scm_mask_ints' is deprecated."); - return (SCM_I_CURRENT_THREAD->block_asyncs != 0); -} - - -SCM -scm_guard (SCM guardian, SCM obj, int throw_p) -{ - scm_c_issue_deprecation_warning - ("scm_guard is deprecated. Use scm_call_1 instead."); - - return scm_call_1 (guardian, obj); -} - -SCM -scm_get_one_zombie (SCM guardian) -{ - scm_c_issue_deprecation_warning - ("scm_guard is deprecated. Use scm_call_0 instead."); - - return scm_call_0 (guardian); -} - -SCM_DEFINE (scm_guardian_destroyed_p, "guardian-destroyed?", 1, 0, 0, - (SCM guardian), - "Return @code{#t} if @var{guardian} has been destroyed, otherwise @code{#f}.") -#define FUNC_NAME s_scm_guardian_destroyed_p -{ - scm_c_issue_deprecation_warning - ("'guardian-destroyed?' is deprecated."); - return SCM_BOOL_F; -} -#undef FUNC_NAME - -SCM_DEFINE (scm_guardian_greedy_p, "guardian-greedy?", 1, 0, 0, - (SCM guardian), - "Return @code{#t} if @var{guardian} is a greedy guardian, otherwise @code{#f}.") -#define FUNC_NAME s_scm_guardian_greedy_p -{ - scm_c_issue_deprecation_warning - ("'guardian-greedy?' is deprecated."); - return SCM_BOOL_F; -} -#undef FUNC_NAME - -SCM_DEFINE (scm_destroy_guardian_x, "destroy-guardian!", 1, 0, 0, - (SCM guardian), - "Destroys @var{guardian}, by making it impossible to put any more\n" - "objects in it or get any objects from it. It also unguards any\n" - "objects guarded by @var{guardian}.") -#define FUNC_NAME s_scm_destroy_guardian_x -{ - scm_c_issue_deprecation_warning - ("'destroy-guardian!' is deprecated and ineffective."); - return SCM_UNSPECIFIED; -} -#undef FUNC_NAME - - -/* GC-related things. */ - -unsigned long scm_mallocated, scm_mtrigger; -size_t scm_max_segment_size; - -#if defined (GUILE_DEBUG) || defined (GUILE_DEBUG_FREELIST) -SCM -scm_map_free_list (void) -{ - return SCM_EOL; -} -#endif - -#if defined (GUILE_DEBUG_FREELIST) -SCM -scm_gc_set_debug_check_freelist_x (SCM flag) -{ - return SCM_UNSPECIFIED; -} -#endif - - -/* Trampolines - * - * Trampolines were an intent to speed up calling the same Scheme procedure many - * times from C. - * - * However, this was the wrong thing to optimize; if you really know what you're - * calling, call its function directly, otherwise you're in Scheme-land, and we - * have many better tricks there (inlining, for example, which can remove the - * need for closures and free variables). - * - * Also, in the normal debugging case, trampolines were being computed but not - * used. Silliness. - */ - -scm_t_trampoline_0 -scm_trampoline_0 (SCM proc) -{ - scm_c_issue_deprecation_warning - ("`scm_trampoline_0' is deprecated. Just use `scm_call_0' instead."); - return scm_call_0; -} - -scm_t_trampoline_1 -scm_trampoline_1 (SCM proc) -{ - scm_c_issue_deprecation_warning - ("`scm_trampoline_1' is deprecated. Just use `scm_call_1' instead."); - return scm_call_1; -} - -scm_t_trampoline_2 -scm_trampoline_2 (SCM proc) -{ - scm_c_issue_deprecation_warning - ("`scm_trampoline_2' is deprecated. Just use `scm_call_2' instead."); - return scm_call_2; -} - -int -scm_i_subr_p (SCM x) -{ - scm_c_issue_deprecation_warning ("`scm_subr_p' is deprecated. Use SCM_PRIMITIVE_P instead."); - return SCM_PRIMITIVE_P (x); -} - - - -SCM -scm_internal_lazy_catch (SCM tag, scm_t_catch_body body, void *body_data, scm_t_catch_handler handler, void *handler_data) -{ - scm_c_issue_deprecation_warning - ("`scm_internal_lazy_catch' is no longer supported. Instead this call will\n" - "dispatch to `scm_c_with_throw_handler'. Your handler will be invoked from\n" - "within the dynamic context of the corresponding `throw'.\n" - "\nTHIS COULD CHANGE YOUR PROGRAM'S BEHAVIOR.\n\n" - "Please modify your program to use `scm_c_with_throw_handler' directly,\n" - "and adapt it (if necessary) to expect to be within the dynamic context\n" - "of the throw."); - return scm_c_with_throw_handler (tag, body, body_data, handler, handler_data, 0); -} - -SCM_DEFINE (scm_lazy_catch, "lazy-catch", 3, 0, 0, - (SCM key, SCM thunk, SCM handler), - "This behaves exactly like @code{catch}, except that it does\n" - "not unwind the stack before invoking @var{handler}.\n" - "If the @var{handler} procedure returns normally, Guile\n" - "rethrows the same exception again to the next innermost catch,\n" - "lazy-catch or throw handler. If the @var{handler} exits\n" - "non-locally, that exit determines the continuation.") -#define FUNC_NAME s_scm_lazy_catch -{ - struct scm_body_thunk_data c; - - SCM_ASSERT (scm_is_symbol (key) || scm_is_eq (key, SCM_BOOL_T), - key, SCM_ARG1, FUNC_NAME); - - c.tag = key; - c.body_proc = thunk; - - scm_c_issue_deprecation_warning - ("`lazy-catch' is no longer supported. Instead this call will dispatch\n" - "to `with-throw-handler'. Your handler will be invoked from within the\n" - "dynamic context of the corresponding `throw'.\n" - "\nTHIS COULD CHANGE YOUR PROGRAM'S BEHAVIOR.\n\n" - "Please modify your program to use `with-throw-handler' directly, and\n" - "adapt it (if necessary) to expect to be within the dynamic context of\n" - "the throw."); - - return scm_c_with_throw_handler (key, - scm_body_thunk, &c, - scm_handle_by_proc, &handler, 0); -} -#undef FUNC_NAME - - - - - -SCM -scm_raequal (SCM ra0, SCM ra1) -{ - return scm_array_equal_p (ra0, ra1); -} - - - - - -SCM_DEFINE (scm_dynamic_args_call, "dynamic-args-call", 3, 0, 0, - (SCM func, SCM dobj, SCM args), - "Call the C function indicated by @var{func} and @var{dobj},\n" - "just like @code{dynamic-call}, but pass it some arguments and\n" - "return its return value. The C function is expected to take\n" - "two arguments and return an @code{int}, just like @code{main}:\n" - "@smallexample\n" - "int c_func (int argc, char **argv);\n" - "@end smallexample\n\n" - "The parameter @var{args} must be a list of strings and is\n" - "converted into an array of @code{char *}. The array is passed\n" - "in @var{argv} and its size in @var{argc}. The return value is\n" - "converted to a Scheme number and returned from the call to\n" - "@code{dynamic-args-call}.") -#define FUNC_NAME s_scm_dynamic_args_call -{ - int (*fptr) (int argc, char **argv); - int result, argc; - char **argv; - - if (scm_is_string (func)) - { -#if HAVE_MODULES - func = scm_dynamic_func (func, dobj); -#else - scm_misc_error ("dynamic-args-call", - "dynamic-func not available to resolve ~S", - scm_list_1 (func)); -#endif - } - SCM_VALIDATE_POINTER (SCM_ARG1, func); - - fptr = SCM_POINTER_VALUE (func); - - argv = scm_i_allocate_string_pointers (args); - for (argc = 0; argv[argc]; argc++) - ; - result = (*fptr) (argc, argv); - - return scm_from_int (result); -} -#undef FUNC_NAME - - - - - -int -scm_badargsp (SCM formals, SCM args) -{ - scm_c_issue_deprecation_warning - ("`scm_badargsp' is deprecated. Copy it into your project if you need it."); - - while (!scm_is_null (formals)) - { - if (!scm_is_pair (formals)) - return 0; - if (scm_is_null (args)) - return 1; - formals = scm_cdr (formals); - args = scm_cdr (args); - } - return !scm_is_null (args) ? 1 : 0; -} - - - -/* scm_internal_stack_catch - Use this one if you want debugging information to be stored in - the-last-stack on error. */ - -static SCM -ss_handler (void *data SCM_UNUSED, SCM tag, SCM throw_args) -{ - /* In the stack */ - scm_fluid_set_x (scm_variable_ref - (scm_c_module_lookup - (scm_c_resolve_module ("ice-9 save-stack"), - "the-last-stack")), - scm_make_stack (SCM_BOOL_T, SCM_EOL)); - /* Throw the error */ - return scm_throw (tag, throw_args); -} - -struct cwss_data -{ - SCM tag; - scm_t_catch_body body; - void *data; -}; - -static SCM -cwss_body (void *data) -{ - struct cwss_data *d = data; - return scm_c_with_throw_handler (d->tag, d->body, d->data, ss_handler, NULL, 0); -} - -SCM -scm_internal_stack_catch (SCM tag, - scm_t_catch_body body, - void *body_data, - scm_t_catch_handler handler, - void *handler_data) -{ - struct cwss_data d; - d.tag = tag; - d.body = body; - d.data = body_data; - scm_c_issue_deprecation_warning - ("`scm_internal_stack_catch' is deprecated. Talk to guile-devel if you see this message."); - return scm_internal_catch (tag, cwss_body, &d, handler, handler_data); -} - - - -SCM -scm_short2num (short x) -{ - scm_c_issue_deprecation_warning - ("`scm_short2num' is deprecated. Use scm_from_short instead."); - return scm_from_short (x); -} - -SCM -scm_ushort2num (unsigned short x) -{ - scm_c_issue_deprecation_warning - ("`scm_ushort2num' is deprecated. Use scm_from_ushort instead."); - return scm_from_ushort (x); -} - -SCM -scm_int2num (int x) -{ - scm_c_issue_deprecation_warning - ("`scm_int2num' is deprecated. Use scm_from_int instead."); - return scm_from_int (x); -} - -SCM -scm_uint2num (unsigned int x) -{ - scm_c_issue_deprecation_warning - ("`scm_uint2num' is deprecated. Use scm_from_uint instead."); - return scm_from_uint (x); -} - -SCM -scm_long2num (long x) -{ - scm_c_issue_deprecation_warning - ("`scm_long2num' is deprecated. Use scm_from_long instead."); - return scm_from_long (x); -} - -SCM -scm_ulong2num (unsigned long x) -{ - scm_c_issue_deprecation_warning - ("`scm_ulong2num' is deprecated. Use scm_from_ulong instead."); - return scm_from_ulong (x); -} - -SCM -scm_size2num (size_t x) -{ - scm_c_issue_deprecation_warning - ("`scm_size2num' is deprecated. Use scm_from_size_t instead."); - return scm_from_size_t (x); -} - -SCM -scm_ptrdiff2num (ptrdiff_t x) -{ - scm_c_issue_deprecation_warning - ("`scm_ptrdiff2num' is deprecated. Use scm_from_ssize_t instead."); - return scm_from_ssize_t (x); -} - -short -scm_num2short (SCM x, unsigned long pos, const char *s_caller) -{ - scm_c_issue_deprecation_warning - ("`scm_num2short' is deprecated. Use scm_to_short instead."); - return scm_to_short (x); -} - -unsigned short -scm_num2ushort (SCM x, unsigned long pos, const char *s_caller) -{ - scm_c_issue_deprecation_warning - ("`scm_num2ushort' is deprecated. Use scm_to_ushort instead."); - return scm_to_ushort (x); -} - -int -scm_num2int (SCM x, unsigned long pos, const char *s_caller) -{ - scm_c_issue_deprecation_warning - ("`scm_num2int' is deprecated. Use scm_to_int instead."); - return scm_to_int (x); -} - -unsigned int -scm_num2uint (SCM x, unsigned long pos, const char *s_caller) -{ - scm_c_issue_deprecation_warning - ("`scm_num2uint' is deprecated. Use scm_to_uint instead."); - return scm_to_uint (x); -} - -long -scm_num2long (SCM x, unsigned long pos, const char *s_caller) -{ - scm_c_issue_deprecation_warning - ("`scm_num2long' is deprecated. Use scm_to_long instead."); - return scm_to_long (x); -} - -unsigned long -scm_num2ulong (SCM x, unsigned long pos, const char *s_caller) -{ - scm_c_issue_deprecation_warning - ("`scm_num2ulong' is deprecated. Use scm_to_ulong instead."); - return scm_to_ulong (x); -} - -size_t -scm_num2size (SCM x, unsigned long pos, const char *s_caller) -{ - scm_c_issue_deprecation_warning - ("`scm_num2size' is deprecated. Use scm_to_size_t instead."); - return scm_to_size_t (x); -} - -ptrdiff_t -scm_num2ptrdiff (SCM x, unsigned long pos, const char *s_caller) -{ - scm_c_issue_deprecation_warning - ("`scm_num2ptrdiff' is deprecated. Use scm_to_ssize_t instead."); - return scm_to_ssize_t (x); -} - -#if SCM_SIZEOF_LONG_LONG != 0 - -SCM -scm_long_long2num (long long x) -{ - scm_c_issue_deprecation_warning - ("`scm_long_long2num' is deprecated. Use scm_from_long_long instead."); - return scm_from_long_long (x); -} - -SCM -scm_ulong_long2num (unsigned long long x) -{ - scm_c_issue_deprecation_warning - ("`scm_ulong_long2num' is deprecated. Use scm_from_ulong_long instead."); - return scm_from_ulong_long (x); -} - -long long -scm_num2long_long (SCM x, unsigned long pos, const char *s_caller) -{ - scm_c_issue_deprecation_warning - ("`scm_num2long_long' is deprecated. Use scm_to_long_long instead."); - return scm_to_long_long (x); -} - -unsigned long long -scm_num2ulong_long (SCM x, unsigned long pos, const char *s_caller) -{ - scm_c_issue_deprecation_warning - ("`scm_num2ulong_long' is deprecated. Use scm_from_ulong_long instead."); - return scm_to_ulong_long (x); -} - -#endif - -SCM -scm_make_real (double x) -{ - scm_c_issue_deprecation_warning - ("`scm_make_real' is deprecated. Use scm_from_double instead."); - return scm_from_double (x); -} - -double -scm_num2dbl (SCM a, const char *why) -{ - scm_c_issue_deprecation_warning - ("`scm_num2dbl' is deprecated. Use scm_to_double instead."); - return scm_to_double (a); -} - -SCM -scm_float2num (float n) -{ - scm_c_issue_deprecation_warning - ("`scm_float2num' is deprecated. Use scm_from_double instead."); - return scm_from_double ((double) n); -} - -SCM -scm_double2num (double n) -{ - scm_c_issue_deprecation_warning - ("`scm_double2num' is deprecated. Use scm_from_double instead."); - return scm_from_double (n); -} - -SCM -scm_make_complex (double x, double y) -{ - scm_c_issue_deprecation_warning - ("`scm_make_complex' is deprecated. Use scm_c_make_rectangular instead."); - return scm_c_make_rectangular (x, y); -} - -SCM -scm_mem2symbol (const char *mem, size_t len) -{ - scm_c_issue_deprecation_warning - ("`scm_mem2symbol' is deprecated. Use scm_from_locale_symboln instead."); - return scm_from_locale_symboln (mem, len); -} - -SCM -scm_mem2uninterned_symbol (const char *mem, size_t len) -{ - scm_c_issue_deprecation_warning - ("`scm_mem2uninterned_symbol' is deprecated. " - "Use scm_make_symbol and scm_from_locale_symboln instead."); - return scm_make_symbol (scm_from_locale_stringn (mem, len)); -} - -SCM -scm_str2symbol (const char *str) -{ - scm_c_issue_deprecation_warning - ("`scm_str2symbol' is deprecated. Use scm_from_locale_symbol instead."); - return scm_from_locale_symbol (str); -} - - -/* This function must only be applied to memory obtained via malloc, - since the GC is going to apply `free' to it when the string is - dropped. - - Also, s[len] must be `\0', since we promise that strings are - null-terminated. Perhaps we could handle non-null-terminated - strings by claiming they're shared substrings of a string we just - made up. */ -SCM -scm_take_str (char *s, size_t len) -{ - scm_c_issue_deprecation_warning - ("`scm_take_str' is deprecated. Use scm_take_locale_stringn instead."); - return scm_take_locale_stringn (s, len); -} - -/* `s' must be a malloc'd string. See scm_take_str. */ -SCM -scm_take0str (char *s) -{ - scm_c_issue_deprecation_warning - ("`scm_take0str' is deprecated. Use scm_take_locale_string instead."); - return scm_take_locale_string (s); -} - -SCM -scm_mem2string (const char *src, size_t len) -{ - scm_c_issue_deprecation_warning - ("`scm_mem2string' is deprecated. Use scm_from_locale_stringn instead."); - return scm_from_locale_stringn (src, len); -} - -SCM -scm_str2string (const char *src) -{ - scm_c_issue_deprecation_warning - ("`scm_str2string' is deprecated. Use scm_from_locale_string instead."); - return scm_from_locale_string (src); -} - -SCM -scm_makfrom0str (const char *src) -{ - scm_c_issue_deprecation_warning - ("`scm_makfrom0str' is deprecated." - "Use scm_from_locale_string instead, but check for NULL first."); - if (!src) return SCM_BOOL_F; - return scm_from_locale_string (src); -} - -SCM -scm_makfrom0str_opt (const char *src) -{ - scm_c_issue_deprecation_warning - ("`scm_makfrom0str_opt' is deprecated." - "Use scm_from_locale_string instead, but check for NULL first."); - return scm_makfrom0str (src); -} - - -SCM -scm_allocate_string (size_t len) -{ - scm_c_issue_deprecation_warning - ("`scm_allocate_string' is deprecated. Use scm_c_make_string instead."); - return scm_i_make_string (len, NULL, 0); -} - -SCM_DEFINE (scm_make_keyword_from_dash_symbol, "make-keyword-from-dash-symbol", 1, 0, 0, - (SCM symbol), - "Make a keyword object from a @var{symbol} that starts with a dash.") -#define FUNC_NAME s_scm_make_keyword_from_dash_symbol -{ - SCM dash_string, non_dash_symbol; - - scm_c_issue_deprecation_warning - ("`scm_make_keyword_from_dash_symbol' is deprecated. Don't use dash symbols."); - - SCM_ASSERT (scm_is_symbol (symbol) - && (scm_i_symbol_ref (symbol, 0) == '-'), - symbol, SCM_ARG1, FUNC_NAME); - - dash_string = scm_symbol_to_string (symbol); - non_dash_symbol = - scm_string_to_symbol (scm_c_substring (dash_string, - 1, - scm_c_string_length (dash_string))); - - return scm_symbol_to_keyword (non_dash_symbol); -} -#undef FUNC_NAME - -SCM_DEFINE (scm_keyword_dash_symbol, "keyword-dash-symbol", 1, 0, 0, - (SCM keyword), - "Return the dash symbol for @var{keyword}.\n" - "This is the inverse of @code{make-keyword-from-dash-symbol}.") -#define FUNC_NAME s_scm_keyword_dash_symbol -{ - SCM symbol = scm_keyword_to_symbol (keyword); - SCM parts = scm_list_2 (scm_from_locale_string ("-"), - scm_symbol_to_string (symbol)); - scm_c_issue_deprecation_warning - ("`scm_keyword_dash_symbol' is deprecated. Don't use dash symbols."); - - return scm_string_to_symbol (scm_string_append (parts)); -} -#undef FUNC_NAME - -SCM -scm_c_make_keyword (const char *s) -{ - scm_c_issue_deprecation_warning - ("`scm_c_make_keyword' is deprecated. Use scm_from_locale_keyword instead."); - return scm_from_locale_keyword (s); -} - -unsigned int -scm_thread_sleep (unsigned int t) -{ - scm_c_issue_deprecation_warning - ("`scm_thread_sleep' is deprecated. Use scm_std_sleep instead."); - return scm_std_sleep (t); -} - -unsigned long -scm_thread_usleep (unsigned long t) -{ - scm_c_issue_deprecation_warning - ("`scm_thread_usleep' is deprecated. Use scm_std_usleep instead."); - return scm_std_usleep (t); -} - -int scm_internal_select (int fds, - SELECT_TYPE *rfds, - SELECT_TYPE *wfds, - SELECT_TYPE *efds, - struct timeval *timeout) -{ - scm_c_issue_deprecation_warning - ("`scm_internal_select' is deprecated. Use scm_std_select instead."); - return scm_std_select (fds, rfds, wfds, efds, timeout); -} - - - -#ifdef HAVE_CUSERID - -# if !HAVE_DECL_CUSERID -extern char *cuserid (char *); -# endif - -SCM_DEFINE (scm_cuserid, "cuserid", 0, 0, 0, - (void), - "Return a string containing a user name associated with the\n" - "effective user id of the process. Return @code{#f} if this\n" - "information cannot be obtained.") -#define FUNC_NAME s_scm_cuserid -{ - char buf[L_cuserid]; - char * p; - - scm_c_issue_deprecation_warning - ("`cuserid' is deprecated. Use `(passwd:name (getpwuid (geteuid)))' instead."); - - p = cuserid (buf); - if (!p || !*p) - return SCM_BOOL_F; - return scm_from_locale_string (p); -} -#undef FUNC_NAME -#endif /* HAVE_CUSERID */ - - - -/* {Properties} - */ - -static SCM properties_whash; - -SCM_DEFINE (scm_primitive_make_property, "primitive-make-property", 1, 0, 0, - (SCM not_found_proc), - "Create a @dfn{property token} that can be used with\n" - "@code{primitive-property-ref} and @code{primitive-property-set!}.\n" - "See @code{primitive-property-ref} for the significance of\n" - "@var{not_found_proc}.") -#define FUNC_NAME s_scm_primitive_make_property -{ - scm_c_issue_deprecation_warning - ("`primitive-make-property' is deprecated. Use object properties."); - - if (!scm_is_false (not_found_proc)) - SCM_VALIDATE_PROC (SCM_ARG1, not_found_proc); - return scm_cons (not_found_proc, SCM_EOL); -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_primitive_property_ref, "primitive-property-ref", 2, 0, 0, - (SCM prop, SCM obj), - "Return the property @var{prop} of @var{obj}.\n" - "\n" - "When no value has yet been associated with @var{prop} and\n" - "@var{obj}, the @var{not-found-proc} from @var{prop} is used. A\n" - "call @code{(@var{not-found-proc} @var{prop} @var{obj})} is made\n" - "and the result set as the property value. If\n" - "@var{not-found-proc} is @code{#f} then @code{#f} is the\n" - "property value.") -#define FUNC_NAME s_scm_primitive_property_ref -{ - SCM alist; - - scm_c_issue_deprecation_warning - ("`primitive-property-ref' is deprecated. Use object properties."); - - SCM_VALIDATE_CONS (SCM_ARG1, prop); - - alist = scm_hashq_ref (properties_whash, obj, SCM_EOL); - if (scm_is_pair (alist)) - { - SCM assoc = scm_assq (prop, alist); - if (scm_is_true (assoc)) - return SCM_CDR (assoc); - } - - if (scm_is_false (SCM_CAR (prop))) - return SCM_BOOL_F; - else - { - SCM val = scm_call_2 (SCM_CAR (prop), prop, obj); - scm_hashq_set_x (properties_whash, obj, - scm_acons (prop, val, alist)); - return val; - } -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_primitive_property_set_x, "primitive-property-set!", 3, 0, 0, - (SCM prop, SCM obj, SCM val), - "Set the property @var{prop} of @var{obj} to @var{val}.") -#define FUNC_NAME s_scm_primitive_property_set_x -{ - SCM alist, assoc; - - scm_c_issue_deprecation_warning - ("`primitive-property-set!' is deprecated. Use object properties."); - - SCM_VALIDATE_CONS (SCM_ARG1, prop); - alist = scm_hashq_ref (properties_whash, obj, SCM_EOL); - assoc = scm_assq (prop, alist); - if (scm_is_pair (assoc)) - SCM_SETCDR (assoc, val); - else - scm_hashq_set_x (properties_whash, obj, - scm_acons (prop, val, alist)); - return SCM_UNSPECIFIED; -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_primitive_property_del_x, "primitive-property-del!", 2, 0, 0, - (SCM prop, SCM obj), - "Remove any value associated with @var{prop} and @var{obj}.") -#define FUNC_NAME s_scm_primitive_property_del_x -{ - SCM alist; - - scm_c_issue_deprecation_warning - ("`primitive-property-del!' is deprecated. Use object properties."); - - SCM_VALIDATE_CONS (SCM_ARG1, prop); - alist = scm_hashq_ref (properties_whash, obj, SCM_EOL); - if (scm_is_pair (alist)) - scm_hashq_set_x (properties_whash, obj, scm_assq_remove_x (alist, prop)); - return SCM_UNSPECIFIED; -} -#undef FUNC_NAME - - - -SCM -scm_whash_get_handle (SCM whash, SCM key) -{ - scm_c_issue_deprecation_warning - ("The `scm_whash' API is deprecated. Use the `scm_hashq' API instead."); - - return scm_hashq_get_handle (whash, key); -} - -int -SCM_WHASHFOUNDP (SCM h) -{ - scm_c_issue_deprecation_warning - ("The `scm_whash' API is deprecated. Use the `scm_hashq' API instead."); - - return scm_is_true (h); -} - -SCM -SCM_WHASHREF (SCM whash, SCM handle) -{ - scm_c_issue_deprecation_warning - ("The `scm_whash' API is deprecated. Use the `scm_hashq' API instead."); - - return SCM_CDR (handle); -} - -void -SCM_WHASHSET (SCM whash, SCM handle, SCM obj) -{ - scm_c_issue_deprecation_warning - ("The `scm_whash' API is deprecated. Use the `scm_hashq' API instead."); - - SCM_SETCDR (handle, obj); -} - -SCM -scm_whash_create_handle (SCM whash, SCM key) -{ - scm_c_issue_deprecation_warning - ("The `scm_whash' API is deprecated. Use the `scm_hashq' API instead."); - - return scm_hashq_create_handle_x (whash, key, SCM_UNSPECIFIED); -} - -SCM -scm_whash_lookup (SCM whash, SCM obj) -{ - scm_c_issue_deprecation_warning - ("The `scm_whash' API is deprecated. Use the `scm_hashq' API instead."); - - return scm_hashq_ref (whash, obj, SCM_BOOL_F); -} - -void -scm_whash_insert (SCM whash, SCM key, SCM obj) -{ - scm_c_issue_deprecation_warning - ("The `scm_whash' API is deprecated. Use the `scm_hashq' API instead."); - - scm_hashq_set_x (whash, key, obj); -} - - - -SCM scm_struct_table = SCM_BOOL_F; - -SCM -scm_struct_create_handle (SCM obj) -{ - scm_c_issue_deprecation_warning - ("`scm_struct_create_handle' is deprecated, and has no effect."); - - return scm_cons (obj, scm_cons (SCM_BOOL_F, SCM_BOOL_F)); -} - SCM @@ -2624,221 +75,10 @@ scm_immutable_double_cell (scm_t_bits car, scm_t_bits cbr, return scm_double_cell (car, cbr, ccr, cdr); } - - - -scm_t_bits -scm_i_deprecated_asrtgo (scm_t_bits condition) -{ - scm_c_issue_deprecation_warning - ("SCM_ASRTGO is deprecated. Use `if (!condition) goto label;' directly."); - - return condition; -} - -/* scm_sym2var - * - * looks up the variable bound to SYM according to PROC. PROC should be - * a `eval closure' of some module. - * - * When no binding exists, and DEFINEP is true, create a new binding - * with a initial value of SCM_UNDEFINED. Return `#f' when DEFINEP as - * false and no binding exists. - * - * When PROC is `#f', it is ignored and the binding is searched for in - * the scm_pre_modules_obarray (a `eq' hash table). - */ - -SCM -scm_sym2var (SCM sym, SCM proc, SCM definep) -#define FUNC_NAME "scm_sym2var" -{ - SCM var; - - if (scm_is_true (definep)) - scm_c_issue_deprecation_warning - ("scm_sym2var is deprecated. Use scm_define or scm_module_define\n" - "to define variables. In some rare cases you may need\n" - "scm_module_ensure_local_variable."); - else - scm_c_issue_deprecation_warning - ("scm_sym2var is deprecated. Use scm_module_variable to look up\n" - "variables."); - - if (SCM_NIMP (proc)) - { - if (SCM_EVAL_CLOSURE_P (proc)) - { - /* Bypass evaluator in the standard case. */ - var = scm_eval_closure_lookup (proc, sym, definep); - } - else - var = scm_call_2 (proc, sym, definep); - } - else - { - if (scm_is_false (definep)) - var = scm_module_variable (scm_the_root_module (), sym); - else - var = scm_module_ensure_local_variable (scm_the_root_module (), sym); - } - - if (scm_is_true (var) && !SCM_VARIABLEP (var)) - SCM_MISC_ERROR ("~S is not bound to a variable", scm_list_1 (sym)); - - return var; -} -#undef FUNC_NAME - -SCM -scm_lookup_closure_module (SCM proc) -{ - scm_c_issue_deprecation_warning - ("Eval closures are deprecated. See \"Accessing Modules From C\" in\n" - "the manual, for replacements."); - - if (scm_is_false (proc)) - return scm_the_root_module (); - else if (SCM_EVAL_CLOSURE_P (proc)) - return SCM_PACK (SCM_SMOB_DATA (proc)); - else - /* FIXME: The `module' property is no longer set on eval closures, as it - introduced a circular reference that precludes garbage collection of - modules with the current weak hash table semantics (see - http://lists.gnu.org/archive/html/guile-devel/2009-01/msg00102.html and - http://thread.gmane.org/gmane.comp.programming.garbage-collection.boehmgc/2465 - for details). Since it doesn't appear to be used (only in this - function, which has 1 caller), we no longer extend - `set-module-eval-closure!' to set the `module' property. */ - abort (); -} - -SCM -scm_module_lookup_closure (SCM module) -{ - scm_c_issue_deprecation_warning - ("Eval closures are deprecated. See \"Accessing Modules From C\" in\n" - "the manual, for replacements."); - - if (scm_is_false (module)) - return SCM_BOOL_F; - else - return SCM_MODULE_EVAL_CLOSURE (module); -} - -SCM -scm_current_module_lookup_closure () -{ - scm_c_issue_deprecation_warning - ("Eval closures are deprecated. See \"Accessing Modules From C\" in\n" - "the manual, for replacements."); - - if (scm_module_system_booted_p) - return scm_module_lookup_closure (scm_current_module ()); - else - return SCM_BOOL_F; -} - -scm_t_bits scm_tc16_eval_closure; - -#define SCM_F_EVAL_CLOSURE_INTERFACE (1<<0) -#define SCM_EVAL_CLOSURE_INTERFACE_P(e) \ - (SCM_SMOB_FLAGS (e) & SCM_F_EVAL_CLOSURE_INTERFACE) - -/* NOTE: This function may be called by a smob application - or from another C function directly. */ -SCM -scm_eval_closure_lookup (SCM eclo, SCM sym, SCM definep) -{ - SCM module = SCM_PACK (SCM_SMOB_DATA (eclo)); - - scm_c_issue_deprecation_warning - ("Eval closures are deprecated. See \"Accessing Modules From C\" in\n" - "the manual, for replacements."); - - if (scm_is_true (definep)) - { - if (SCM_EVAL_CLOSURE_INTERFACE_P (eclo)) - return SCM_BOOL_F; - return scm_module_ensure_local_variable (module, sym); - } - else - return scm_module_variable (module, sym); -} - -SCM_DEFINE (scm_standard_eval_closure, "standard-eval-closure", 1, 0, 0, - (SCM module), - "Return an eval closure for the module @var{module}.") -#define FUNC_NAME s_scm_standard_eval_closure -{ - scm_c_issue_deprecation_warning - ("Eval closures are deprecated. See \"Accessing Modules From C\" in\n" - "the manual, for replacements."); - - SCM_RETURN_NEWSMOB (scm_tc16_eval_closure, SCM_UNPACK (module)); -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_standard_interface_eval_closure, - "standard-interface-eval-closure", 1, 0, 0, - (SCM module), - "Return a interface eval closure for the module @var{module}. " - "Such a closure does not allow new bindings to be added.") -#define FUNC_NAME s_scm_standard_interface_eval_closure -{ - scm_c_issue_deprecation_warning - ("Eval closures are deprecated. See \"Accessing Modules From C\" in\n" - "the manual, for replacements."); - - SCM_RETURN_NEWSMOB (scm_tc16_eval_closure | (SCM_F_EVAL_CLOSURE_INTERFACE<<16), - SCM_UNPACK (module)); -} -#undef FUNC_NAME - -SCM_DEFINE (scm_eval_closure_module, - "eval-closure-module", 1, 0, 0, - (SCM eval_closure), - "Return the module associated with this eval closure.") -/* the idea is that eval closures are really not the way to do things, they're - superfluous given our module system. this function lets mmacros migrate away - from eval closures. */ -#define FUNC_NAME s_scm_eval_closure_module -{ - scm_c_issue_deprecation_warning - ("Eval closures are deprecated. See \"Accessing Modules From C\" in\n" - "the manual, for replacements."); - - SCM_MAKE_VALIDATE_MSG (SCM_ARG1, eval_closure, EVAL_CLOSURE_P, - "eval-closure"); - return SCM_SMOB_OBJECT (eval_closure); -} -#undef FUNC_NAME - - - - -SCM_DEFINE (scm_struct_vtable_tag, "struct-vtable-tag", 1, 0, 0, - (SCM handle), - "Return the vtable tag of the structure @var{handle}.") -#define FUNC_NAME s_scm_struct_vtable_tag -{ - SCM_VALIDATE_VTABLE (1, handle); - scm_c_issue_deprecation_warning - ("struct-vtable-tag is deprecated. What were you doing with it anyway?"); - - return scm_from_unsigned_integer - (((scm_t_bits)SCM_STRUCT_DATA (handle)) >> 3); -} -#undef FUNC_NAME - - - - SCM_DEFINE (scm_generalized_vector_p, "generalized-vector?", 1, 0, 0, (SCM obj), "Return @code{#t} if @var{obj} is a vector, string,\n" @@ -2924,11 +164,6 @@ SCM_DEFINE (scm_generalized_vector_to_list, "generalized-vector->list", 1, 0, 0, void scm_i_init_deprecated () { - properties_whash = scm_make_weak_key_hash_table (SCM_UNDEFINED); - scm_struct_table = scm_make_hash_table (SCM_UNDEFINED); - scm_tc16_eval_closure = scm_make_smob_type ("eval-closure", 0); - scm_set_smob_apply (scm_tc16_eval_closure, scm_eval_closure_lookup, 2, 0, 0); - #include "libguile/deprecated.x" } diff --git a/libguile/deprecated.h b/libguile/deprecated.h index 1812dd063..d02fc7976 100644 --- a/libguile/deprecated.h +++ b/libguile/deprecated.h @@ -31,119 +31,6 @@ #if (SCM_ENABLE_DEPRECATED == 1) -/* From eval.h: Macros for handling ilocs. These were deprecated in guile - * 1.7.0 on 2004-04-22. */ -#define SCM_IFRINC (0x00000100L) -#define SCM_ICDR (0x00080000L) -#define SCM_IFRAME(n) ((long)((SCM_ICDR-SCM_IFRINC)>>8) \ - & (SCM_UNPACK (n) >> 8)) -#define SCM_IDIST(n) (SCM_UNPACK (n) >> 20) -#define SCM_ICDRP(n) (SCM_ICDR & SCM_UNPACK (n)) - - -/* From tags.h: Macros to access internal symbol names of isyms. Deprecated - * in guile 1.7.0 on 2004-04-22. */ -SCM_API char *scm_isymnames[]; -#define SCM_ISYMNUM(n) 0 -#define SCM_ISYMCHARS(n) "#@<deprecated>" - - -/* From tags.h: Macro checking for two tc16 types that are allocated to differ - * only in the 's'-bit. Deprecated in guile 1.7.0 on 2003-09-21. */ -#define SCM_TYP16S(x) (0xfeff & SCM_CELL_TYPE (x)) - - -/* From numbers.h: Macros checking for types, but avoiding a redundant check - * for !SCM_IMP. These were deprecated in guile 1.7.0 on 2003-09-06. */ -#define SCM_SLOPPY_INEXACTP(x) (SCM_TYP16S (x) == scm_tc16_real) -#define SCM_SLOPPY_REALP(x) (SCM_TYP16 (x) == scm_tc16_real) -#define SCM_SLOPPY_COMPLEXP(x) (SCM_TYP16 (x) == scm_tc16_complex) - - -/* From structs.h: - Deprecated in Guile 1.9.5 on 2009-11-03. */ -#define scm_vtable_index_vtable scm_vtable_index_self -#define scm_vtable_index_printer scm_vtable_index_instance_printer -#define scm_struct_i_free scm_vtable_index_instance_finalize -#define scm_struct_i_flags scm_vtable_index_flags -#define SCM_STRUCTF_MASK ((scm_t_bits)-1) -#define SCM_SET_VTABLE_DESTRUCTOR(X, D) (SCM_STRUCT_DATA(x)[scm_struct_i_free]=(scm_t_bits)(D)) - -#define scm_substring_move_left_x scm_substring_move_x -#define scm_substring_move_right_x scm_substring_move_x - -#define scm_sizet size_t - -SCM_DEPRECATED SCM scm_wta (SCM arg, const char *pos, const char *s_subr); - -#define SCM_WNA 8 -#define SCM_OUTOFRANGE 10 -#define SCM_NALLOC 11 - -SCM_DEPRECATED void scm_register_module_xxx (char *module_name, void *init_func); -SCM_DEPRECATED SCM scm_registered_modules (void); -SCM_DEPRECATED SCM scm_clear_registered_modules (void); - -SCM_DEPRECATED SCM scm_protect_object (SCM obj); -SCM_DEPRECATED SCM scm_unprotect_object (SCM obj); - -#define SCM_SETAND_CAR(x, y) \ - (SCM_SETCAR ((x), SCM_PACK (SCM_UNPACK (SCM_CAR (x)) & (y)))) -#define SCM_SETOR_CAR(x, y)\ - (SCM_SETCAR ((x), SCM_PACK (SCM_UNPACK (SCM_CAR (x)) | (y)))) -#define SCM_SETAND_CDR(x, y)\ - (SCM_SETCDR ((x), SCM_PACK (SCM_UNPACK (SCM_CDR (x)) & (y)))) -#define SCM_SETOR_CDR(x, y)\ - (SCM_SETCDR ((x), SCM_PACK (SCM_UNPACK (SCM_CDR (x)) | (y)))) -#define SCM_FREEP(x) (0) -#define SCM_NFREEP(x) (1) -#define SCM_GCTYP16(x) SCM_TYP16 (x) -#define SCM_GCCDR(x) SCM_CDR (x) -SCM_DEPRECATED void scm_remember (SCM * ptr); - -SCM_DEPRECATED SCM scm_make_module (SCM name); -SCM_DEPRECATED SCM scm_ensure_user_module (SCM name); -SCM_DEPRECATED SCM scm_load_scheme_module (SCM name); - -#define scm_port scm_t_port -#define scm_ptob_descriptor scm_t_ptob_descriptor -#define scm_port_rw_active scm_t_port_rw_active - -SCM_DEPRECATED SCM scm_close_all_ports_except (SCM ports); - -#define scm_rstate scm_t_rstate -#define scm_rng scm_t_rng - -#define SCM_SLOPPY_CONSP(x) ((1 & SCM_CELL_TYPE (x)) == 0) -#define SCM_SLOPPY_NCONSP(x) (!SCM_SLOPPY_CONSP(x)) - -#define scm_tc7_ssymbol scm_tc7_symbol -#define scm_tc7_msymbol scm_tc7_symbol -#define scm_tcs_symbols scm_tc7_symbol - -SCM_DEPRECATED SCM scm_makstr (size_t len, int); -SCM_DEPRECATED SCM scm_makfromstr (const char *src, size_t len, int); - -SCM_DEPRECATED SCM scm_variable_set_name_hint (SCM var, SCM hint); -SCM_DEPRECATED SCM scm_builtin_variable (SCM name); - -SCM_DEPRECATED SCM scm_internal_with_fluids (SCM fluids, SCM vals, - SCM (*cproc)(void *), - void *cdata); - -SCM_DEPRECATED SCM scm_make_gsubr (const char *name, - int req, int opt, int rst, - scm_t_subr fcn); -SCM_DEPRECATED SCM scm_make_gsubr_with_generic (const char *name, - int req, - int opt, - int rst, - scm_t_subr fcn, - SCM *gf); - -SCM_DEPRECATED SCM scm_create_hook (const char* name, int n_args); - - /* Deprecated 13-05-2011 because it's better just to scm_dynwind_begin. That also avoids the temptation to stuff pointers in an SCM. */ @@ -154,6 +41,39 @@ SCM_DEPRECATED SCM scm_internal_dynamic_wind (scm_t_guard before, void *inner_data, void *guard_data); + +/* Deprecated 15-05-2011 because it's better to be explicit with the + `return'. Code is more readable that way. */ +#define SCM_WTA_DISPATCH_0(gf, subr) \ + return scm_wta_dispatch_0 ((gf), (subr)) +#define SCM_WTA_DISPATCH_1(gf, a1, pos, subr) \ + return scm_wta_dispatch_1 ((gf), (a1), (pos), (subr)) +#define SCM_WTA_DISPATCH_2(gf, a1, a2, pos, subr) \ + return scm_wta_dispatch_2 ((gf), (a1), (a2), (pos), (subr)) +#define SCM_WTA_DISPATCH_N(gf, args, pos, subr) \ + return scm_wta_dispatch_n ((gf), (args), (pos), (subr)) + +/* Deprecated 15-05-2011 because this idiom is not very readable. */ +#define SCM_GASSERT0(cond, gf, subr) \ + if (SCM_UNLIKELY (!(cond))) \ + return scm_wta_dispatch_0 ((gf), (subr)) +#define SCM_GASSERT1(cond, gf, a1, pos, subr) \ + if (SCM_UNLIKELY (!(cond))) \ + return scm_wta_dispatch_1 ((gf), (a1), (pos), (subr)) +#define SCM_GASSERT2(cond, gf, a1, a2, pos, subr) \ + if (SCM_UNLIKELY (!(cond))) \ + return scm_wta_dispatch_2 ((gf), (a1), (a2), (pos), (subr)) +#define SCM_GASSERTn(cond, gf, args, pos, subr) \ + if (SCM_UNLIKELY (!(cond))) \ + return scm_wta_dispatch_n ((gf), (args), (pos), (subr)) + +/* Deprecated 15-05-2011 because this is a one-off macro that does + strange things. */ +#define SCM_WTA_DISPATCH_1_SUBR(subr, a1, pos) \ + return (SCM_UNPACK ((*SCM_SUBR_GENERIC (subr))) \ + ? scm_call_1 ((*SCM_SUBR_GENERIC (subr)), (a1)) \ + : (scm_i_wrong_type_arg_symbol (SCM_SUBR_NAME (subr), (pos), (a1)), SCM_UNSPECIFIED)) + #define SCM_LIST0 SCM_EOL #define SCM_LIST1(e0) scm_cons ((e0), SCM_EOL) #define SCM_LIST2(e0, e1) scm_cons2 ((e0), (e1), SCM_EOL) @@ -172,689 +92,60 @@ SCM_DEPRECATED SCM scm_internal_dynamic_wind (scm_t_guard before, scm_cons ((e0),\ SCM_LIST8 ((e1), (e2), (e3), (e4), (e5), (e6), (e7), (e8))) -#define scm_listify scm_list_n - -SCM_DEPRECATED SCM scm_sloppy_memq (SCM x, SCM lst); -SCM_DEPRECATED SCM scm_sloppy_memv (SCM x, SCM lst); -SCM_DEPRECATED SCM scm_sloppy_member (SCM x, SCM lst); - -SCM_DEPRECATED SCM scm_read_and_eval_x (SCM port); - -#define scm_subr_entry scm_t_subr_entry - -#define SCM_SUBR_DOC(x) SCM_BOOL_F - -SCM_DEPRECATED SCM scm_call_catching_errors (scm_t_subr thunk, - scm_t_subr err_filter, - void * closure); - -SCM_DEPRECATED long scm_make_smob_type_mfpe (char *name, size_t size, - SCM (*mark) (SCM), - size_t (*free) (SCM), - int (*print) (SCM, SCM, - scm_print_state*), - SCM (*equalp) (SCM, SCM)); - -SCM_DEPRECATED void scm_set_smob_mfpe (long tc, - SCM (*mark) (SCM), - size_t (*free) (SCM), - int (*print) (SCM, SCM, scm_print_state*), - SCM (*equalp) (SCM, SCM)); - -SCM_DEPRECATED size_t scm_smob_free (SCM obj); - -SCM_DEPRECATED SCM scm_strprint_obj (SCM obj); -SCM_DEPRECATED SCM scm_read_0str (char *expr); -SCM_DEPRECATED SCM scm_eval_0str (const char *expr); - -SCM_DEPRECATED char *scm_i_object_chars (SCM); - -#define SCM_CHARS(x) scm_i_object_chars(x) -#define SCM_UCHARS(x) ((unsigned char *)SCM_CHARS(x)) - -SCM_DEPRECATED long scm_i_object_length (SCM); - -#define SCM_LENGTH(x) scm_i_object_length(x) - -#define scm_strhash(str, len, n) (scm_string_hash ((str), (len)) % (n)) - -SCM_DEPRECATED SCM scm_sym2ovcell_soft (SCM sym, SCM obarray); -SCM_DEPRECATED SCM scm_sym2ovcell (SCM sym, SCM obarray); -SCM_DEPRECATED SCM scm_intern_obarray_soft (const char *name, size_t len, - SCM obarray, unsigned int softness); -SCM_DEPRECATED SCM scm_intern_obarray (const char *name, size_t len, SCM obarray); -SCM_DEPRECATED SCM scm_symbol_value0 (const char *name); - -SCM_DEPRECATED SCM scm_string_to_obarray_symbol (SCM o, SCM s, SCM softp); -SCM_DEPRECATED SCM scm_intern_symbol (SCM o, SCM s); -SCM_DEPRECATED SCM scm_unintern_symbol (SCM o, SCM s); -SCM_DEPRECATED SCM scm_symbol_binding (SCM o, SCM s); -#if 0 -/* This name has been reused for real uninterned symbols. */ -SCM_DEPRECATED SCM scm_symbol_interned_p (SCM o, SCM s); -#endif -SCM_DEPRECATED SCM scm_symbol_bound_p (SCM o, SCM s); -SCM_DEPRECATED SCM scm_symbol_set_x (SCM o, SCM s, SCM v); - -SCM_DEPRECATED SCM scm_gentemp (SCM prefix, SCM obarray); - -#define SCM_OPDIRP(x) (SCM_DIRP (x) && (SCM_DIR_OPEN_P (x))) -#define scm_fport scm_t_fport -#define scm_option scm_t_option -#define scm_srcprops scm_t_srcprops -#define scm_srcprops_chunk scm_t_srcprops_chunk -#define scm_array scm_t_array -#define scm_array_dim scm_t_array_dim -#define SCM_FUNC_NAME (scm_makfrom0str (FUNC_NAME)) - -#define SCM_WTA(pos, scm) \ - do { scm_wta (scm, (char *) pos, FUNC_NAME); } while (0) - -#define RETURN_SCM_WTA(pos, scm) \ - do { return scm_wta (scm, (char *) pos, FUNC_NAME); } while (0) - -#define SCM_VALIDATE_NUMBER_COPY(pos, z, cvar) \ - do { \ - if (SCM_I_INUMP (z)) \ - cvar = (double) SCM_I_INUM (z); \ - else if (SCM_REALP (z)) \ - cvar = SCM_REAL_VALUE (z); \ - else if (SCM_BIGP (z)) \ - cvar = scm_i_big2dbl (z); \ - else \ - { \ - cvar = 0.0; \ - SCM_WRONG_TYPE_ARG (pos, z); \ - } \ - } while (0) - -#define SCM_VALIDATE_NUMBER_DEF_COPY(pos, number, def, cvar) \ - do { \ - if (SCM_UNBNDP (number)) \ - cvar = def; \ - else \ - SCM_VALIDATE_NUMBER_COPY(pos, number, cvar); \ - } while (0) - -#define SCM_VALIDATE_OPDIR(pos, port) SCM_MAKE_VALIDATE (pos, port, OPDIRP) - -/* Deprecated because we can not safely cast a SCM* to a scm_t_bits* - */ - -#define SCM_CELL_WORD_LOC(x, n) ((scm_t_bits*)SCM_CELL_OBJECT_LOC((x),(n))) - -/* Users shouldn't know about INUMs. - */ - -SCM_DEPRECATED SCM scm_i_makinum (scm_t_signed_bits val); -SCM_DEPRECATED int scm_i_inump (SCM obj); -SCM_DEPRECATED scm_t_signed_bits scm_i_inum (SCM obj); - -#define SCM_MAKINUM(x) scm_i_makinum(x) -#define SCM_INUM(x) scm_i_inum(x) -#define SCM_INUMP(x) scm_i_inump(x) -#define SCM_NINUMP(x) (!SCM_INUMP(x)) - -#define SCM_VALIDATE_INUM(pos, k) SCM_MAKE_VALIDATE_MSG (pos, k, INUMP, "exact integer") - -#define SCM_VALIDATE_INUM_COPY(pos, k, cvar) \ - do { \ - SCM_ASSERT (SCM_I_INUMP (k), k, pos, FUNC_NAME); \ - cvar = SCM_I_INUM (k); \ - } while (0) - -#define SCM_VALIDATE_BIGINT(pos, k) SCM_MAKE_VALIDATE_MSG (pos, k, BIGP, "bignum") - -#define SCM_VALIDATE_INUM_MIN(pos, k, min) \ - do { \ - SCM_ASSERT (SCM_I_INUMP(k), k, pos, FUNC_NAME); \ - SCM_ASSERT_RANGE (pos, k, (SCM_I_INUM (k) >= min)); \ - } while (0) - -#define SCM_VALIDATE_INUM_MIN_COPY(pos, k, min, cvar) \ - do { \ - SCM_ASSERT (SCM_I_INUMP (k), k, pos, FUNC_NAME); \ - SCM_ASSERT_RANGE (pos, k, (SCM_I_INUM (k) >= min)); \ - cvar = SCM_INUM (k); \ - } while (0) - -#define SCM_VALIDATE_INUM_MIN_DEF_COPY(pos, k, min, default, cvar) \ - do { \ - if (SCM_UNBNDP (k)) \ - k = SCM_I_MAKINUM (default); \ - SCM_ASSERT (SCM_I_INUMP (k), k, pos, FUNC_NAME); \ - SCM_ASSERT_RANGE (pos, k, (SCM_I_INUM (k) >= min)); \ - cvar = SCM_INUM (k); \ - } while (0) - -#define SCM_VALIDATE_INUM_DEF(pos, k, default) \ - do { \ - if (SCM_UNBNDP (k)) \ - k = SCM_I_MAKINUM (default); \ - else SCM_ASSERT (SCM_I_INUMP (k), k, pos, FUNC_NAME); \ - } while (0) - -#define SCM_VALIDATE_INUM_DEF_COPY(pos, k, default, cvar) \ - do { \ - if (SCM_UNBNDP (k)) \ - { \ - k = SCM_I_MAKINUM (default); \ - cvar = default; \ - } \ - else \ - { \ - SCM_ASSERT (SCM_I_INUMP (k), k, pos, FUNC_NAME); \ - cvar = SCM_INUM (k); \ - } \ - } while (0) - -/* [low, high) */ -#define SCM_VALIDATE_INUM_RANGE(pos, k, low, high) \ - do { SCM_ASSERT(SCM_I_INUMP(k), k, pos, FUNC_NAME); \ - SCM_ASSERT_RANGE(pos, k, \ - (SCM_I_INUM (k) >= low && \ - SCM_I_INUM (k) < high)); \ - } while (0) - -#define SCM_VALIDATE_INUM_RANGE_COPY(pos, k, low, high, cvar) \ - do { \ - SCM_ASSERT (SCM_INUMP (k), k, pos, FUNC_NAME); \ - SCM_ASSERT_RANGE (pos, k, low <= SCM_INUM (k) && SCM_INUM (k) < high); \ - cvar = SCM_INUM (k); \ - } while (0) - -#define SCM_STRING_COERCE_0TERMINATION_X(x) (x) - -/* XXX - buggy interface, STR might not be large enough. - - Converts the given Scheme string OBJ into a C string, containing a copy - of OBJ's content with a trailing null byte. If LENP is non-NULL, set - *LENP to the string's length. - - When STR is non-NULL it receives the copy and is returned by the function, - otherwise new memory is allocated and the caller is responsible for - freeing it via free(). If out of memory, NULL is returned. - - Note that Scheme strings may contain arbitrary data, including null - characters. This means that null termination is not a reliable way to - determine the length of the returned value. However, the function always - copies the complete contents of OBJ, and sets *LENP to the length of the - scheme string (if LENP is non-null). -*/ -SCM_DEPRECATED char *scm_c_string2str (SCM obj, char *str, size_t *lenp); - -/* XXX - buggy interface, you don't know how many bytes have been copied. - - Copy LEN characters at START from the Scheme string OBJ to memory - at STR. START is an index into OBJ; zero means the beginning of - the string. STR has already been allocated by the caller. - - If START + LEN is off the end of OBJ, silently truncate the source - region to fit the string. If truncation occurs, the corresponding - area of STR is left unchanged. -*/ -SCM_DEPRECATED char *scm_c_substring2str (SCM obj, char *str, size_t start, size_t len); - -SCM_DEPRECATED char *scm_c_symbol2str (SCM obj, char *str, size_t *lenp); - -/* Deprecated because the names belong to what is now - scm_truncate_number and scm_round_number. -*/ -SCM_DEPRECATED double scm_truncate (double x); -SCM_DEPRECATED double scm_round (double x); -/* Deprecated, use scm_expt */ -SCM_DEPRECATED SCM scm_sys_expt (SCM x, SCM y); - -/* if your platform doesn't have asinh et al */ -SCM_DEPRECATED double scm_asinh (double x); -SCM_DEPRECATED double scm_acosh (double x); -SCM_DEPRECATED double scm_atanh (double x); -SCM_DEPRECATED SCM scm_sys_atan2 (SCM z1, SCM z2); - -/* Deprecated because we don't want people to access the internal - representation of strings directly. -*/ - -#define SCM_VALIDATE_STRING_COPY(pos, str, cvar) \ - do { \ - SCM_ASSERT (SCM_STRINGP (str), str, pos, FUNC_NAME); \ - cvar = SCM_STRING_CHARS(str); \ - } while (0) - -/* validate a string and optional start/end arguments which default to - 0/string-len. this is unrelated to the old shared substring - support, so please do not deprecate it :) */ -#define SCM_VALIDATE_SUBSTRING_SPEC_COPY(pos_str, str, c_str, \ - pos_start, start, c_start,\ - pos_end, end, c_end) \ - do {\ - SCM_VALIDATE_STRING_COPY (pos_str, str, c_str);\ - c_start = SCM_UNBNDP(start)? 0 : scm_to_size_t (start);\ - c_end = SCM_UNBNDP(end)? SCM_STRING_LENGTH(str) : scm_to_size_t (end);\ - SCM_ASSERT_RANGE (pos_start, start,\ - 0 <= c_start \ - && (size_t) c_start <= SCM_STRING_LENGTH (str));\ - SCM_ASSERT_RANGE (pos_end, end,\ - c_start <= c_end \ - && (size_t) c_end <= SCM_STRING_LENGTH (str));\ - } while (0) - -/* Deprecated because we don't want people to access the internals of - symbols directly. -*/ - -SCM_DEPRECATED char *scm_i_deprecated_symbol_chars (SCM sym); -SCM_DEPRECATED size_t scm_i_deprecated_symbol_length (SCM sym); - -#define SCM_SYMBOL_CHARS(x) scm_i_deprecated_symbol_chars(x) -#define SCM_SYMBOL_LENGTH(x) scm_i_deprecated_symbol_length(x) - -/* Deprecated because the macros used to evaluate the arguments more - than once and because the symbol of a keyword now has no dash. -*/ - -SCM_DEPRECATED int scm_i_keywordp (SCM obj); -SCM_DEPRECATED SCM scm_i_keywordsym (SCM keyword); - -#define SCM_KEYWORDP(x) scm_i_keywordp(x) -#define SCM_KEYWORDSYM(x) scm_i_keywordsym(x) - -/* Deprecated because we don't want to hand out unprotected pointers - to arrays, vectors, etc. */ - -#define SCM_VECTOR_MAX_LENGTH ((1L << 24) - 1) - -SCM_DEPRECATED int scm_i_vectorp (SCM x); -SCM_DEPRECATED unsigned long scm_i_vector_length (SCM x); -SCM_DEPRECATED const SCM *scm_i_velts (SCM x); -SCM_DEPRECATED SCM *scm_i_writable_velts (SCM x); -SCM_DEPRECATED SCM scm_i_vector_ref (SCM x, size_t idx); -SCM_DEPRECATED void scm_i_vector_set (SCM x, size_t idx, SCM val); -SCM_DEPRECATED SCM scm_vector_equal_p (SCM x, SCM y); - -#define SCM_VECTORP(x) scm_i_vectorp(x) -#define SCM_VECTOR_LENGTH(x) scm_i_vector_length(x) -#define SCM_VELTS(x) scm_i_velts(x) -#define SCM_WRITABLE_VELTS(x) scm_i_writable_velts(x) -#define SCM_VECTOR_REF(x,y) scm_i_vector_ref(x,y) -#define SCM_VECTOR_SET(x,y,z) scm_i_vector_set(x,y,z) - -typedef scm_i_t_array scm_t_array; - -SCM_DEPRECATED int scm_i_arrayp (SCM a); -SCM_DEPRECATED size_t scm_i_array_ndim (SCM a); -SCM_DEPRECATED int scm_i_array_contp (SCM a); -SCM_DEPRECATED scm_t_array *scm_i_array_mem (SCM a); -SCM_DEPRECATED SCM scm_i_array_v (SCM a); -SCM_DEPRECATED size_t scm_i_array_base (SCM a); -SCM_DEPRECATED scm_t_array_dim *scm_i_array_dims (SCM a); - -#define SCM_ARRAYP(a) scm_i_arrayp(a) -#define SCM_ARRAY_NDIM(a) scm_i_array_ndim(a) -#define SCM_ARRAY_CONTP(a) scm_i_array_contp(a) -#define SCM_ARRAY_MEM(a) scm_i_array_mem(a) -#define SCM_ARRAY_V(a) scm_i_array_v(a) -#define SCM_ARRAY_BASE(a) scm_i_array_base(a) -#define SCM_ARRAY_DIMS(a) scm_i_array_dims(a) - -SCM_DEPRECATED SCM scm_uniform_vector_read_x (SCM v, SCM port_or_fd, - SCM start, SCM end); -SCM_DEPRECATED SCM scm_uniform_vector_write (SCM v, SCM port_or_fd, - SCM start, SCM end); -SCM_DEPRECATED SCM scm_uniform_array_read_x (SCM ra, SCM port_or_fd, - SCM start, SCM end); -SCM_DEPRECATED SCM scm_uniform_array_write (SCM v, SCM port_or_fd, - SCM start, SCM end); - -/* Deprecated because they should not be lvalues and we want people to - use the official interfaces. - */ - -#define scm_cur_inp scm_i_cur_inp () -#define scm_cur_outp scm_i_cur_outp () -#define scm_cur_errp scm_i_cur_errp () -#define scm_cur_loadp scm_i_cur_loadp () -#define scm_progargs scm_i_progargs () -#define scm_dynwinds scm_i_deprecated_dynwinds () -#define scm_stack_base scm_i_stack_base () - -SCM_DEPRECATED SCM scm_i_cur_inp (void); -SCM_DEPRECATED SCM scm_i_cur_outp (void); -SCM_DEPRECATED SCM scm_i_cur_errp (void); -SCM_DEPRECATED SCM scm_i_cur_loadp (void); -SCM_DEPRECATED SCM scm_i_progargs (void); -SCM_DEPRECATED SCM scm_i_deprecated_dynwinds (void); -SCM_DEPRECATED SCM_STACKITEM *scm_i_stack_base (void); - -/* Deprecated because it evaluates its argument twice. - */ -#define SCM_FLUIDP(x) scm_i_fluidp (x) -SCM_DEPRECATED int scm_i_fluidp (SCM x); - -/* Deprecated in Guile 1.9.5 on 2009-11-15 because these are IPv4-only - functions which are deprecated upstream. */ - -SCM_DEPRECATED SCM scm_inet_aton (SCM address); -SCM_DEPRECATED SCM scm_inet_ntoa (SCM inetid); - -/* In the old days, SCM_CRITICAL_SECTION_START stopped signal handlers - from running, since in those days the handler directly ran scheme - code, and that had to be avoided when the heap was not in a - consistent state etc. And since the scheme code could do a stack - swapping new continuation etc, signals had to be deferred around - various C library functions which were not safe or not known to be - safe to swap away, which was a lot of stuff. - - These days signals are implemented with asyncs and don't directly - run scheme code in the handler, but hold it until an SCM_TICK etc - where it will be safe. This means interrupt protection is not - needed and SCM_CRITICAL_SECTION_START / SCM_CRITICAL_SECTION_END is - something of an anachronism. - - What past SCM_CRITICAL_SECTION_START usage also did though was - indicate code that was not reentrant, ie. could not be reentered by - signal handler code. The present definitions are a mutex lock, - affording that reentrancy protection against the new guile 1.8 - free-running posix threads. - - One big problem with the present defintions though is that code which - throws an error from within a DEFER/ALLOW region will leave the - defer_mutex locked and hence hang other threads that attempt to enter a - similar DEFER/ALLOW region. -*/ - -SCM_DEPRECATED void scm_i_defer_ints_etc (void); -#define SCM_DEFER_INTS scm_i_defer_ints_etc () -#define SCM_ALLOW_INTS scm_i_defer_ints_etc () -#define SCM_REDEFER_INTS scm_i_defer_ints_etc () -#define SCM_REALLOW_INTS scm_i_defer_ints_etc () - -/* In the old days (pre-1.8), this macro was sometimes used as an lvalue as - in "scm_mask_ints = 1" to block async execution. It no longer works. */ -#define scm_mask_ints (scm_i_mask_ints ()) - -SCM_DEPRECATED int scm_i_mask_ints (void); - -/* Deprecated since they are unnecessary and had not been documented. - */ -SCM_DEPRECATED SCM scm_guard (SCM guardian, SCM obj, int throw_p); -SCM_DEPRECATED SCM scm_get_one_zombie (SCM guardian); - -/* Deprecated since guardians no longer have these special features. - */ -SCM_DEPRECATED SCM scm_destroy_guardian_x (SCM guardian); -SCM_DEPRECATED SCM scm_guardian_greedy_p (SCM guardian); -SCM_DEPRECATED SCM scm_guardian_destroyed_p (SCM guardian); - - -/* GC-related things deprecated with the move to BDW-GC starting from 1.9.3 - (2009-09-15). */ - -SCM_DEPRECATED unsigned long scm_mallocated; -SCM_DEPRECATED unsigned long scm_mtrigger; - -SCM_DEPRECATED size_t scm_max_segment_size; - -#if defined (GUILE_DEBUG) || defined (GUILE_DEBUG_FREELIST) -SCM_DEPRECATED SCM scm_map_free_list (void); -#endif - -#if defined (GUILE_DEBUG_FREELIST) -SCM_DEPRECATED SCM scm_gc_set_debug_check_freelist_x (SCM flag); -#endif - - - -/* Deprecated 2009-11-27, scm_call_N is sufficient */ -SCM_DEPRECATED scm_t_trampoline_0 scm_trampoline_0 (SCM proc); -SCM_DEPRECATED scm_t_trampoline_1 scm_trampoline_1 (SCM proc); -SCM_DEPRECATED scm_t_trampoline_2 scm_trampoline_2 (SCM proc); - - - -/* Deprecated 2009-12-06, use the procedures instead */ -#define SCM_PROCEDURE_WITH_SETTER_P(obj) (scm_is_true (scm_procedure_with_setter_p (obj))) -#define SCM_PROCEDURE(obj) SCM_STRUCT_PROCEDURE (obj, 0) -#define SCM_SETTER(obj) SCM_STRUCT_SETTER (obj, 1) - - - -/* Deprecated 2010-01-05, use SCM_PRIMITIVE_P instead */ -SCM_DEPRECATED int scm_i_subr_p (SCM x); -#define scm_subr_p(x) (scm_i_subr_p (x)) - - - -/* Deprecated 2010-01-31, use with-throw-handler instead */ -SCM_DEPRECATED SCM scm_lazy_catch (SCM tag, SCM thunk, SCM handler); -SCM_DEPRECATED SCM scm_internal_lazy_catch (SCM tag, - scm_t_catch_body body, - void *body_data, - scm_t_catch_handler handler, - void *handler_data); - - - -/* Deprecated 2010-03-31, use array-equal? instead */ -SCM_DEPRECATED SCM scm_raequal (SCM ra0, SCM ra1); - -/* Deprecated 2010-04-01, use the dynamic FFI instead */ -SCM_DEPRECATED SCM scm_dynamic_args_call (SCM symb, SCM dobj, SCM args); - -/* Deprecated 2010-05-12, no replacement */ -SCM_DEPRECATED int scm_badargsp (SCM formals, SCM args); - -/* Deprecated 2010-06-19, use call-with-error-handling instead */ -SCM_DEPRECATED SCM scm_internal_stack_catch (SCM tag, - scm_t_catch_body body, - void *body_data, - scm_t_catch_handler handler, - void *handler_data); - - - -/* These functions were "discouraged" in 1.8, and now are deprecated. */ - -/* scm_to_int, scm_from_int are the official functions to do the job, - but there is nothing wrong with using scm_num2int, etc. - - These could be trivially defined via macros, but we leave them as - functions since existing code may take their addresses. -*/ - -SCM_DEPRECATED SCM scm_short2num (short n); -SCM_DEPRECATED SCM scm_ushort2num (unsigned short n); -SCM_DEPRECATED SCM scm_int2num (int n); -SCM_DEPRECATED SCM scm_uint2num (unsigned int n); -SCM_DEPRECATED SCM scm_long2num (long n); -SCM_DEPRECATED SCM scm_ulong2num (unsigned long n); -SCM_DEPRECATED SCM scm_size2num (size_t n); -SCM_DEPRECATED SCM scm_ptrdiff2num (scm_t_ptrdiff n); -SCM_DEPRECATED short scm_num2short (SCM num, unsigned long int pos, - const char *s_caller); -SCM_DEPRECATED unsigned short scm_num2ushort (SCM num, unsigned long int pos, - const char *s_caller); -SCM_DEPRECATED int scm_num2int (SCM num, unsigned long int pos, - const char *s_caller); -SCM_DEPRECATED unsigned int scm_num2uint (SCM num, unsigned long int pos, - const char *s_caller); -SCM_DEPRECATED long scm_num2long (SCM num, unsigned long int pos, - const char *s_caller); -SCM_DEPRECATED unsigned long scm_num2ulong (SCM num, unsigned long int pos, - const char *s_caller); -SCM_DEPRECATED scm_t_ptrdiff scm_num2ptrdiff (SCM num, unsigned long int pos, - const char *s_caller); -SCM_DEPRECATED size_t scm_num2size (SCM num, unsigned long int pos, - const char *s_caller); -#if SCM_SIZEOF_LONG_LONG != 0 -SCM_DEPRECATED SCM scm_long_long2num (long long sl); -SCM_DEPRECATED SCM scm_ulong_long2num (unsigned long long sl); -SCM_DEPRECATED long long scm_num2long_long (SCM num, unsigned long int pos, - const char *s_caller); -SCM_DEPRECATED unsigned long long scm_num2ulong_long (SCM num, unsigned long int pos, - const char *s_caller); +#define SCM_CHAR_CODE_LIMIT SCM_CHAR_CODE_LIMIT__GONE__REPLACE_WITH__256L +#define SCM_OPDIRP SCM_OPDIRP__GONE__REPLACE_WITH__SCM_DIRP_and_SCM_DIR_OPEN_P +#define SCM_PROCEDURE SCM_PROCEDURE__GONE__REPLACE_WITH__scm_procedure +#define SCM_PROCEDURE_WITH_SETTER_P SCM_PROCEDURE_WITH_SETTER_P__GONE__REPLACE_WITH__scm_is_true__scm_procedure_with_setter_p +#define SCM_SETTER SCM_SETTER__GONE__REPLACE_WITH__scm_setter +#define SCM_THREAD_SWITCHING_CODE SCM_THREAD_SWITCHING_CODE__GONE__REMOVE_FROM_YOUR_CODE +#define SCM_VALIDATE_NUMBER_COPY SCM_VALIDATE_NUMBER_COPY__GONE__REPLACE_WITH__SCM_VALIDATE_DOUBLE_COPY +#define SCM_VALIDATE_NUMBER_DEF_COPY SCM_VALIDATE_NUMBER_DEF_COPY__GONE__REPLACE_WITH__SCM_UNBNDP_and_SCM_VALIDATE_DOUBLE_COPY +#define SCM_VALIDATE_OPDIR SCM_VALIDATE_OPDIR__GONE +#define SCM_VALIDATE_STRING_COPY SCM_VALIDATE_STRING_COPY__GONE +#define SCM_VALIDATE_SUBSTRING_SPEC_COPY SCM_VALIDATE_SUBSTRING_SPEC_COPY__GONE +#define scm_array scm_array__GONE__REPLACE_WITH__scm_t_array +#define scm_array_dim scm_array_dim__GONE__REPLACE_WITH__scm_t_array_dim +#define scm_async_click scm_async_click__GONE__REPLACE_WITH__scm_async_tick +#define scm_call_generic_0 scm_call_generic_0__GONE__REPLACE_WITH__scm_call_0 +#define scm_call_generic_1 scm_call_generic_1__GONE__REPLACE_WITH__scm_call_1 +#define scm_call_generic_2 scm_call_generic_2__GONE__REPLACE_WITH__scm_call_2 +#define scm_call_generic_3 scm_call_generic_3__GONE__REPLACE_WITH__scm_call_3 +#define scm_apply_generic scm_apply_generic__GONE__REPLACE_WITH__scm_apply_0 +#define scm_fport scm_fport__GONE__REPLACE_WITH__scm_t_fport +#define scm_listify scm_listify__GONE__REPLACE_WITH__scm_list_n +#define scm_option scm_option__GONE__REPLACE_WITH__scm_t_option +#define scm_port scm_port__GONE__REPLACE_WITH__scm_t_port +#define scm_port_rw_active scm_port_rw_active__GONE__REPLACE_WITH__scm_t_port_rw_active +#define scm_ptob_descriptor scm_ptob_descriptor__GONE__REPLACE_WITH__scm_t_ptob_descriptor +#define scm_rng scm_rng__GONE__REPLACE_WITH__scm_t_rng +#define scm_rstate scm_rstate__GONE__REPLACE_WITH__scm_t_rstate +#define scm_sizet scm_sizet__GONE__REPLACE_WITH__size_t +#define scm_srcprops scm_srcprops__GONE__REPLACE_WITH__scm_t_srcprops +#define scm_srcprops_chunk scm_srcprops_chunk__GONE__REPLACE_WITH__scm_t_srcprops_chunk +#define scm_struct_i_flags scm_struct_i_flags__GONE__REPLACE_WITH__scm_vtable_index_flags +#define scm_struct_i_free scm_struct_i_free__GONE__REPLACE_WITH__scm_vtable_index_instance_finalize +#define scm_subr_entry scm_subr_entry__GONE__REPLACE_WITH__scm_t_subr_entry +#define scm_substring_move_left_x scm_substring_move_left_x__GONE__REPLACE_WITH__scm_substring_move_x +#define scm_substring_move_right_x scm_substring_move_right_x__GONE__REPLACE_WITH__scm_substring_move_x +#define scm_vtable_index_printer scm_vtable_index_printer__GONE__REPLACE_WITH__scm_vtable_index_instance_printer +#define scm_vtable_index_vtable scm_vtable_index_vtable__GONE__REPLACE_WITH__scm_vtable_index_self +typedef scm_i_t_array scm_i_t_array__GONE__REPLACE_WITH__scm_t_array; + +#ifndef BUILDING_LIBGUILE +#define SCM_ASYNC_TICK SCM_ASYNC_TICK__GONE__REPLACE_WITH__scm_async_tick #endif -SCM_DEPRECATED SCM scm_make_real (double x); -SCM_DEPRECATED double scm_num2dbl (SCM a, const char * why); -SCM_DEPRECATED SCM scm_float2num (float n); -SCM_DEPRECATED SCM scm_double2num (double n); - -/* The next two are implemented in numbers.c since they use features - only available there. -*/ -SCM_DEPRECATED float scm_num2float (SCM num, unsigned long int pos, - const char *s_caller); -SCM_DEPRECATED double scm_num2double (SCM num, unsigned long int pos, - const char *s_caller); - -SCM_DEPRECATED SCM scm_make_complex (double x, double y); - -/* Discouraged because they don't make the encoding explicit. - */ - -SCM_DEPRECATED SCM scm_mem2symbol (const char *mem, size_t len); -SCM_DEPRECATED SCM scm_mem2uninterned_symbol (const char *mem, size_t len); -SCM_DEPRECATED SCM scm_str2symbol (const char *str); - -SCM_DEPRECATED SCM scm_take_str (char *s, size_t len); -SCM_DEPRECATED SCM scm_take0str (char *s); -SCM_DEPRECATED SCM scm_mem2string (const char *src, size_t len); -SCM_DEPRECATED SCM scm_str2string (const char *src); -SCM_DEPRECATED SCM scm_makfrom0str (const char *src); -SCM_DEPRECATED SCM scm_makfrom0str_opt (const char *src); - -/* Discouraged because scm_c_make_string has a better name and is more - consistent with make-string. - */ -SCM_DEPRECATED SCM scm_allocate_string (size_t len); - -/* Discouraged because they are just strange. - */ - -SCM_DEPRECATED SCM scm_make_keyword_from_dash_symbol (SCM symbol); -SCM_DEPRECATED SCM scm_keyword_dash_symbol (SCM keyword); - -/* Discouraged because it does not state what encoding S is in. - */ - -SCM_DEPRECATED SCM scm_c_make_keyword (const char *s); - -SCM_DEPRECATED unsigned int scm_thread_sleep (unsigned int); -SCM_DEPRECATED unsigned long scm_thread_usleep (unsigned long); -SCM_DEPRECATED int scm_internal_select (int fds, - SELECT_TYPE *rfds, - SELECT_TYPE *wfds, - SELECT_TYPE *efds, - struct timeval *timeout); - -/* Deprecated because the cuserid call is deprecated. - */ -SCM_DEPRECATED SCM scm_cuserid (void); - - - -/* Deprecated because it's yet another property interface. - */ -SCM_DEPRECATED SCM scm_primitive_make_property (SCM not_found_proc); -SCM_DEPRECATED SCM scm_primitive_property_ref (SCM prop, SCM obj); -SCM_DEPRECATED SCM scm_primitive_property_set_x (SCM prop, SCM obj, SCM val); -SCM_DEPRECATED SCM scm_primitive_property_del_x (SCM prop, SCM obj); - - - -/* {The old whash table interface} - * Deprecated, as the hash table interface is sufficient, and accessing - * handles of weak hash tables is no longer supported. - */ - -#define scm_whash_handle SCM - -SCM_DEPRECATED SCM scm_whash_get_handle (SCM whash, SCM key); -SCM_DEPRECATED int SCM_WHASHFOUNDP (SCM h); -SCM_DEPRECATED SCM SCM_WHASHREF (SCM whash, SCM handle); -SCM_DEPRECATED void SCM_WHASHSET (SCM whash, SCM handle, SCM obj); -SCM_DEPRECATED SCM scm_whash_create_handle (SCM whash, SCM key); -SCM_DEPRECATED SCM scm_whash_lookup (SCM whash, SCM obj); -SCM_DEPRECATED void scm_whash_insert (SCM whash, SCM key, SCM obj); - - - - -/* No need for a table for names, and the struct->class mapping is - maintained by GOOPS now. */ -#define SCM_STRUCT_TABLE_NAME(X) SCM_CAR (X) -#define SCM_SET_STRUCT_TABLE_NAME(X, NAME) SCM_SETCAR (X, NAME) -#define SCM_STRUCT_TABLE_CLASS(X) SCM_CDR (X) -#define SCM_SET_STRUCT_TABLE_CLASS(X, CLASS) SCM_SETCDR (X, CLASS) - -SCM_DEPRECATED SCM scm_struct_table; -SCM_DEPRECATED SCM scm_struct_create_handle (SCM obj); - /* Deprecated 26-05-2011, as the GC_STUBBORN API doesn't do anything any more. */ -SCM_DEPRECATED SCM scm_immutable_cell (scm_t_bits car, scm_t_bits cdr); -SCM_DEPRECATED SCM scm_immutable_double_cell (scm_t_bits car, scm_t_bits cbr, +SCM_API SCM scm_immutable_cell (scm_t_bits car, scm_t_bits cdr); +SCM_API SCM scm_immutable_double_cell (scm_t_bits car, scm_t_bits cbr, scm_t_bits ccr, scm_t_bits cdr); -SCM_DEPRECATED scm_t_bits scm_i_deprecated_asrtgo (scm_t_bits condition); - -/* Deprecated 08-01-2012, as it's undocumented and unused. */ -#define SCM_ASRTGO(_cond, _label) \ - do { if (!scm_i_deprecated_asrtgo(_cond)) goto _label; } while (0) - - - -/* Deprecated 23-05-2012, as as it's undocumented, poorly named, and - adequately replaced by scm_module_variable / - scm_ensure_module_variable / scm_define / scm_module_define. */ -SCM_DEPRECATED SCM scm_sym2var (SCM sym, SCM thunk, SCM definep); - - - -/* Eval closure deprecation, 23-05-2012. */ -#define SCM_TOP_LEVEL_LOOKUP_CLOSURE (scm_current_module_lookup_closure()) - -SCM_DEPRECATED SCM scm_lookup_closure_module (SCM proc); -SCM_DEPRECATED SCM scm_module_lookup_closure (SCM module); -SCM_DEPRECATED SCM scm_current_module_lookup_closure (void); - -SCM_DEPRECATED scm_t_bits scm_tc16_eval_closure; - -#define SCM_EVAL_CLOSURE_P(x) SCM_TYP16_PREDICATE (scm_tc16_eval_closure, x) - -SCM_DEPRECATED SCM scm_eval_closure_lookup (SCM eclo, SCM sym, SCM definep); -SCM_DEPRECATED SCM scm_standard_eval_closure (SCM module); -SCM_DEPRECATED SCM scm_standard_interface_eval_closure (SCM module); -SCM_DEPRECATED SCM scm_eval_closure_module (SCM eval_closure); - - - -SCM_DEPRECATED SCM scm_struct_vtable_tag (SCM handle); - - - -#ifdef UCHAR_MAX -# define SCM_CHAR_CODE_LIMIT (UCHAR_MAX + 1L) -#else -# define SCM_CHAR_CODE_LIMIT 256L -#endif - - - -SCM_DEPRECATED SCM scm_generalized_vector_p (SCM v); -SCM_DEPRECATED SCM scm_generalized_vector_length (SCM v); -SCM_DEPRECATED SCM scm_generalized_vector_ref (SCM v, SCM idx); -SCM_DEPRECATED SCM scm_generalized_vector_set_x (SCM v, SCM idx, SCM val); -SCM_DEPRECATED SCM scm_generalized_vector_to_list (SCM v); - - - void scm_i_init_deprecated (void); #endif diff --git a/libguile/deprecation.c b/libguile/deprecation.c index aa50eaf8c..1be3aea7e 100644 --- a/libguile/deprecation.c +++ b/libguile/deprecation.c @@ -83,7 +83,7 @@ scm_c_issue_deprecation_warning (const char *msg) fprintf (stderr, "%s\n", msg); else { - scm_puts (msg, scm_current_warning_port ()); + scm_puts_unlocked (msg, scm_current_warning_port ()); scm_newline (scm_current_warning_port ()); } } diff --git a/libguile/dynl.c b/libguile/dynl.c index 0061234e8..79198e64c 100644 --- a/libguile/dynl.c +++ b/libguile/dynl.c @@ -229,11 +229,11 @@ scm_t_bits scm_tc16_dynamic_obj; static int dynl_obj_print (SCM exp, SCM port, scm_print_state *pstate) { - scm_puts ("#<dynamic-object ", port); + scm_puts_unlocked ("#<dynamic-object ", port); scm_iprin1 (DYNL_FILENAME (exp), port, pstate); if (DYNL_HANDLE (exp) == NULL) - scm_puts (" (unlinked)", port); - scm_putc ('>', port); + scm_puts_unlocked (" (unlinked)", port); + scm_putc_unlocked ('>', port); return 1; } diff --git a/libguile/dynstack.c b/libguile/dynstack.c new file mode 100644 index 000000000..ce9a2feae --- /dev/null +++ b/libguile/dynstack.c @@ -0,0 +1,556 @@ +/* Copyright (C) 2012 Free Software Foundation, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 3 of + * the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + + + + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#include <assert.h> + +#include "libguile/_scm.h" +#include "libguile/control.h" +#include "libguile/eval.h" +#include "libguile/fluids.h" +#include "libguile/dynstack.h" + + + + +#define PROMPT_WORDS 5 +#define PROMPT_KEY(top) (SCM_PACK ((top)[0])) +#define PROMPT_FP(top) ((SCM *) ((top)[1])) +#define PROMPT_SP(top) ((SCM *) ((top)[2])) +#define PROMPT_IP(top) ((scm_t_uint8 *) ((top)[3])) +#define PROMPT_JMPBUF(top) ((scm_i_jmp_buf *) ((top)[4])) + +#define WINDER_WORDS 2 +#define WINDER_PROC(top) ((scm_t_guard) ((top)[0])) +#define WINDER_DATA(top) ((void *) ((top)[1])) + +#define DYNWIND_WORDS 2 +#define DYNWIND_ENTER(top) (SCM_PACK ((top)[0])) +#define DYNWIND_LEAVE(top) (SCM_PACK ((top)[1])) + +#define WITH_FLUIDS_FLUIDS(top) ((SCM*)((top) + 1)) +#define WITH_FLUIDS_VALUES(top) ((SCM*)((top)[0])) + + + + +static void +copy_scm_t_bits (scm_t_bits *dst, scm_t_bits *src, size_t n) +{ + size_t i; + + for (i = 0; i < n; i++) + dst[i] = src[i]; +} + +static void +copy_scm (SCM *dst, SCM *src, size_t n) +{ + size_t i; + + for (i = 0; i < n; i++) + dst[i] = src[i]; +} + +static void +clear_scm_t_bits (scm_t_bits *items, size_t n) +{ + size_t i; + + for (i = 0; i < n; i++) + items[i] = 0; +} + +/* Ensure space for N additional words. */ +static void +dynstack_ensure_space (scm_t_dynstack *dynstack, size_t n) +{ + size_t capacity = SCM_DYNSTACK_CAPACITY (dynstack); + size_t height = SCM_DYNSTACK_HEIGHT (dynstack); + + n += SCM_DYNSTACK_HEADER_LEN; + + if (capacity < height + n) + { + scm_t_bits *new_base; + + while (capacity < height + n) + capacity = (capacity < 4) ? 8 : (capacity * 2); + + new_base = scm_gc_malloc (capacity * sizeof(scm_t_bits), "dynstack"); + + copy_scm_t_bits (new_base, dynstack->base, height); + clear_scm_t_bits (dynstack->base, height); + + dynstack->base = new_base; + dynstack->top = new_base + height; + dynstack->limit = new_base + capacity; + } +} + +static inline scm_t_bits * +push_dynstack_entry_unchecked (scm_t_dynstack *dynstack, + scm_t_dynstack_item_type type, + scm_t_bits flags, size_t len) +{ + scm_t_bits *ret = dynstack->top; + + SCM_DYNSTACK_SET_TAG (dynstack->top, SCM_MAKE_DYNSTACK_TAG (type, flags, len)); + dynstack->top += SCM_DYNSTACK_HEADER_LEN + len; + SCM_DYNSTACK_SET_PREV_OFFSET (dynstack->top, SCM_DYNSTACK_HEADER_LEN + len); + + return ret; +} + +static inline scm_t_bits * +push_dynstack_entry (scm_t_dynstack *dynstack, + scm_t_dynstack_item_type type, + scm_t_bits flags, size_t len) +{ + if (SCM_UNLIKELY (!SCM_DYNSTACK_HAS_SPACE (dynstack, len))) + dynstack_ensure_space (dynstack, len); + return push_dynstack_entry_unchecked (dynstack, type, flags, len); +} + +void +scm_dynstack_push_frame (scm_t_dynstack *dynstack, + scm_t_dynstack_frame_flags flags) +{ + push_dynstack_entry (dynstack, SCM_DYNSTACK_TYPE_FRAME, flags, 0); +} + +void +scm_dynstack_push_rewinder (scm_t_dynstack *dynstack, + scm_t_dynstack_winder_flags flags, + scm_t_guard proc, void *data) +{ + scm_t_bits *words; + + words = push_dynstack_entry (dynstack, SCM_DYNSTACK_TYPE_REWINDER, flags, 2); + words[0] = (scm_t_bits) proc; + words[1] = (scm_t_bits) data; +} + +void +scm_dynstack_push_unwinder (scm_t_dynstack *dynstack, + scm_t_dynstack_winder_flags flags, + scm_t_guard proc, void *data) +{ + scm_t_bits *words; + + words = push_dynstack_entry (dynstack, SCM_DYNSTACK_TYPE_UNWINDER, flags, 2); + words[0] = (scm_t_bits) proc; + words[1] = (scm_t_bits) data; +} + +/* The fluids are stored on the stack. However, the values have to be + stored on the heap, so that all continuations that capture this + dynamic scope capture the same bindings. */ +void +scm_dynstack_push_fluids (scm_t_dynstack *dynstack, size_t n, + SCM *fluids, SCM *values, SCM dynamic_state) +{ + scm_t_bits *words; + SCM *heap_values; + + n = scm_prepare_fluids (n, fluids, values); + heap_values = scm_gc_malloc (n * sizeof (scm_t_bits), "with-fluids"); + copy_scm (heap_values, values, n); + + words = push_dynstack_entry (dynstack, SCM_DYNSTACK_TYPE_WITH_FLUIDS, + 0, n + 1); + words[0] = (scm_t_bits) heap_values; + copy_scm (WITH_FLUIDS_FLUIDS (words), fluids, n); + + /* Go ahead and swap them. */ + scm_swap_fluids (n, WITH_FLUIDS_FLUIDS (words), WITH_FLUIDS_VALUES (words), + dynamic_state); +} + +void +scm_dynstack_push_prompt (scm_t_dynstack *dynstack, + scm_t_dynstack_prompt_flags flags, + SCM key, + SCM *fp, SCM *sp, scm_t_uint8 *ip, + scm_i_jmp_buf *registers) +{ + scm_t_bits *words; + + words = push_dynstack_entry (dynstack, SCM_DYNSTACK_TYPE_PROMPT, flags, + PROMPT_WORDS); + words[0] = SCM_UNPACK (key); + words[1] = (scm_t_bits) fp; + words[2] = (scm_t_bits) sp; + words[3] = (scm_t_bits) ip; + words[4] = (scm_t_bits) registers; +} + +void +scm_dynstack_push_dynwind (scm_t_dynstack *dynstack, SCM enter, SCM leave) +{ + scm_t_bits *words; + + words = push_dynstack_entry (dynstack, SCM_DYNSTACK_TYPE_DYNWIND, 0, 2); + words[0] = SCM_UNPACK (enter); + words[1] = SCM_UNPACK (leave); +} + +static inline scm_t_bits +dynstack_pop (scm_t_dynstack *dynstack, scm_t_bits **words) +{ + scm_t_bits *prev = SCM_DYNSTACK_PREV (dynstack->top); + scm_t_bits tag; + + if (SCM_UNLIKELY (!prev)) + abort (); + + SCM_DYNSTACK_SET_PREV_OFFSET (dynstack->top, 0); + dynstack->top = prev; + + tag = SCM_DYNSTACK_TAG (dynstack->top); + SCM_DYNSTACK_SET_TAG (dynstack->top, 0); + *words = dynstack->top; + + return tag; +} + +void +scm_dynstack_pop (scm_t_dynstack *dynstack) +{ + scm_t_bits tag, *words; + tag = dynstack_pop (dynstack, &words); + clear_scm_t_bits (words, SCM_DYNSTACK_TAG_LEN (tag)); +} + +scm_t_dynstack * +scm_dynstack_capture_all (scm_t_dynstack *dynstack) +{ + return scm_dynstack_capture (dynstack, SCM_DYNSTACK_FIRST (dynstack)); +} + +scm_t_dynstack * +scm_dynstack_capture (scm_t_dynstack *dynstack, scm_t_bits *item) +{ + char *mem; + scm_t_dynstack *ret; + size_t len; + + assert (item >= SCM_DYNSTACK_FIRST (dynstack)); + assert (item <= dynstack->top); + + len = dynstack->top - item + SCM_DYNSTACK_HEADER_LEN; + mem = scm_gc_malloc (sizeof (*ret) + len * sizeof(scm_t_bits), "dynstack"); + ret = (scm_t_dynstack *) mem; + ret->base = (scm_t_bits *) (mem + sizeof (*ret)); + ret->limit = ret->base + len; + ret->top = ret->base + len; + + copy_scm_t_bits (ret->base, item - SCM_DYNSTACK_HEADER_LEN, len); + SCM_DYNSTACK_SET_PREV_OFFSET (SCM_DYNSTACK_FIRST (ret), 0); + + return ret; +} + +void +scm_dynstack_wind_1 (scm_t_dynstack *dynstack, scm_t_bits *item) +{ + scm_t_bits tag = SCM_DYNSTACK_TAG (item); + scm_t_dynstack_item_type type = SCM_DYNSTACK_TAG_TYPE (tag); + scm_t_bits flags = SCM_DYNSTACK_TAG_FLAGS (tag); + size_t len = SCM_DYNSTACK_TAG_LEN (tag); + + switch (type) + { + case SCM_DYNSTACK_TYPE_FRAME: + if (!(flags & SCM_F_DYNSTACK_FRAME_REWINDABLE)) + scm_misc_error ("scm_dynstack_wind_1", + "cannot invoke continuation from this context", + SCM_EOL); + break; + + case SCM_DYNSTACK_TYPE_UNWINDER: + break; + + case SCM_DYNSTACK_TYPE_REWINDER: + WINDER_PROC (item) (WINDER_DATA (item)); + break; + + case SCM_DYNSTACK_TYPE_WITH_FLUIDS: + scm_swap_fluids (len - 1, WITH_FLUIDS_FLUIDS (item), + WITH_FLUIDS_VALUES (item), + SCM_I_CURRENT_THREAD->dynamic_state); + break; + + case SCM_DYNSTACK_TYPE_PROMPT: + /* see vm_reinstate_partial_continuation */ + break; + + case SCM_DYNSTACK_TYPE_DYNWIND: + scm_call_0 (DYNWIND_ENTER (item)); + break; + + case SCM_DYNSTACK_TYPE_NONE: + default: + abort (); + } + + { + scm_t_bits *words = push_dynstack_entry (dynstack, type, flags, len); + + copy_scm_t_bits (words, item, len); + } +} + +scm_t_bits +scm_dynstack_unwind_1 (scm_t_dynstack *dynstack) +{ + scm_t_bits tag; + scm_t_bits *words; + scm_t_dynstack_item_type type; + size_t len; + + tag = dynstack_pop (dynstack, &words); + + type = SCM_DYNSTACK_TAG_TYPE (tag); + len = SCM_DYNSTACK_TAG_LEN (tag); + + switch (type) + { + case SCM_DYNSTACK_TYPE_FRAME: + break; + + case SCM_DYNSTACK_TYPE_UNWINDER: + WINDER_PROC (words) (WINDER_DATA (words)); + clear_scm_t_bits (words, WINDER_WORDS); + break; + + case SCM_DYNSTACK_TYPE_REWINDER: + clear_scm_t_bits (words, WINDER_WORDS); + break; + + case SCM_DYNSTACK_TYPE_WITH_FLUIDS: + scm_swap_fluids (len - 1, WITH_FLUIDS_FLUIDS (words), + WITH_FLUIDS_VALUES (words), + SCM_I_CURRENT_THREAD->dynamic_state); + clear_scm_t_bits (words, len); + break; + + case SCM_DYNSTACK_TYPE_PROMPT: + /* we could invalidate the prompt */ + clear_scm_t_bits (words, PROMPT_WORDS); + break; + + case SCM_DYNSTACK_TYPE_DYNWIND: + { + SCM proc = DYNWIND_LEAVE (words); + clear_scm_t_bits (words, DYNWIND_WORDS); + scm_call_0 (proc); + } + break; + + case SCM_DYNSTACK_TYPE_NONE: + default: + abort (); + } + + return tag; +} + +void +scm_dynstack_wind (scm_t_dynstack *dynstack, scm_t_bits *item) +{ + for (; SCM_DYNSTACK_TAG (item); item = SCM_DYNSTACK_NEXT (item)) + scm_dynstack_wind_1 (dynstack, item); +} + +void +scm_dynstack_unwind (scm_t_dynstack *dynstack, scm_t_bits *base) +{ + while (dynstack->top > base) + scm_dynstack_unwind_1 (dynstack); +} + +static int +same_entries (scm_t_bits *walk_a, scm_t_bits *next_a, + scm_t_bits *walk_b, scm_t_bits *next_b) +{ + if (SCM_DYNSTACK_TAG (walk_a) != SCM_DYNSTACK_TAG (walk_b)) + return 0; + + if (next_a - walk_a != next_b - walk_b) + return 0; + + assert (SCM_DYNSTACK_PREV_OFFSET (next_a) == next_a - walk_a); + assert (SCM_DYNSTACK_PREV_OFFSET (next_b) == next_b - walk_b); + + while (walk_a != next_a) + if (*(walk_a++) != *(walk_b++)) + return 0; + + return 1; +} + +static ptrdiff_t +shared_prefix_length (scm_t_dynstack *a, scm_t_dynstack *b) +{ + scm_t_bits *walk_a, *next_a, *walk_b, *next_b; + + walk_a = SCM_DYNSTACK_FIRST (a); + walk_b = SCM_DYNSTACK_FIRST (b); + + next_a = SCM_DYNSTACK_NEXT (walk_a); + next_b = SCM_DYNSTACK_NEXT (walk_b); + + while (next_a && next_b && same_entries (walk_a, next_a, walk_b, next_b)) + { + walk_a = next_a; + walk_b = next_b; + + next_a = SCM_DYNSTACK_NEXT (walk_a); + next_b = SCM_DYNSTACK_NEXT (walk_b); + } + + return walk_a - a->base; +} + +scm_t_bits * +scm_dynstack_unwind_fork (scm_t_dynstack *dynstack, scm_t_dynstack *branch) +{ + ptrdiff_t join_height; + + join_height = shared_prefix_length (dynstack, branch); + + scm_dynstack_unwind (dynstack, dynstack->base + join_height); + + return branch->base + join_height; +} + +scm_t_bits* +scm_dynstack_find_prompt (scm_t_dynstack *dynstack, SCM key, + scm_t_dynstack_prompt_flags *flags, + SCM **fp, SCM **sp, scm_t_uint8 **ip, + scm_i_jmp_buf **registers) +{ + scm_t_bits *walk; + + for (walk = SCM_DYNSTACK_PREV (dynstack->top); walk; + walk = SCM_DYNSTACK_PREV (walk)) + { + scm_t_bits tag = SCM_DYNSTACK_TAG (walk); + + if (SCM_DYNSTACK_TAG_TYPE (tag) == SCM_DYNSTACK_TYPE_PROMPT + && scm_is_eq (PROMPT_KEY (walk), key)) + { + if (flags) + *flags = SCM_DYNSTACK_TAG_FLAGS (tag); + if (fp) + *fp = PROMPT_FP (walk); + if (sp) + *sp = PROMPT_SP (walk); + if (ip) + *ip = PROMPT_IP (walk); + if (registers) + *registers = PROMPT_JMPBUF (walk); + return walk; + } + } + + return NULL; +} + +void +scm_dynstack_wind_prompt (scm_t_dynstack *dynstack, scm_t_bits *item, + scm_t_ptrdiff reloc, scm_i_jmp_buf *registers) +{ + scm_t_bits tag = SCM_DYNSTACK_TAG (item); + + if (SCM_DYNSTACK_TAG_TYPE (tag) != SCM_DYNSTACK_TYPE_PROMPT) + abort (); + + scm_dynstack_push_prompt (dynstack, + SCM_DYNSTACK_TAG_FLAGS (tag), + PROMPT_KEY (item), + PROMPT_FP (item) + reloc, + PROMPT_SP (item) + reloc, + PROMPT_IP (item), + registers); +} + +void +scm_dynstack_unwind_frame (scm_t_dynstack *dynstack) +{ + /* Unwind up to and including the next frame entry. */ + while (1) + { + scm_t_bits tag, *words; + + tag = dynstack_pop (dynstack, &words); + + switch (SCM_DYNSTACK_TAG_TYPE (tag)) + { + case SCM_DYNSTACK_TYPE_FRAME: + return; + case SCM_DYNSTACK_TYPE_REWINDER: + clear_scm_t_bits (words, WINDER_WORDS); + continue; + case SCM_DYNSTACK_TYPE_UNWINDER: + { + scm_t_guard proc = WINDER_PROC (words); + void *data = WINDER_DATA (words); + clear_scm_t_bits (words, WINDER_WORDS); + if (SCM_DYNSTACK_TAG_FLAGS (tag) & SCM_F_DYNSTACK_WINDER_EXPLICIT) + proc (data); + continue; + } + default: + /* We should only see winders. */ + abort (); + } + } +} + +/* This function must not allocate. */ +void +scm_dynstack_unwind_fluids (scm_t_dynstack *dynstack, SCM dynamic_state) +{ + scm_t_bits tag, *words; + size_t len; + + tag = dynstack_pop (dynstack, &words); + len = SCM_DYNSTACK_TAG_LEN (tag); + + assert (SCM_DYNSTACK_TAG_TYPE (tag) == SCM_DYNSTACK_TYPE_WITH_FLUIDS); + assert (len >= 1); + + scm_swap_fluids (len - 1, WITH_FLUIDS_FLUIDS (words), + WITH_FLUIDS_VALUES (words), dynamic_state); + clear_scm_t_bits (words, len); +} + + +/* + Local Variables: + c-file-style: "gnu" + End: +*/ diff --git a/libguile/dynstack.h b/libguile/dynstack.h new file mode 100644 index 000000000..207638ec7 --- /dev/null +++ b/libguile/dynstack.h @@ -0,0 +1,208 @@ +/* classes: h_files */ + +#ifndef SCM_DYNSTACK_H +#define SCM_DYNSTACK_H + +/* Copyright (C) 2012 Free Software Foundation, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 3 of + * the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + + + +#include "libguile/__scm.h" +#include "libguile/control.h" + + + +typedef struct +{ + scm_t_bits *base; + scm_t_bits *top; + scm_t_bits *limit; +} scm_t_dynstack; + + + +/* Items on the dynstack are preceded by two-word headers, giving the + offset of the preceding item (or 0 if there is none) and the type, + flags, and length of the following dynstack entry, in words. In + addition, there is a "null header" at the top of the stack, + indicating the length of the previous item, but with a tag of zero. + + For example, consider an empty dynstack, with a capacity of 6 words: + + +----------+----------+ + + |prev=0 |tag=0 | | + +----------+----------+ + + ^base ^top limit^ + + Now we evaluate (dynamic-wind enter thunk leave). That will result + in a dynstack of: + + / the len=2 words \ + +----------+----------+----------+----------+----------+----------+ + |prev=0 |tag:len=2 |enter |leave |prev=4 |tag=0 | + +----------+----------+----------+----------+----------+----------+ + ^base top,limit^ + + The tag is a combination of the type of the dynstack item, some flags + associated with the item, and the length of the item. See + SCM_MAKE_DYNSTACK_TAG below for the details. + + This arrangement makes it possible to have variable-length dynstack + items, and yet be able to traverse them forwards or backwards. */ + +#define SCM_DYNSTACK_HEADER_LEN 2 + +#define SCM_DYNSTACK_PREV_OFFSET(top) ((top)[-2]) +#define SCM_DYNSTACK_SET_PREV_OFFSET(top, offset) (top)[-2] = (offset) + +#define SCM_DYNSTACK_TAG(top) ((top)[-1]) +#define SCM_DYNSTACK_SET_TAG(top, tag) (top)[-1] = (tag) + +typedef enum { + SCM_DYNSTACK_TYPE_NONE = 0, + SCM_DYNSTACK_TYPE_FRAME, + SCM_DYNSTACK_TYPE_UNWINDER, + SCM_DYNSTACK_TYPE_REWINDER, + SCM_DYNSTACK_TYPE_WITH_FLUIDS, + SCM_DYNSTACK_TYPE_PROMPT, + SCM_DYNSTACK_TYPE_DYNWIND, +} scm_t_dynstack_item_type; + +#define SCM_DYNSTACK_TAG_TYPE_MASK 0xf +#define SCM_DYNSTACK_TAG_FLAGS_MASK 0xf0 +#define SCM_DYNSTACK_TAG_FLAGS_SHIFT 4 +#define SCM_DYNSTACK_TAG_LEN_SHIFT 8 + +#define SCM_MAKE_DYNSTACK_TAG(type, flags, len) \ + ((type) | (flags) | ((len) << SCM_DYNSTACK_TAG_LEN_SHIFT)) + +#define SCM_DYNSTACK_TAG_TYPE(tag) \ + ((tag) & SCM_DYNSTACK_TAG_TYPE_MASK) +#define SCM_DYNSTACK_TAG_FLAGS(tag) \ + ((tag) & SCM_DYNSTACK_TAG_FLAGS_MASK) +#define SCM_DYNSTACK_TAG_LEN(tag) \ + ((tag) >> SCM_DYNSTACK_TAG_LEN_SHIFT) + +#define SCM_DYNSTACK_PREV(top) \ + (SCM_DYNSTACK_PREV_OFFSET (top) \ + ? ((top) - SCM_DYNSTACK_PREV_OFFSET (top)) : NULL) +#define SCM_DYNSTACK_NEXT(top) \ + (SCM_DYNSTACK_TAG (top) \ + ? ((top) + SCM_DYNSTACK_TAG_LEN (SCM_DYNSTACK_TAG (top)) \ + + SCM_DYNSTACK_HEADER_LEN) \ + : NULL) + +#define SCM_DYNSTACK_FIRST(dynstack) \ + ((dynstack)->base + SCM_DYNSTACK_HEADER_LEN) + +#define SCM_DYNSTACK_CAPACITY(dynstack) \ + ((dynstack)->limit - (dynstack)->base) +#define SCM_DYNSTACK_SPACE(dynstack) \ + ((dynstack)->limit - (dynstack)->top) +#define SCM_DYNSTACK_HEIGHT(dynstack) \ + ((dynstack)->top - (dynstack)->base) + +#define SCM_DYNSTACK_HAS_SPACE(dynstack, n) \ + (SCM_DYNSTACK_SPACE (dynstack) >= n + SCM_DYNSTACK_HEADER_LEN) + +typedef enum { + SCM_F_DYNSTACK_FRAME_REWINDABLE = (1 << SCM_DYNSTACK_TAG_FLAGS_SHIFT) +} scm_t_dynstack_frame_flags; + +typedef enum { + SCM_F_DYNSTACK_WINDER_EXPLICIT = (1 << SCM_DYNSTACK_TAG_FLAGS_SHIFT) +} scm_t_dynstack_winder_flags; + +typedef enum { + SCM_F_DYNSTACK_PROMPT_ESCAPE_ONLY = (1 << SCM_DYNSTACK_TAG_FLAGS_SHIFT) +} scm_t_dynstack_prompt_flags; + +typedef void (*scm_t_guard) (void *); + + + + +/* Pushing and popping entries on the dynamic stack. */ + +SCM_INTERNAL void scm_dynstack_push_frame (scm_t_dynstack *, + scm_t_dynstack_frame_flags); +SCM_INTERNAL void scm_dynstack_push_rewinder (scm_t_dynstack *, + scm_t_dynstack_winder_flags, + scm_t_guard, void *); +SCM_INTERNAL void scm_dynstack_push_unwinder (scm_t_dynstack *, + scm_t_dynstack_winder_flags, + scm_t_guard, void *); +SCM_INTERNAL void scm_dynstack_push_fluids (scm_t_dynstack *, + size_t, + SCM *fluids, + SCM *values, + SCM dynamic_state); +SCM_INTERNAL void scm_dynstack_push_prompt (scm_t_dynstack *, + scm_t_dynstack_prompt_flags, + SCM key, + SCM *fp, SCM *sp, scm_t_uint8 *ip, + scm_i_jmp_buf *registers); +SCM_INTERNAL void scm_dynstack_push_dynwind (scm_t_dynstack *, + SCM enter, SCM leave); + +SCM_INTERNAL void scm_dynstack_pop (scm_t_dynstack *); + + + + +/* Capturing, winding, and unwinding. */ + +SCM_INTERNAL scm_t_dynstack* scm_dynstack_capture_all (scm_t_dynstack *dynstack); +SCM_INTERNAL scm_t_dynstack* scm_dynstack_capture (scm_t_dynstack *dynstack, + scm_t_bits *item); + +SCM_INTERNAL void scm_dynstack_wind_1 (scm_t_dynstack *, scm_t_bits *); +SCM_INTERNAL scm_t_bits scm_dynstack_unwind_1 (scm_t_dynstack *); + +SCM_INTERNAL void scm_dynstack_wind (scm_t_dynstack *, scm_t_bits *); +SCM_INTERNAL void scm_dynstack_unwind (scm_t_dynstack *, scm_t_bits *); + + + + +/* Miscellany. */ + +SCM_INTERNAL scm_t_bits* scm_dynstack_unwind_fork (scm_t_dynstack *, + scm_t_dynstack *); + +SCM_INTERNAL void scm_dynstack_unwind_frame (scm_t_dynstack *); +SCM_INTERNAL void scm_dynstack_unwind_fluids (scm_t_dynstack *dynstack, + SCM dynamic_state); + +SCM_INTERNAL scm_t_bits* scm_dynstack_find_prompt (scm_t_dynstack *, SCM, + scm_t_dynstack_prompt_flags *, + SCM **, SCM **, scm_t_uint8 **, + scm_i_jmp_buf **); + +SCM_INTERNAL void scm_dynstack_wind_prompt (scm_t_dynstack *, scm_t_bits *, + scm_t_ptrdiff, scm_i_jmp_buf *); + + +#endif /* SCM_DYNSTACK_H */ + +/* + Local Variables: + c-file-style: "gnu" + End: +*/ diff --git a/libguile/dynwind.c b/libguile/dynwind.c index 14dd861dc..4a0b0dd2b 100644 --- a/libguile/dynwind.c +++ b/libguile/dynwind.c @@ -1,5 +1,5 @@ -/* Copyright (C) 1995,1996,1998,1999,2000,2001, 2003, 2004, 2006, 2008, 2010, 2011 Free Software Foundation, Inc. - * +/* Copyright (C) 1995,1996,1998,1999,2000,2001, 2003, 2004, 2006, 2008, 2010, 2011, 2012 Free Software Foundation, Inc. + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version 3 of @@ -26,125 +26,71 @@ #include <assert.h> #include "libguile/_scm.h" -#include "libguile/control.h" +#include "libguile/dynstack.h" #include "libguile/eval.h" -#include "libguile/alist.h" -#include "libguile/fluids.h" #include "libguile/ports.h" -#include "libguile/smob.h" #include "libguile/dynwind.h" - - -/* {Dynamic wind} - - Things that can be on the wind list: - - #<frame> - #<winder> - #<with-fluids> - #<prompt> - (enter-proc . leave-proc) dynamic-wind - -*/ + SCM scm_dynamic_wind (SCM in_guard, SCM thunk, SCM out_guard) #define FUNC_NAME "dynamic-wind" { - SCM ans, old_winds; - SCM_ASSERT (scm_is_true (scm_thunk_p (out_guard)), - out_guard, + SCM ans; + scm_i_thread *thread = SCM_I_CURRENT_THREAD; + + SCM_ASSERT (scm_is_true (scm_thunk_p (out_guard)), out_guard, SCM_ARG3, FUNC_NAME); + scm_call_0 (in_guard); - old_winds = scm_i_dynwinds (); - scm_i_set_dynwinds (scm_acons (in_guard, out_guard, old_winds)); + scm_dynstack_push_dynwind (&thread->dynstack, in_guard, out_guard); + ans = scm_call_0 (thunk); - scm_i_set_dynwinds (old_winds); + + scm_dynstack_pop (&thread->dynstack); scm_call_0 (out_guard); + return ans; } #undef FUNC_NAME -/* Frames and winders. */ - -static scm_t_bits tc16_frame; -#define FRAME_P(f) SCM_SMOB_PREDICATE (tc16_frame, (f)) - -#define FRAME_F_REWINDABLE (1 << 0) -#define FRAME_REWINDABLE_P(f) (SCM_SMOB_FLAGS(f) & FRAME_F_REWINDABLE) - -static scm_t_bits tc16_winder; -#define WINDER_P(w) SCM_SMOB_PREDICATE (tc16_winder, (w)) -#define WINDER_PROC(w) ((void (*)(void *))SCM_SMOB_DATA (w)) -#define WINDER_DATA(w) ((void *)SCM_SMOB_DATA_2 (w)) - -#define WINDER_F_EXPLICIT (1 << 0) -#define WINDER_F_REWIND (1 << 1) -#define WINDER_F_MARK (1 << 2) -#define WINDER_EXPLICIT_P(w) (SCM_SMOB_FLAGS(w) & WINDER_F_EXPLICIT) -#define WINDER_REWIND_P(w) (SCM_SMOB_FLAGS(w) & WINDER_F_REWIND) -#define WINDER_MARK_P(w) (SCM_SMOB_FLAGS(w) & WINDER_F_MARK) void scm_dynwind_begin (scm_t_dynwind_flags flags) { - SCM f; - SCM_NEWSMOB (f, tc16_frame, 0); - if (flags & SCM_F_DYNWIND_REWINDABLE) - SCM_SET_SMOB_FLAGS (f, FRAME_F_REWINDABLE); - scm_i_set_dynwinds (scm_cons (f, scm_i_dynwinds ())); + scm_i_thread *thread = SCM_I_CURRENT_THREAD; + + scm_dynstack_push_frame (&thread->dynstack, flags); } void scm_dynwind_end (void) { - SCM winds; - - /* Unwind upto and including the next frame entry. We can only - encounter #<winder> entries on the way. - */ - - winds = scm_i_dynwinds (); - while (scm_is_pair (winds)) - { - SCM entry = SCM_CAR (winds); - winds = SCM_CDR (winds); - - scm_i_set_dynwinds (winds); - - if (FRAME_P (entry)) - return; - - assert (WINDER_P (entry)); - if (!WINDER_REWIND_P (entry) && WINDER_EXPLICIT_P (entry)) - WINDER_PROC(entry) (WINDER_DATA (entry)); - } - - assert (0); + scm_dynstack_unwind_frame (&SCM_I_CURRENT_THREAD->dynstack); } void scm_dynwind_unwind_handler (void (*proc) (void *), void *data, scm_t_wind_flags flags) { - SCM w; - SCM_NEWSMOB2 (w, tc16_winder, (scm_t_bits) proc, (scm_t_bits) data); - if (flags & SCM_F_WIND_EXPLICITLY) - SCM_SET_SMOB_FLAGS (w, WINDER_F_EXPLICIT); - scm_i_set_dynwinds (scm_cons (w, scm_i_dynwinds ())); + scm_i_thread *thread = SCM_I_CURRENT_THREAD; + scm_t_dynstack *dynstack = &thread->dynstack; + + scm_dynstack_push_unwinder (dynstack, flags, proc, data); } void scm_dynwind_rewind_handler (void (*proc) (void *), void *data, scm_t_wind_flags flags) { - SCM w; - SCM_NEWSMOB2 (w, tc16_winder, (scm_t_bits) proc, (scm_t_bits) data); - SCM_SET_SMOB_FLAGS (w, WINDER_F_REWIND); - scm_i_set_dynwinds (scm_cons (w, scm_i_dynwinds ())); + scm_i_thread *thread = SCM_I_CURRENT_THREAD; + scm_t_dynstack *dynstack = &thread->dynstack; + + scm_dynstack_push_rewinder (dynstack, 0, proc, data); + if (flags & SCM_F_WIND_EXPLICITLY) proc (data); } @@ -153,23 +99,16 @@ void scm_dynwind_unwind_handler_with_scm (void (*proc) (SCM), SCM data, scm_t_wind_flags flags) { - SCM w; - scm_t_bits fl = ((flags&SCM_F_WIND_EXPLICITLY)? WINDER_F_EXPLICIT : 0); - SCM_NEWSMOB2 (w, tc16_winder, (scm_t_bits) proc, SCM_UNPACK (data)); - SCM_SET_SMOB_FLAGS (w, fl | WINDER_F_MARK); - scm_i_set_dynwinds (scm_cons (w, scm_i_dynwinds ())); + /* FIXME: This is not a safe cast. */ + scm_dynwind_unwind_handler ((scm_t_guard) proc, SCM2PTR (data), flags); } void scm_dynwind_rewind_handler_with_scm (void (*proc) (SCM), SCM data, scm_t_wind_flags flags) { - SCM w; - SCM_NEWSMOB2 (w, tc16_winder, (scm_t_bits) proc, SCM_UNPACK (data)); - SCM_SET_SMOB_FLAGS (w, WINDER_F_REWIND | WINDER_F_MARK); - scm_i_set_dynwinds (scm_cons (w, scm_i_dynwinds ())); - if (flags & SCM_F_WIND_EXPLICITLY) - proc (data); + /* FIXME: This is not a safe cast. */ + scm_dynwind_rewind_handler ((scm_t_guard) proc, SCM2PTR (data), flags); } void @@ -178,24 +117,11 @@ scm_dynwind_free (void *mem) scm_dynwind_unwind_handler (free, mem, SCM_F_WIND_EXPLICITLY); } -#ifdef GUILE_DEBUG -SCM_DEFINE (scm_wind_chain, "wind-chain", 0, 0, 0, - (), - "Return the current wind chain. The wind chain contains all\n" - "information required by @code{dynamic-wind} to call its\n" - "argument thunks when entering/exiting its scope.") -#define FUNC_NAME s_scm_wind_chain -{ - return scm_i_dynwinds (); -} -#undef FUNC_NAME -#endif - void scm_swap_bindings (SCM vars, SCM vals) { SCM tmp; - while (SCM_NIMP (vals)) + while (scm_is_pair (vals)) { tmp = SCM_VARIABLE_REF (SCM_CAR (vars)); SCM_VARIABLE_SET (SCM_CAR (vars), SCM_CAR (vals)); @@ -206,97 +132,8 @@ scm_swap_bindings (SCM vars, SCM vals) } void -scm_dowinds (SCM to, long delta) -{ - scm_i_dowinds (to, delta, NULL, NULL); -} - -void -scm_i_dowinds (SCM to, long delta, void (*turn_func) (void *), void *data) -{ - tail: - if (scm_is_eq (to, scm_i_dynwinds ())) - { - if (turn_func) - turn_func (data); - } - else if (delta < 0) - { - SCM wind_elt; - - scm_i_dowinds (SCM_CDR (to), 1 + delta, turn_func, data); - wind_elt = SCM_CAR (to); - - if (FRAME_P (wind_elt)) - { - if (!FRAME_REWINDABLE_P (wind_elt)) - scm_misc_error ("dowinds", - "cannot invoke continuation from this context", - SCM_EOL); - } - else if (WINDER_P (wind_elt)) - { - if (WINDER_REWIND_P (wind_elt)) - WINDER_PROC (wind_elt) (WINDER_DATA (wind_elt)); - } - else if (SCM_WITH_FLUIDS_P (wind_elt)) - { - scm_i_swap_with_fluids (wind_elt, - SCM_I_CURRENT_THREAD->dynamic_state); - } - else if (SCM_PROMPT_P (wind_elt)) - ; /* pass -- see vm_reinstate_partial_continuation */ - else if (scm_is_pair (wind_elt)) - scm_call_0 (SCM_CAR (wind_elt)); - else - /* trash on the wind list */ - abort (); - - scm_i_set_dynwinds (to); - } - else - { - SCM wind; - SCM wind_elt; - - wind = scm_i_dynwinds (); - wind_elt = SCM_CAR (wind); - scm_i_set_dynwinds (SCM_CDR (wind)); - - if (FRAME_P (wind_elt)) - { - /* Nothing to do. */ - } - else if (WINDER_P (wind_elt)) - { - if (!WINDER_REWIND_P (wind_elt)) - WINDER_PROC (wind_elt) (WINDER_DATA (wind_elt)); - } - else if (SCM_WITH_FLUIDS_P (wind_elt)) - { - scm_i_swap_with_fluids (wind_elt, - SCM_I_CURRENT_THREAD->dynamic_state); - } - else if (SCM_PROMPT_P (wind_elt)) - ; /* pass -- though we could invalidate the prompt */ - else if (scm_is_pair (wind_elt)) - scm_call_0 (SCM_CDR (wind_elt)); - else - /* trash on the wind list */ - abort (); - - delta--; - goto tail; /* scm_dowinds(to, delta-1); */ - } -} - -void scm_init_dynwind () { - tc16_frame = scm_make_smob_type ("frame", 0); - - tc16_winder = scm_make_smob_type ("winder", 0); - #include "libguile/dynwind.x" } diff --git a/libguile/dynwind.h b/libguile/dynwind.h index 6e952c4db..9ade05c0b 100644 --- a/libguile/dynwind.h +++ b/libguile/dynwind.h @@ -3,7 +3,7 @@ #ifndef SCM_DYNWIND_H #define SCM_DYNWIND_H -/* Copyright (C) 1995,1996,1998,1999,2000,2003,2004, 2006, 2008, 2011 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1998,1999,2000,2003,2004, 2006, 2008, 2011, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -24,25 +24,22 @@ #include "libguile/__scm.h" +#include "libguile/dynstack.h" -typedef void (*scm_t_guard) (void *); - SCM_API SCM scm_dynamic_wind (SCM thunk1, SCM thunk2, SCM thunk3); -SCM_API void scm_dowinds (SCM to, long delta); -SCM_INTERNAL void scm_i_dowinds (SCM to, long delta, - void (*turn_func) (void *), void *data); + SCM_INTERNAL void scm_init_dynwind (void); SCM_API void scm_swap_bindings (SCM vars, SCM vals); typedef enum { - SCM_F_DYNWIND_REWINDABLE = (1 << 0) + SCM_F_DYNWIND_REWINDABLE = SCM_F_DYNSTACK_FRAME_REWINDABLE } scm_t_dynwind_flags; typedef enum { - SCM_F_WIND_EXPLICITLY = (1 << 0) + SCM_F_WIND_EXPLICITLY = SCM_F_DYNSTACK_WINDER_EXPLICIT } scm_t_wind_flags; SCM_API void scm_dynwind_begin (scm_t_dynwind_flags); @@ -60,9 +57,6 @@ SCM_API void scm_dynwind_rewind_handler_with_scm (void (*func) (SCM), SCM data, SCM_API void scm_dynwind_free (void *mem); -#ifdef GUILE_DEBUG -SCM_API SCM scm_wind_chain (void); -#endif /*GUILE_DEBUG*/ #endif /* SCM_DYNWIND_H */ diff --git a/libguile/elf.h b/libguile/elf.h new file mode 100644 index 000000000..9d537215b --- /dev/null +++ b/libguile/elf.h @@ -0,0 +1,2794 @@ +/* This file defines standard ELF types, structures, and macros. + Copyright (C) 1995-2003,2004,2005,2006,2007,2008,2009,2010 + Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#ifndef _ELF_H +#define _ELF_H 1 + +/* Standard ELF types. */ + +#include <stdint.h> + +/* Type for a 16-bit quantity. */ +typedef uint16_t Elf32_Half; +typedef uint16_t Elf64_Half; + +/* Types for signed and unsigned 32-bit quantities. */ +typedef uint32_t Elf32_Word; +typedef int32_t Elf32_Sword; +typedef uint32_t Elf64_Word; +typedef int32_t Elf64_Sword; + +/* Types for signed and unsigned 64-bit quantities. */ +typedef uint64_t Elf32_Xword; +typedef int64_t Elf32_Sxword; +typedef uint64_t Elf64_Xword; +typedef int64_t Elf64_Sxword; + +/* Type of addresses. */ +typedef uint32_t Elf32_Addr; +typedef uint64_t Elf64_Addr; + +/* Type of file offsets. */ +typedef uint32_t Elf32_Off; +typedef uint64_t Elf64_Off; + +/* Type for section indices, which are 16-bit quantities. */ +typedef uint16_t Elf32_Section; +typedef uint16_t Elf64_Section; + +/* Type for version symbol information. */ +typedef Elf32_Half Elf32_Versym; +typedef Elf64_Half Elf64_Versym; + + +/* The ELF file header. This appears at the start of every ELF file. */ + +#define EI_NIDENT (16) + +typedef struct +{ + unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */ + Elf32_Half e_type; /* Object file type */ + Elf32_Half e_machine; /* Architecture */ + Elf32_Word e_version; /* Object file version */ + Elf32_Addr e_entry; /* Entry point virtual address */ + Elf32_Off e_phoff; /* Program header table file offset */ + Elf32_Off e_shoff; /* Section header table file offset */ + Elf32_Word e_flags; /* Processor-specific flags */ + Elf32_Half e_ehsize; /* ELF header size in bytes */ + Elf32_Half e_phentsize; /* Program header table entry size */ + Elf32_Half e_phnum; /* Program header table entry count */ + Elf32_Half e_shentsize; /* Section header table entry size */ + Elf32_Half e_shnum; /* Section header table entry count */ + Elf32_Half e_shstrndx; /* Section header string table index */ +} Elf32_Ehdr; + +typedef struct +{ + unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */ + Elf64_Half e_type; /* Object file type */ + Elf64_Half e_machine; /* Architecture */ + Elf64_Word e_version; /* Object file version */ + Elf64_Addr e_entry; /* Entry point virtual address */ + Elf64_Off e_phoff; /* Program header table file offset */ + Elf64_Off e_shoff; /* Section header table file offset */ + Elf64_Word e_flags; /* Processor-specific flags */ + Elf64_Half e_ehsize; /* ELF header size in bytes */ + Elf64_Half e_phentsize; /* Program header table entry size */ + Elf64_Half e_phnum; /* Program header table entry count */ + Elf64_Half e_shentsize; /* Section header table entry size */ + Elf64_Half e_shnum; /* Section header table entry count */ + Elf64_Half e_shstrndx; /* Section header string table index */ +} Elf64_Ehdr; + +/* Fields in the e_ident array. The EI_* macros are indices into the + array. The macros under each EI_* macro are the values the byte + may have. */ + +#define EI_MAG0 0 /* File identification byte 0 index */ +#define ELFMAG0 0x7f /* Magic number byte 0 */ + +#define EI_MAG1 1 /* File identification byte 1 index */ +#define ELFMAG1 'E' /* Magic number byte 1 */ + +#define EI_MAG2 2 /* File identification byte 2 index */ +#define ELFMAG2 'L' /* Magic number byte 2 */ + +#define EI_MAG3 3 /* File identification byte 3 index */ +#define ELFMAG3 'F' /* Magic number byte 3 */ + +/* Conglomeration of the identification bytes, for easy testing as a word. */ +#define ELFMAG "\177ELF" +#define SELFMAG 4 + +#define EI_CLASS 4 /* File class byte index */ +#define ELFCLASSNONE 0 /* Invalid class */ +#define ELFCLASS32 1 /* 32-bit objects */ +#define ELFCLASS64 2 /* 64-bit objects */ +#define ELFCLASSNUM 3 + +#define EI_DATA 5 /* Data encoding byte index */ +#define ELFDATANONE 0 /* Invalid data encoding */ +#define ELFDATA2LSB 1 /* 2's complement, little endian */ +#define ELFDATA2MSB 2 /* 2's complement, big endian */ +#define ELFDATANUM 3 + +#define EI_VERSION 6 /* File version byte index */ + /* Value must be EV_CURRENT */ + +#define EI_OSABI 7 /* OS ABI identification */ +#define ELFOSABI_NONE 0 /* UNIX System V ABI */ +#define ELFOSABI_SYSV 0 /* Alias. */ +#define ELFOSABI_HPUX 1 /* HP-UX */ +#define ELFOSABI_NETBSD 2 /* NetBSD. */ +#define ELFOSABI_GNU 3 /* GNU. */ +#define ELFOSABI_LINUX 3 /* Alias for ELFOSABI_GNU. */ +#define ELFOSABI_SOLARIS 6 /* Sun Solaris. */ +#define ELFOSABI_AIX 7 /* IBM AIX. */ +#define ELFOSABI_IRIX 8 /* SGI Irix. */ +#define ELFOSABI_FREEBSD 9 /* FreeBSD. */ +#define ELFOSABI_TRU64 10 /* Compaq TRU64 UNIX. */ +#define ELFOSABI_MODESTO 11 /* Novell Modesto. */ +#define ELFOSABI_OPENBSD 12 /* OpenBSD. */ +#define ELFOSABI_ARM_AEABI 64 /* ARM EABI */ +#define ELFOSABI_ARM 97 /* ARM */ +#define ELFOSABI_STANDALONE 255 /* Standalone (embedded) application */ + +#define EI_ABIVERSION 8 /* ABI version */ + +#define EI_PAD 9 /* Byte index of padding bytes */ + +/* Legal values for e_type (object file type). */ + +#define ET_NONE 0 /* No file type */ +#define ET_REL 1 /* Relocatable file */ +#define ET_EXEC 2 /* Executable file */ +#define ET_DYN 3 /* Shared object file */ +#define ET_CORE 4 /* Core file */ +#define ET_NUM 5 /* Number of defined types */ +#define ET_LOOS 0xfe00 /* OS-specific range start */ +#define ET_HIOS 0xfeff /* OS-specific range end */ +#define ET_LOPROC 0xff00 /* Processor-specific range start */ +#define ET_HIPROC 0xffff /* Processor-specific range end */ + +/* Legal values for e_machine (architecture). */ + +#define EM_NONE 0 /* No machine */ +#define EM_M32 1 /* AT&T WE 32100 */ +#define EM_SPARC 2 /* SUN SPARC */ +#define EM_386 3 /* Intel 80386 */ +#define EM_68K 4 /* Motorola m68k family */ +#define EM_88K 5 /* Motorola m88k family */ +#define EM_860 7 /* Intel 80860 */ +#define EM_MIPS 8 /* MIPS R3000 big-endian */ +#define EM_S370 9 /* IBM System/370 */ +#define EM_MIPS_RS3_LE 10 /* MIPS R3000 little-endian */ + +#define EM_PARISC 15 /* HPPA */ +#define EM_VPP500 17 /* Fujitsu VPP500 */ +#define EM_SPARC32PLUS 18 /* Sun's "v8plus" */ +#define EM_960 19 /* Intel 80960 */ +#define EM_PPC 20 /* PowerPC */ +#define EM_PPC64 21 /* PowerPC 64-bit */ +#define EM_S390 22 /* IBM S390 */ + +#define EM_V800 36 /* NEC V800 series */ +#define EM_FR20 37 /* Fujitsu FR20 */ +#define EM_RH32 38 /* TRW RH-32 */ +#define EM_RCE 39 /* Motorola RCE */ +#define EM_ARM 40 /* ARM */ +#define EM_FAKE_ALPHA 41 /* Digital Alpha */ +#define EM_SH 42 /* Hitachi SH */ +#define EM_SPARCV9 43 /* SPARC v9 64-bit */ +#define EM_TRICORE 44 /* Siemens Tricore */ +#define EM_ARC 45 /* Argonaut RISC Core */ +#define EM_H8_300 46 /* Hitachi H8/300 */ +#define EM_H8_300H 47 /* Hitachi H8/300H */ +#define EM_H8S 48 /* Hitachi H8S */ +#define EM_H8_500 49 /* Hitachi H8/500 */ +#define EM_IA_64 50 /* Intel Merced */ +#define EM_MIPS_X 51 /* Stanford MIPS-X */ +#define EM_COLDFIRE 52 /* Motorola Coldfire */ +#define EM_68HC12 53 /* Motorola M68HC12 */ +#define EM_MMA 54 /* Fujitsu MMA Multimedia Accelerator*/ +#define EM_PCP 55 /* Siemens PCP */ +#define EM_NCPU 56 /* Sony nCPU embeeded RISC */ +#define EM_NDR1 57 /* Denso NDR1 microprocessor */ +#define EM_STARCORE 58 /* Motorola Start*Core processor */ +#define EM_ME16 59 /* Toyota ME16 processor */ +#define EM_ST100 60 /* STMicroelectronic ST100 processor */ +#define EM_TINYJ 61 /* Advanced Logic Corp. Tinyj emb.fam*/ +#define EM_X86_64 62 /* AMD x86-64 architecture */ +#define EM_PDSP 63 /* Sony DSP Processor */ + +#define EM_FX66 66 /* Siemens FX66 microcontroller */ +#define EM_ST9PLUS 67 /* STMicroelectronics ST9+ 8/16 mc */ +#define EM_ST7 68 /* STmicroelectronics ST7 8 bit mc */ +#define EM_68HC16 69 /* Motorola MC68HC16 microcontroller */ +#define EM_68HC11 70 /* Motorola MC68HC11 microcontroller */ +#define EM_68HC08 71 /* Motorola MC68HC08 microcontroller */ +#define EM_68HC05 72 /* Motorola MC68HC05 microcontroller */ +#define EM_SVX 73 /* Silicon Graphics SVx */ +#define EM_ST19 74 /* STMicroelectronics ST19 8 bit mc */ +#define EM_VAX 75 /* Digital VAX */ +#define EM_CRIS 76 /* Axis Communications 32-bit embedded processor */ +#define EM_JAVELIN 77 /* Infineon Technologies 32-bit embedded processor */ +#define EM_FIREPATH 78 /* Element 14 64-bit DSP Processor */ +#define EM_ZSP 79 /* LSI Logic 16-bit DSP Processor */ +#define EM_MMIX 80 /* Donald Knuth's educational 64-bit processor */ +#define EM_HUANY 81 /* Harvard University machine-independent object files */ +#define EM_PRISM 82 /* SiTera Prism */ +#define EM_AVR 83 /* Atmel AVR 8-bit microcontroller */ +#define EM_FR30 84 /* Fujitsu FR30 */ +#define EM_D10V 85 /* Mitsubishi D10V */ +#define EM_D30V 86 /* Mitsubishi D30V */ +#define EM_V850 87 /* NEC v850 */ +#define EM_M32R 88 /* Mitsubishi M32R */ +#define EM_MN10300 89 /* Matsushita MN10300 */ +#define EM_MN10200 90 /* Matsushita MN10200 */ +#define EM_PJ 91 /* picoJava */ +#define EM_OPENRISC 92 /* OpenRISC 32-bit embedded processor */ +#define EM_ARC_A5 93 /* ARC Cores Tangent-A5 */ +#define EM_XTENSA 94 /* Tensilica Xtensa Architecture */ +#define EM_NUM 95 + +/* If it is necessary to assign new unofficial EM_* values, please + pick large random numbers (0x8523, 0xa7f2, etc.) to minimize the + chances of collision with official or non-GNU unofficial values. */ + +#define EM_ALPHA 0x9026 + +/* Legal values for e_version (version). */ + +#define EV_NONE 0 /* Invalid ELF version */ +#define EV_CURRENT 1 /* Current version */ +#define EV_NUM 2 + +/* Section header. */ + +typedef struct +{ + Elf32_Word sh_name; /* Section name (string tbl index) */ + Elf32_Word sh_type; /* Section type */ + Elf32_Word sh_flags; /* Section flags */ + Elf32_Addr sh_addr; /* Section virtual addr at execution */ + Elf32_Off sh_offset; /* Section file offset */ + Elf32_Word sh_size; /* Section size in bytes */ + Elf32_Word sh_link; /* Link to another section */ + Elf32_Word sh_info; /* Additional section information */ + Elf32_Word sh_addralign; /* Section alignment */ + Elf32_Word sh_entsize; /* Entry size if section holds table */ +} Elf32_Shdr; + +typedef struct +{ + Elf64_Word sh_name; /* Section name (string tbl index) */ + Elf64_Word sh_type; /* Section type */ + Elf64_Xword sh_flags; /* Section flags */ + Elf64_Addr sh_addr; /* Section virtual addr at execution */ + Elf64_Off sh_offset; /* Section file offset */ + Elf64_Xword sh_size; /* Section size in bytes */ + Elf64_Word sh_link; /* Link to another section */ + Elf64_Word sh_info; /* Additional section information */ + Elf64_Xword sh_addralign; /* Section alignment */ + Elf64_Xword sh_entsize; /* Entry size if section holds table */ +} Elf64_Shdr; + +/* Special section indices. */ + +#define SHN_UNDEF 0 /* Undefined section */ +#define SHN_LORESERVE 0xff00 /* Start of reserved indices */ +#define SHN_LOPROC 0xff00 /* Start of processor-specific */ +#define SHN_BEFORE 0xff00 /* Order section before all others + (Solaris). */ +#define SHN_AFTER 0xff01 /* Order section after all others + (Solaris). */ +#define SHN_HIPROC 0xff1f /* End of processor-specific */ +#define SHN_LOOS 0xff20 /* Start of OS-specific */ +#define SHN_HIOS 0xff3f /* End of OS-specific */ +#define SHN_ABS 0xfff1 /* Associated symbol is absolute */ +#define SHN_COMMON 0xfff2 /* Associated symbol is common */ +#define SHN_XINDEX 0xffff /* Index is in extra table. */ +#define SHN_HIRESERVE 0xffff /* End of reserved indices */ + +/* Legal values for sh_type (section type). */ + +#define SHT_NULL 0 /* Section header table entry unused */ +#define SHT_PROGBITS 1 /* Program data */ +#define SHT_SYMTAB 2 /* Symbol table */ +#define SHT_STRTAB 3 /* String table */ +#define SHT_RELA 4 /* Relocation entries with addends */ +#define SHT_HASH 5 /* Symbol hash table */ +#define SHT_DYNAMIC 6 /* Dynamic linking information */ +#define SHT_NOTE 7 /* Notes */ +#define SHT_NOBITS 8 /* Program space with no data (bss) */ +#define SHT_REL 9 /* Relocation entries, no addends */ +#define SHT_SHLIB 10 /* Reserved */ +#define SHT_DYNSYM 11 /* Dynamic linker symbol table */ +#define SHT_INIT_ARRAY 14 /* Array of constructors */ +#define SHT_FINI_ARRAY 15 /* Array of destructors */ +#define SHT_PREINIT_ARRAY 16 /* Array of pre-constructors */ +#define SHT_GROUP 17 /* Section group */ +#define SHT_SYMTAB_SHNDX 18 /* Extended section indeces */ +#define SHT_NUM 19 /* Number of defined types. */ +#define SHT_LOOS 0x60000000 /* Start OS-specific. */ +#define SHT_GNU_ATTRIBUTES 0x6ffffff5 /* Object attributes. */ +#define SHT_GNU_HASH 0x6ffffff6 /* GNU-style hash table. */ +#define SHT_GNU_LIBLIST 0x6ffffff7 /* Prelink library list */ +#define SHT_CHECKSUM 0x6ffffff8 /* Checksum for DSO content. */ +#define SHT_LOSUNW 0x6ffffffa /* Sun-specific low bound. */ +#define SHT_SUNW_move 0x6ffffffa +#define SHT_SUNW_COMDAT 0x6ffffffb +#define SHT_SUNW_syminfo 0x6ffffffc +#define SHT_GNU_verdef 0x6ffffffd /* Version definition section. */ +#define SHT_GNU_verneed 0x6ffffffe /* Version needs section. */ +#define SHT_GNU_versym 0x6fffffff /* Version symbol table. */ +#define SHT_HISUNW 0x6fffffff /* Sun-specific high bound. */ +#define SHT_HIOS 0x6fffffff /* End OS-specific type */ +#define SHT_LOPROC 0x70000000 /* Start of processor-specific */ +#define SHT_HIPROC 0x7fffffff /* End of processor-specific */ +#define SHT_LOUSER 0x80000000 /* Start of application-specific */ +#define SHT_HIUSER 0x8fffffff /* End of application-specific */ + +/* Legal values for sh_flags (section flags). */ + +#define SHF_WRITE (1 << 0) /* Writable */ +#define SHF_ALLOC (1 << 1) /* Occupies memory during execution */ +#define SHF_EXECINSTR (1 << 2) /* Executable */ +#define SHF_MERGE (1 << 4) /* Might be merged */ +#define SHF_STRINGS (1 << 5) /* Contains nul-terminated strings */ +#define SHF_INFO_LINK (1 << 6) /* `sh_info' contains SHT index */ +#define SHF_LINK_ORDER (1 << 7) /* Preserve order after combining */ +#define SHF_OS_NONCONFORMING (1 << 8) /* Non-standard OS specific handling + required */ +#define SHF_GROUP (1 << 9) /* Section is member of a group. */ +#define SHF_TLS (1 << 10) /* Section hold thread-local data. */ +#define SHF_MASKOS 0x0ff00000 /* OS-specific. */ +#define SHF_MASKPROC 0xf0000000 /* Processor-specific */ +#define SHF_ORDERED (1 << 30) /* Special ordering requirement + (Solaris). */ +#define SHF_EXCLUDE (1 << 31) /* Section is excluded unless + referenced or allocated (Solaris).*/ + +/* Section group handling. */ +#define GRP_COMDAT 0x1 /* Mark group as COMDAT. */ + +/* Symbol table entry. */ + +typedef struct +{ + Elf32_Word st_name; /* Symbol name (string tbl index) */ + Elf32_Addr st_value; /* Symbol value */ + Elf32_Word st_size; /* Symbol size */ + unsigned char st_info; /* Symbol type and binding */ + unsigned char st_other; /* Symbol visibility */ + Elf32_Section st_shndx; /* Section index */ +} Elf32_Sym; + +typedef struct +{ + Elf64_Word st_name; /* Symbol name (string tbl index) */ + unsigned char st_info; /* Symbol type and binding */ + unsigned char st_other; /* Symbol visibility */ + Elf64_Section st_shndx; /* Section index */ + Elf64_Addr st_value; /* Symbol value */ + Elf64_Xword st_size; /* Symbol size */ +} Elf64_Sym; + +/* The syminfo section if available contains additional information about + every dynamic symbol. */ + +typedef struct +{ + Elf32_Half si_boundto; /* Direct bindings, symbol bound to */ + Elf32_Half si_flags; /* Per symbol flags */ +} Elf32_Syminfo; + +typedef struct +{ + Elf64_Half si_boundto; /* Direct bindings, symbol bound to */ + Elf64_Half si_flags; /* Per symbol flags */ +} Elf64_Syminfo; + +/* Possible values for si_boundto. */ +#define SYMINFO_BT_SELF 0xffff /* Symbol bound to self */ +#define SYMINFO_BT_PARENT 0xfffe /* Symbol bound to parent */ +#define SYMINFO_BT_LOWRESERVE 0xff00 /* Beginning of reserved entries */ + +/* Possible bitmasks for si_flags. */ +#define SYMINFO_FLG_DIRECT 0x0001 /* Direct bound symbol */ +#define SYMINFO_FLG_PASSTHRU 0x0002 /* Pass-thru symbol for translator */ +#define SYMINFO_FLG_COPY 0x0004 /* Symbol is a copy-reloc */ +#define SYMINFO_FLG_LAZYLOAD 0x0008 /* Symbol bound to object to be lazy + loaded */ +/* Syminfo version values. */ +#define SYMINFO_NONE 0 +#define SYMINFO_CURRENT 1 +#define SYMINFO_NUM 2 + + +/* How to extract and insert information held in the st_info field. */ + +#define ELF32_ST_BIND(val) (((unsigned char) (val)) >> 4) +#define ELF32_ST_TYPE(val) ((val) & 0xf) +#define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf)) + +/* Both Elf32_Sym and Elf64_Sym use the same one-byte st_info field. */ +#define ELF64_ST_BIND(val) ELF32_ST_BIND (val) +#define ELF64_ST_TYPE(val) ELF32_ST_TYPE (val) +#define ELF64_ST_INFO(bind, type) ELF32_ST_INFO ((bind), (type)) + +/* Legal values for ST_BIND subfield of st_info (symbol binding). */ + +#define STB_LOCAL 0 /* Local symbol */ +#define STB_GLOBAL 1 /* Global symbol */ +#define STB_WEAK 2 /* Weak symbol */ +#define STB_NUM 3 /* Number of defined types. */ +#define STB_LOOS 10 /* Start of OS-specific */ +#define STB_GNU_UNIQUE 10 /* Unique symbol. */ +#define STB_HIOS 12 /* End of OS-specific */ +#define STB_LOPROC 13 /* Start of processor-specific */ +#define STB_HIPROC 15 /* End of processor-specific */ + +/* Legal values for ST_TYPE subfield of st_info (symbol type). */ + +#define STT_NOTYPE 0 /* Symbol type is unspecified */ +#define STT_OBJECT 1 /* Symbol is a data object */ +#define STT_FUNC 2 /* Symbol is a code object */ +#define STT_SECTION 3 /* Symbol associated with a section */ +#define STT_FILE 4 /* Symbol's name is file name */ +#define STT_COMMON 5 /* Symbol is a common data object */ +#define STT_TLS 6 /* Symbol is thread-local data object*/ +#define STT_NUM 7 /* Number of defined types. */ +#define STT_LOOS 10 /* Start of OS-specific */ +#define STT_GNU_IFUNC 10 /* Symbol is indirect code object */ +#define STT_HIOS 12 /* End of OS-specific */ +#define STT_LOPROC 13 /* Start of processor-specific */ +#define STT_HIPROC 15 /* End of processor-specific */ + + +/* Symbol table indices are found in the hash buckets and chain table + of a symbol hash table section. This special index value indicates + the end of a chain, meaning no further symbols are found in that bucket. */ + +#define STN_UNDEF 0 /* End of a chain. */ + + +/* How to extract and insert information held in the st_other field. */ + +#define ELF32_ST_VISIBILITY(o) ((o) & 0x03) + +/* For ELF64 the definitions are the same. */ +#define ELF64_ST_VISIBILITY(o) ELF32_ST_VISIBILITY (o) + +/* Symbol visibility specification encoded in the st_other field. */ +#define STV_DEFAULT 0 /* Default symbol visibility rules */ +#define STV_INTERNAL 1 /* Processor specific hidden class */ +#define STV_HIDDEN 2 /* Sym unavailable in other modules */ +#define STV_PROTECTED 3 /* Not preemptible, not exported */ + + +/* Relocation table entry without addend (in section of type SHT_REL). */ + +typedef struct +{ + Elf32_Addr r_offset; /* Address */ + Elf32_Word r_info; /* Relocation type and symbol index */ +} Elf32_Rel; + +/* I have seen two different definitions of the Elf64_Rel and + Elf64_Rela structures, so we'll leave them out until Novell (or + whoever) gets their act together. */ +/* The following, at least, is used on Sparc v9, MIPS, and Alpha. */ + +typedef struct +{ + Elf64_Addr r_offset; /* Address */ + Elf64_Xword r_info; /* Relocation type and symbol index */ +} Elf64_Rel; + +/* Relocation table entry with addend (in section of type SHT_RELA). */ + +typedef struct +{ + Elf32_Addr r_offset; /* Address */ + Elf32_Word r_info; /* Relocation type and symbol index */ + Elf32_Sword r_addend; /* Addend */ +} Elf32_Rela; + +typedef struct +{ + Elf64_Addr r_offset; /* Address */ + Elf64_Xword r_info; /* Relocation type and symbol index */ + Elf64_Sxword r_addend; /* Addend */ +} Elf64_Rela; + +/* How to extract and insert information held in the r_info field. */ + +#define ELF32_R_SYM(val) ((val) >> 8) +#define ELF32_R_TYPE(val) ((val) & 0xff) +#define ELF32_R_INFO(sym, type) (((sym) << 8) + ((type) & 0xff)) + +#define ELF64_R_SYM(i) ((i) >> 32) +#define ELF64_R_TYPE(i) ((i) & 0xffffffff) +#define ELF64_R_INFO(sym,type) ((((Elf64_Xword) (sym)) << 32) + (type)) + +/* Program segment header. */ + +typedef struct +{ + Elf32_Word p_type; /* Segment type */ + Elf32_Off p_offset; /* Segment file offset */ + Elf32_Addr p_vaddr; /* Segment virtual address */ + Elf32_Addr p_paddr; /* Segment physical address */ + Elf32_Word p_filesz; /* Segment size in file */ + Elf32_Word p_memsz; /* Segment size in memory */ + Elf32_Word p_flags; /* Segment flags */ + Elf32_Word p_align; /* Segment alignment */ +} Elf32_Phdr; + +typedef struct +{ + Elf64_Word p_type; /* Segment type */ + Elf64_Word p_flags; /* Segment flags */ + Elf64_Off p_offset; /* Segment file offset */ + Elf64_Addr p_vaddr; /* Segment virtual address */ + Elf64_Addr p_paddr; /* Segment physical address */ + Elf64_Xword p_filesz; /* Segment size in file */ + Elf64_Xword p_memsz; /* Segment size in memory */ + Elf64_Xword p_align; /* Segment alignment */ +} Elf64_Phdr; + +/* Special value for e_phnum. This indicates that the real number of + program headers is too large to fit into e_phnum. Instead the real + value is in the field sh_info of section 0. */ + +#define PN_XNUM 0xffff + +/* Legal values for p_type (segment type). */ + +#define PT_NULL 0 /* Program header table entry unused */ +#define PT_LOAD 1 /* Loadable program segment */ +#define PT_DYNAMIC 2 /* Dynamic linking information */ +#define PT_INTERP 3 /* Program interpreter */ +#define PT_NOTE 4 /* Auxiliary information */ +#define PT_SHLIB 5 /* Reserved */ +#define PT_PHDR 6 /* Entry for header table itself */ +#define PT_TLS 7 /* Thread-local storage segment */ +#define PT_NUM 8 /* Number of defined types */ +#define PT_LOOS 0x60000000 /* Start of OS-specific */ +#define PT_GNU_EH_FRAME 0x6474e550 /* GCC .eh_frame_hdr segment */ +#define PT_GNU_STACK 0x6474e551 /* Indicates stack executability */ +#define PT_GNU_RELRO 0x6474e552 /* Read-only after relocation */ +#define PT_LOSUNW 0x6ffffffa +#define PT_SUNWBSS 0x6ffffffa /* Sun Specific segment */ +#define PT_SUNWSTACK 0x6ffffffb /* Stack segment */ +#define PT_HISUNW 0x6fffffff +#define PT_HIOS 0x6fffffff /* End of OS-specific */ +#define PT_LOPROC 0x70000000 /* Start of processor-specific */ +#define PT_HIPROC 0x7fffffff /* End of processor-specific */ + +/* Legal values for p_flags (segment flags). */ + +#define PF_X (1 << 0) /* Segment is executable */ +#define PF_W (1 << 1) /* Segment is writable */ +#define PF_R (1 << 2) /* Segment is readable */ +#define PF_MASKOS 0x0ff00000 /* OS-specific */ +#define PF_MASKPROC 0xf0000000 /* Processor-specific */ + +/* Legal values for note segment descriptor types for core files. */ + +#define NT_PRSTATUS 1 /* Contains copy of prstatus struct */ +#define NT_FPREGSET 2 /* Contains copy of fpregset struct */ +#define NT_PRPSINFO 3 /* Contains copy of prpsinfo struct */ +#define NT_PRXREG 4 /* Contains copy of prxregset struct */ +#define NT_TASKSTRUCT 4 /* Contains copy of task structure */ +#define NT_PLATFORM 5 /* String from sysinfo(SI_PLATFORM) */ +#define NT_AUXV 6 /* Contains copy of auxv array */ +#define NT_GWINDOWS 7 /* Contains copy of gwindows struct */ +#define NT_ASRS 8 /* Contains copy of asrset struct */ +#define NT_PSTATUS 10 /* Contains copy of pstatus struct */ +#define NT_PSINFO 13 /* Contains copy of psinfo struct */ +#define NT_PRCRED 14 /* Contains copy of prcred struct */ +#define NT_UTSNAME 15 /* Contains copy of utsname struct */ +#define NT_LWPSTATUS 16 /* Contains copy of lwpstatus struct */ +#define NT_LWPSINFO 17 /* Contains copy of lwpinfo struct */ +#define NT_PRFPXREG 20 /* Contains copy of fprxregset struct */ +#define NT_PRXFPREG 0x46e62b7f /* Contains copy of user_fxsr_struct */ +#define NT_PPC_VMX 0x100 /* PowerPC Altivec/VMX registers */ +#define NT_PPC_SPE 0x101 /* PowerPC SPE/EVR registers */ +#define NT_PPC_VSX 0x102 /* PowerPC VSX registers */ +#define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ +#define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ +#define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ + +/* Legal values for the note segment descriptor types for object files. */ + +#define NT_VERSION 1 /* Contains a version string. */ + + +/* Dynamic section entry. */ + +typedef struct +{ + Elf32_Sword d_tag; /* Dynamic entry type */ + union + { + Elf32_Word d_val; /* Integer value */ + Elf32_Addr d_ptr; /* Address value */ + } d_un; +} Elf32_Dyn; + +typedef struct +{ + Elf64_Sxword d_tag; /* Dynamic entry type */ + union + { + Elf64_Xword d_val; /* Integer value */ + Elf64_Addr d_ptr; /* Address value */ + } d_un; +} Elf64_Dyn; + +/* Legal values for d_tag (dynamic entry type). */ + +#define DT_NULL 0 /* Marks end of dynamic section */ +#define DT_NEEDED 1 /* Name of needed library */ +#define DT_PLTRELSZ 2 /* Size in bytes of PLT relocs */ +#define DT_PLTGOT 3 /* Processor defined value */ +#define DT_HASH 4 /* Address of symbol hash table */ +#define DT_STRTAB 5 /* Address of string table */ +#define DT_SYMTAB 6 /* Address of symbol table */ +#define DT_RELA 7 /* Address of Rela relocs */ +#define DT_RELASZ 8 /* Total size of Rela relocs */ +#define DT_RELAENT 9 /* Size of one Rela reloc */ +#define DT_STRSZ 10 /* Size of string table */ +#define DT_SYMENT 11 /* Size of one symbol table entry */ +#define DT_INIT 12 /* Address of init function */ +#define DT_FINI 13 /* Address of termination function */ +#define DT_SONAME 14 /* Name of shared object */ +#define DT_RPATH 15 /* Library search path (deprecated) */ +#define DT_SYMBOLIC 16 /* Start symbol search here */ +#define DT_REL 17 /* Address of Rel relocs */ +#define DT_RELSZ 18 /* Total size of Rel relocs */ +#define DT_RELENT 19 /* Size of one Rel reloc */ +#define DT_PLTREL 20 /* Type of reloc in PLT */ +#define DT_DEBUG 21 /* For debugging; unspecified */ +#define DT_TEXTREL 22 /* Reloc might modify .text */ +#define DT_JMPREL 23 /* Address of PLT relocs */ +#define DT_BIND_NOW 24 /* Process relocations of object */ +#define DT_INIT_ARRAY 25 /* Array with addresses of init fct */ +#define DT_FINI_ARRAY 26 /* Array with addresses of fini fct */ +#define DT_INIT_ARRAYSZ 27 /* Size in bytes of DT_INIT_ARRAY */ +#define DT_FINI_ARRAYSZ 28 /* Size in bytes of DT_FINI_ARRAY */ +#define DT_RUNPATH 29 /* Library search path */ +#define DT_FLAGS 30 /* Flags for the object being loaded */ +#define DT_ENCODING 32 /* Start of encoded range */ +#define DT_PREINIT_ARRAY 32 /* Array with addresses of preinit fct*/ +#define DT_PREINIT_ARRAYSZ 33 /* size in bytes of DT_PREINIT_ARRAY */ +#define DT_NUM 34 /* Number used */ +#define DT_LOOS 0x6000000d /* Start of OS-specific */ +#define DT_HIOS 0x6ffff000 /* End of OS-specific */ +#define DT_LOPROC 0x70000000 /* Start of processor-specific */ +#define DT_HIPROC 0x7fffffff /* End of processor-specific */ +#define DT_PROCNUM DT_MIPS_NUM /* Most used by any processor */ + +/* DT_* entries which fall between DT_VALRNGHI & DT_VALRNGLO use the + Dyn.d_un.d_val field of the Elf*_Dyn structure. This follows Sun's + approach. */ +#define DT_VALRNGLO 0x6ffffd00 +#define DT_GNU_PRELINKED 0x6ffffdf5 /* Prelinking timestamp */ +#define DT_GNU_CONFLICTSZ 0x6ffffdf6 /* Size of conflict section */ +#define DT_GNU_LIBLISTSZ 0x6ffffdf7 /* Size of library list */ +#define DT_CHECKSUM 0x6ffffdf8 +#define DT_PLTPADSZ 0x6ffffdf9 +#define DT_MOVEENT 0x6ffffdfa +#define DT_MOVESZ 0x6ffffdfb +#define DT_FEATURE_1 0x6ffffdfc /* Feature selection (DTF_*). */ +#define DT_POSFLAG_1 0x6ffffdfd /* Flags for DT_* entries, effecting + the following DT_* entry. */ +#define DT_SYMINSZ 0x6ffffdfe /* Size of syminfo table (in bytes) */ +#define DT_SYMINENT 0x6ffffdff /* Entry size of syminfo */ +#define DT_VALRNGHI 0x6ffffdff +#define DT_VALTAGIDX(tag) (DT_VALRNGHI - (tag)) /* Reverse order! */ +#define DT_VALNUM 12 + +/* DT_* entries which fall between DT_ADDRRNGHI & DT_ADDRRNGLO use the + Dyn.d_un.d_ptr field of the Elf*_Dyn structure. + + If any adjustment is made to the ELF object after it has been + built these entries will need to be adjusted. */ +#define DT_ADDRRNGLO 0x6ffffe00 +#define DT_GNU_HASH 0x6ffffef5 /* GNU-style hash table. */ +#define DT_TLSDESC_PLT 0x6ffffef6 +#define DT_TLSDESC_GOT 0x6ffffef7 +#define DT_GNU_CONFLICT 0x6ffffef8 /* Start of conflict section */ +#define DT_GNU_LIBLIST 0x6ffffef9 /* Library list */ +#define DT_CONFIG 0x6ffffefa /* Configuration information. */ +#define DT_DEPAUDIT 0x6ffffefb /* Dependency auditing. */ +#define DT_AUDIT 0x6ffffefc /* Object auditing. */ +#define DT_PLTPAD 0x6ffffefd /* PLT padding. */ +#define DT_MOVETAB 0x6ffffefe /* Move table. */ +#define DT_SYMINFO 0x6ffffeff /* Syminfo table. */ +#define DT_ADDRRNGHI 0x6ffffeff +#define DT_ADDRTAGIDX(tag) (DT_ADDRRNGHI - (tag)) /* Reverse order! */ +#define DT_ADDRNUM 11 + +/* The versioning entry types. The next are defined as part of the + GNU extension. */ +#define DT_VERSYM 0x6ffffff0 + +#define DT_RELACOUNT 0x6ffffff9 +#define DT_RELCOUNT 0x6ffffffa + +/* These were chosen by Sun. */ +#define DT_FLAGS_1 0x6ffffffb /* State flags, see DF_1_* below. */ +#define DT_VERDEF 0x6ffffffc /* Address of version definition + table */ +#define DT_VERDEFNUM 0x6ffffffd /* Number of version definitions */ +#define DT_VERNEED 0x6ffffffe /* Address of table with needed + versions */ +#define DT_VERNEEDNUM 0x6fffffff /* Number of needed versions */ +#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */ +#define DT_VERSIONTAGNUM 16 + +/* Sun added these machine-independent extensions in the "processor-specific" + range. Be compatible. */ +#define DT_AUXILIARY 0x7ffffffd /* Shared object to load before self */ +#define DT_FILTER 0x7fffffff /* Shared object to get values from */ +#define DT_EXTRATAGIDX(tag) ((Elf32_Word)-((Elf32_Sword) (tag) <<1>>1)-1) +#define DT_EXTRANUM 3 + +/* Values of `d_un.d_val' in the DT_FLAGS entry. */ +#define DF_ORIGIN 0x00000001 /* Object may use DF_ORIGIN */ +#define DF_SYMBOLIC 0x00000002 /* Symbol resolutions starts here */ +#define DF_TEXTREL 0x00000004 /* Object contains text relocations */ +#define DF_BIND_NOW 0x00000008 /* No lazy binding for this object */ +#define DF_STATIC_TLS 0x00000010 /* Module uses the static TLS model */ + +/* State flags selectable in the `d_un.d_val' element of the DT_FLAGS_1 + entry in the dynamic section. */ +#define DF_1_NOW 0x00000001 /* Set RTLD_NOW for this object. */ +#define DF_1_GLOBAL 0x00000002 /* Set RTLD_GLOBAL for this object. */ +#define DF_1_GROUP 0x00000004 /* Set RTLD_GROUP for this object. */ +#define DF_1_NODELETE 0x00000008 /* Set RTLD_NODELETE for this object.*/ +#define DF_1_LOADFLTR 0x00000010 /* Trigger filtee loading at runtime.*/ +#define DF_1_INITFIRST 0x00000020 /* Set RTLD_INITFIRST for this object*/ +#define DF_1_NOOPEN 0x00000040 /* Set RTLD_NOOPEN for this object. */ +#define DF_1_ORIGIN 0x00000080 /* $ORIGIN must be handled. */ +#define DF_1_DIRECT 0x00000100 /* Direct binding enabled. */ +#define DF_1_TRANS 0x00000200 +#define DF_1_INTERPOSE 0x00000400 /* Object is used to interpose. */ +#define DF_1_NODEFLIB 0x00000800 /* Ignore default lib search path. */ +#define DF_1_NODUMP 0x00001000 /* Object can't be dldump'ed. */ +#define DF_1_CONFALT 0x00002000 /* Configuration alternative created.*/ +#define DF_1_ENDFILTEE 0x00004000 /* Filtee terminates filters search. */ +#define DF_1_DISPRELDNE 0x00008000 /* Disp reloc applied at build time. */ +#define DF_1_DISPRELPND 0x00010000 /* Disp reloc applied at run-time. */ + +/* Flags for the feature selection in DT_FEATURE_1. */ +#define DTF_1_PARINIT 0x00000001 +#define DTF_1_CONFEXP 0x00000002 + +/* Flags in the DT_POSFLAG_1 entry effecting only the next DT_* entry. */ +#define DF_P1_LAZYLOAD 0x00000001 /* Lazyload following object. */ +#define DF_P1_GROUPPERM 0x00000002 /* Symbols from next object are not + generally available. */ + +/* Version definition sections. */ + +typedef struct +{ + Elf32_Half vd_version; /* Version revision */ + Elf32_Half vd_flags; /* Version information */ + Elf32_Half vd_ndx; /* Version Index */ + Elf32_Half vd_cnt; /* Number of associated aux entries */ + Elf32_Word vd_hash; /* Version name hash value */ + Elf32_Word vd_aux; /* Offset in bytes to verdaux array */ + Elf32_Word vd_next; /* Offset in bytes to next verdef + entry */ +} Elf32_Verdef; + +typedef struct +{ + Elf64_Half vd_version; /* Version revision */ + Elf64_Half vd_flags; /* Version information */ + Elf64_Half vd_ndx; /* Version Index */ + Elf64_Half vd_cnt; /* Number of associated aux entries */ + Elf64_Word vd_hash; /* Version name hash value */ + Elf64_Word vd_aux; /* Offset in bytes to verdaux array */ + Elf64_Word vd_next; /* Offset in bytes to next verdef + entry */ +} Elf64_Verdef; + + +/* Legal values for vd_version (version revision). */ +#define VER_DEF_NONE 0 /* No version */ +#define VER_DEF_CURRENT 1 /* Current version */ +#define VER_DEF_NUM 2 /* Given version number */ + +/* Legal values for vd_flags (version information flags). */ +#define VER_FLG_BASE 0x1 /* Version definition of file itself */ +#define VER_FLG_WEAK 0x2 /* Weak version identifier */ + +/* Versym symbol index values. */ +#define VER_NDX_LOCAL 0 /* Symbol is local. */ +#define VER_NDX_GLOBAL 1 /* Symbol is global. */ +#define VER_NDX_LORESERVE 0xff00 /* Beginning of reserved entries. */ +#define VER_NDX_ELIMINATE 0xff01 /* Symbol is to be eliminated. */ + +/* Auxialiary version information. */ + +typedef struct +{ + Elf32_Word vda_name; /* Version or dependency names */ + Elf32_Word vda_next; /* Offset in bytes to next verdaux + entry */ +} Elf32_Verdaux; + +typedef struct +{ + Elf64_Word vda_name; /* Version or dependency names */ + Elf64_Word vda_next; /* Offset in bytes to next verdaux + entry */ +} Elf64_Verdaux; + + +/* Version dependency section. */ + +typedef struct +{ + Elf32_Half vn_version; /* Version of structure */ + Elf32_Half vn_cnt; /* Number of associated aux entries */ + Elf32_Word vn_file; /* Offset of filename for this + dependency */ + Elf32_Word vn_aux; /* Offset in bytes to vernaux array */ + Elf32_Word vn_next; /* Offset in bytes to next verneed + entry */ +} Elf32_Verneed; + +typedef struct +{ + Elf64_Half vn_version; /* Version of structure */ + Elf64_Half vn_cnt; /* Number of associated aux entries */ + Elf64_Word vn_file; /* Offset of filename for this + dependency */ + Elf64_Word vn_aux; /* Offset in bytes to vernaux array */ + Elf64_Word vn_next; /* Offset in bytes to next verneed + entry */ +} Elf64_Verneed; + + +/* Legal values for vn_version (version revision). */ +#define VER_NEED_NONE 0 /* No version */ +#define VER_NEED_CURRENT 1 /* Current version */ +#define VER_NEED_NUM 2 /* Given version number */ + +/* Auxiliary needed version information. */ + +typedef struct +{ + Elf32_Word vna_hash; /* Hash value of dependency name */ + Elf32_Half vna_flags; /* Dependency specific information */ + Elf32_Half vna_other; /* Unused */ + Elf32_Word vna_name; /* Dependency name string offset */ + Elf32_Word vna_next; /* Offset in bytes to next vernaux + entry */ +} Elf32_Vernaux; + +typedef struct +{ + Elf64_Word vna_hash; /* Hash value of dependency name */ + Elf64_Half vna_flags; /* Dependency specific information */ + Elf64_Half vna_other; /* Unused */ + Elf64_Word vna_name; /* Dependency name string offset */ + Elf64_Word vna_next; /* Offset in bytes to next vernaux + entry */ +} Elf64_Vernaux; + + +/* Legal values for vna_flags. */ +#define VER_FLG_WEAK 0x2 /* Weak version identifier */ + + +/* Auxiliary vector. */ + +/* This vector is normally only used by the program interpreter. The + usual definition in an ABI supplement uses the name auxv_t. The + vector is not usually defined in a standard <elf.h> file, but it + can't hurt. We rename it to avoid conflicts. The sizes of these + types are an arrangement between the exec server and the program + interpreter, so we don't fully specify them here. */ + +typedef struct +{ + uint32_t a_type; /* Entry type */ + union + { + uint32_t a_val; /* Integer value */ + /* We use to have pointer elements added here. We cannot do that, + though, since it does not work when using 32-bit definitions + on 64-bit platforms and vice versa. */ + } a_un; +} Elf32_auxv_t; + +typedef struct +{ + uint64_t a_type; /* Entry type */ + union + { + uint64_t a_val; /* Integer value */ + /* We use to have pointer elements added here. We cannot do that, + though, since it does not work when using 32-bit definitions + on 64-bit platforms and vice versa. */ + } a_un; +} Elf64_auxv_t; + +/* Legal values for a_type (entry type). */ + +#define AT_NULL 0 /* End of vector */ +#define AT_IGNORE 1 /* Entry should be ignored */ +#define AT_EXECFD 2 /* File descriptor of program */ +#define AT_PHDR 3 /* Program headers for program */ +#define AT_PHENT 4 /* Size of program header entry */ +#define AT_PHNUM 5 /* Number of program headers */ +#define AT_PAGESZ 6 /* System page size */ +#define AT_BASE 7 /* Base address of interpreter */ +#define AT_FLAGS 8 /* Flags */ +#define AT_ENTRY 9 /* Entry point of program */ +#define AT_NOTELF 10 /* Program is not ELF */ +#define AT_UID 11 /* Real uid */ +#define AT_EUID 12 /* Effective uid */ +#define AT_GID 13 /* Real gid */ +#define AT_EGID 14 /* Effective gid */ +#define AT_CLKTCK 17 /* Frequency of times() */ + +/* Some more special a_type values describing the hardware. */ +#define AT_PLATFORM 15 /* String identifying platform. */ +#define AT_HWCAP 16 /* Machine dependent hints about + processor capabilities. */ + +/* This entry gives some information about the FPU initialization + performed by the kernel. */ +#define AT_FPUCW 18 /* Used FPU control word. */ + +/* Cache block sizes. */ +#define AT_DCACHEBSIZE 19 /* Data cache block size. */ +#define AT_ICACHEBSIZE 20 /* Instruction cache block size. */ +#define AT_UCACHEBSIZE 21 /* Unified cache block size. */ + +/* A special ignored value for PPC, used by the kernel to control the + interpretation of the AUXV. Must be > 16. */ +#define AT_IGNOREPPC 22 /* Entry should be ignored. */ + +#define AT_SECURE 23 /* Boolean, was exec setuid-like? */ + +#define AT_BASE_PLATFORM 24 /* String identifying real platforms.*/ + +#define AT_RANDOM 25 /* Address of 16 random bytes. */ + +#define AT_EXECFN 31 /* Filename of executable. */ + +/* Pointer to the global system page used for system calls and other + nice things. */ +#define AT_SYSINFO 32 +#define AT_SYSINFO_EHDR 33 + +/* Shapes of the caches. Bits 0-3 contains associativity; bits 4-7 contains + log2 of line size; mask those to get cache size. */ +#define AT_L1I_CACHESHAPE 34 +#define AT_L1D_CACHESHAPE 35 +#define AT_L2_CACHESHAPE 36 +#define AT_L3_CACHESHAPE 37 + +/* Note section contents. Each entry in the note section begins with + a header of a fixed form. */ + +typedef struct +{ + Elf32_Word n_namesz; /* Length of the note's name. */ + Elf32_Word n_descsz; /* Length of the note's descriptor. */ + Elf32_Word n_type; /* Type of the note. */ +} Elf32_Nhdr; + +typedef struct +{ + Elf64_Word n_namesz; /* Length of the note's name. */ + Elf64_Word n_descsz; /* Length of the note's descriptor. */ + Elf64_Word n_type; /* Type of the note. */ +} Elf64_Nhdr; + +/* Known names of notes. */ + +/* Solaris entries in the note section have this name. */ +#define ELF_NOTE_SOLARIS "SUNW Solaris" + +/* Note entries for GNU systems have this name. */ +#define ELF_NOTE_GNU "GNU" + + +/* Defined types of notes for Solaris. */ + +/* Value of descriptor (one word) is desired pagesize for the binary. */ +#define ELF_NOTE_PAGESIZE_HINT 1 + + +/* Defined note types for GNU systems. */ + +/* ABI information. The descriptor consists of words: + word 0: OS descriptor + word 1: major version of the ABI + word 2: minor version of the ABI + word 3: subminor version of the ABI +*/ +#define NT_GNU_ABI_TAG 1 +#define ELF_NOTE_ABI NT_GNU_ABI_TAG /* Old name. */ + +/* Known OSes. These values can appear in word 0 of an + NT_GNU_ABI_TAG note section entry. */ +#define ELF_NOTE_OS_LINUX 0 +#define ELF_NOTE_OS_GNU 1 +#define ELF_NOTE_OS_SOLARIS2 2 +#define ELF_NOTE_OS_FREEBSD 3 + +/* Synthetic hwcap information. The descriptor begins with two words: + word 0: number of entries + word 1: bitmask of enabled entries + Then follow variable-length entries, one byte followed by a + '\0'-terminated hwcap name string. The byte gives the bit + number to test if enabled, (1U << bit) & bitmask. */ +#define NT_GNU_HWCAP 2 + +/* Build ID bits as generated by ld --build-id. + The descriptor consists of any nonzero number of bytes. */ +#define NT_GNU_BUILD_ID 3 + +/* Version note generated by GNU gold containing a version string. */ +#define NT_GNU_GOLD_VERSION 4 + + +/* Move records. */ +typedef struct +{ + Elf32_Xword m_value; /* Symbol value. */ + Elf32_Word m_info; /* Size and index. */ + Elf32_Word m_poffset; /* Symbol offset. */ + Elf32_Half m_repeat; /* Repeat count. */ + Elf32_Half m_stride; /* Stride info. */ +} Elf32_Move; + +typedef struct +{ + Elf64_Xword m_value; /* Symbol value. */ + Elf64_Xword m_info; /* Size and index. */ + Elf64_Xword m_poffset; /* Symbol offset. */ + Elf64_Half m_repeat; /* Repeat count. */ + Elf64_Half m_stride; /* Stride info. */ +} Elf64_Move; + +/* Macro to construct move records. */ +#define ELF32_M_SYM(info) ((info) >> 8) +#define ELF32_M_SIZE(info) ((unsigned char) (info)) +#define ELF32_M_INFO(sym, size) (((sym) << 8) + (unsigned char) (size)) + +#define ELF64_M_SYM(info) ELF32_M_SYM (info) +#define ELF64_M_SIZE(info) ELF32_M_SIZE (info) +#define ELF64_M_INFO(sym, size) ELF32_M_INFO (sym, size) + + +/* Motorola 68k specific definitions. */ + +/* Values for Elf32_Ehdr.e_flags. */ +#define EF_CPU32 0x00810000 + +/* m68k relocs. */ + +#define R_68K_NONE 0 /* No reloc */ +#define R_68K_32 1 /* Direct 32 bit */ +#define R_68K_16 2 /* Direct 16 bit */ +#define R_68K_8 3 /* Direct 8 bit */ +#define R_68K_PC32 4 /* PC relative 32 bit */ +#define R_68K_PC16 5 /* PC relative 16 bit */ +#define R_68K_PC8 6 /* PC relative 8 bit */ +#define R_68K_GOT32 7 /* 32 bit PC relative GOT entry */ +#define R_68K_GOT16 8 /* 16 bit PC relative GOT entry */ +#define R_68K_GOT8 9 /* 8 bit PC relative GOT entry */ +#define R_68K_GOT32O 10 /* 32 bit GOT offset */ +#define R_68K_GOT16O 11 /* 16 bit GOT offset */ +#define R_68K_GOT8O 12 /* 8 bit GOT offset */ +#define R_68K_PLT32 13 /* 32 bit PC relative PLT address */ +#define R_68K_PLT16 14 /* 16 bit PC relative PLT address */ +#define R_68K_PLT8 15 /* 8 bit PC relative PLT address */ +#define R_68K_PLT32O 16 /* 32 bit PLT offset */ +#define R_68K_PLT16O 17 /* 16 bit PLT offset */ +#define R_68K_PLT8O 18 /* 8 bit PLT offset */ +#define R_68K_COPY 19 /* Copy symbol at runtime */ +#define R_68K_GLOB_DAT 20 /* Create GOT entry */ +#define R_68K_JMP_SLOT 21 /* Create PLT entry */ +#define R_68K_RELATIVE 22 /* Adjust by program base */ +#define R_68K_TLS_GD32 25 /* 32 bit GOT offset for GD */ +#define R_68K_TLS_GD16 26 /* 16 bit GOT offset for GD */ +#define R_68K_TLS_GD8 27 /* 8 bit GOT offset for GD */ +#define R_68K_TLS_LDM32 28 /* 32 bit GOT offset for LDM */ +#define R_68K_TLS_LDM16 29 /* 16 bit GOT offset for LDM */ +#define R_68K_TLS_LDM8 30 /* 8 bit GOT offset for LDM */ +#define R_68K_TLS_LDO32 31 /* 32 bit module-relative offset */ +#define R_68K_TLS_LDO16 32 /* 16 bit module-relative offset */ +#define R_68K_TLS_LDO8 33 /* 8 bit module-relative offset */ +#define R_68K_TLS_IE32 34 /* 32 bit GOT offset for IE */ +#define R_68K_TLS_IE16 35 /* 16 bit GOT offset for IE */ +#define R_68K_TLS_IE8 36 /* 8 bit GOT offset for IE */ +#define R_68K_TLS_LE32 37 /* 32 bit offset relative to + static TLS block */ +#define R_68K_TLS_LE16 38 /* 16 bit offset relative to + static TLS block */ +#define R_68K_TLS_LE8 39 /* 8 bit offset relative to + static TLS block */ +#define R_68K_TLS_DTPMOD32 40 /* 32 bit module number */ +#define R_68K_TLS_DTPREL32 41 /* 32 bit module-relative offset */ +#define R_68K_TLS_TPREL32 42 /* 32 bit TP-relative offset */ +/* Keep this the last entry. */ +#define R_68K_NUM 43 + +/* Intel 80386 specific definitions. */ + +/* i386 relocs. */ + +#define R_386_NONE 0 /* No reloc */ +#define R_386_32 1 /* Direct 32 bit */ +#define R_386_PC32 2 /* PC relative 32 bit */ +#define R_386_GOT32 3 /* 32 bit GOT entry */ +#define R_386_PLT32 4 /* 32 bit PLT address */ +#define R_386_COPY 5 /* Copy symbol at runtime */ +#define R_386_GLOB_DAT 6 /* Create GOT entry */ +#define R_386_JMP_SLOT 7 /* Create PLT entry */ +#define R_386_RELATIVE 8 /* Adjust by program base */ +#define R_386_GOTOFF 9 /* 32 bit offset to GOT */ +#define R_386_GOTPC 10 /* 32 bit PC relative offset to GOT */ +#define R_386_32PLT 11 +#define R_386_TLS_TPOFF 14 /* Offset in static TLS block */ +#define R_386_TLS_IE 15 /* Address of GOT entry for static TLS + block offset */ +#define R_386_TLS_GOTIE 16 /* GOT entry for static TLS block + offset */ +#define R_386_TLS_LE 17 /* Offset relative to static TLS + block */ +#define R_386_TLS_GD 18 /* Direct 32 bit for GNU version of + general dynamic thread local data */ +#define R_386_TLS_LDM 19 /* Direct 32 bit for GNU version of + local dynamic thread local data + in LE code */ +#define R_386_16 20 +#define R_386_PC16 21 +#define R_386_8 22 +#define R_386_PC8 23 +#define R_386_TLS_GD_32 24 /* Direct 32 bit for general dynamic + thread local data */ +#define R_386_TLS_GD_PUSH 25 /* Tag for pushl in GD TLS code */ +#define R_386_TLS_GD_CALL 26 /* Relocation for call to + __tls_get_addr() */ +#define R_386_TLS_GD_POP 27 /* Tag for popl in GD TLS code */ +#define R_386_TLS_LDM_32 28 /* Direct 32 bit for local dynamic + thread local data in LE code */ +#define R_386_TLS_LDM_PUSH 29 /* Tag for pushl in LDM TLS code */ +#define R_386_TLS_LDM_CALL 30 /* Relocation for call to + __tls_get_addr() in LDM code */ +#define R_386_TLS_LDM_POP 31 /* Tag for popl in LDM TLS code */ +#define R_386_TLS_LDO_32 32 /* Offset relative to TLS block */ +#define R_386_TLS_IE_32 33 /* GOT entry for negated static TLS + block offset */ +#define R_386_TLS_LE_32 34 /* Negated offset relative to static + TLS block */ +#define R_386_TLS_DTPMOD32 35 /* ID of module containing symbol */ +#define R_386_TLS_DTPOFF32 36 /* Offset in TLS block */ +#define R_386_TLS_TPOFF32 37 /* Negated offset in static TLS block */ +/* 38? */ +#define R_386_TLS_GOTDESC 39 /* GOT offset for TLS descriptor. */ +#define R_386_TLS_DESC_CALL 40 /* Marker of call through TLS + descriptor for + relaxation. */ +#define R_386_TLS_DESC 41 /* TLS descriptor containing + pointer to code and to + argument, returning the TLS + offset for the symbol. */ +#define R_386_IRELATIVE 42 /* Adjust indirectly by program base */ +/* Keep this the last entry. */ +#define R_386_NUM 43 + +/* SUN SPARC specific definitions. */ + +/* Legal values for ST_TYPE subfield of st_info (symbol type). */ + +#define STT_SPARC_REGISTER 13 /* Global register reserved to app. */ + +/* Values for Elf64_Ehdr.e_flags. */ + +#define EF_SPARCV9_MM 3 +#define EF_SPARCV9_TSO 0 +#define EF_SPARCV9_PSO 1 +#define EF_SPARCV9_RMO 2 +#define EF_SPARC_LEDATA 0x800000 /* little endian data */ +#define EF_SPARC_EXT_MASK 0xFFFF00 +#define EF_SPARC_32PLUS 0x000100 /* generic V8+ features */ +#define EF_SPARC_SUN_US1 0x000200 /* Sun UltraSPARC1 extensions */ +#define EF_SPARC_HAL_R1 0x000400 /* HAL R1 extensions */ +#define EF_SPARC_SUN_US3 0x000800 /* Sun UltraSPARCIII extensions */ + +/* SPARC relocs. */ + +#define R_SPARC_NONE 0 /* No reloc */ +#define R_SPARC_8 1 /* Direct 8 bit */ +#define R_SPARC_16 2 /* Direct 16 bit */ +#define R_SPARC_32 3 /* Direct 32 bit */ +#define R_SPARC_DISP8 4 /* PC relative 8 bit */ +#define R_SPARC_DISP16 5 /* PC relative 16 bit */ +#define R_SPARC_DISP32 6 /* PC relative 32 bit */ +#define R_SPARC_WDISP30 7 /* PC relative 30 bit shifted */ +#define R_SPARC_WDISP22 8 /* PC relative 22 bit shifted */ +#define R_SPARC_HI22 9 /* High 22 bit */ +#define R_SPARC_22 10 /* Direct 22 bit */ +#define R_SPARC_13 11 /* Direct 13 bit */ +#define R_SPARC_LO10 12 /* Truncated 10 bit */ +#define R_SPARC_GOT10 13 /* Truncated 10 bit GOT entry */ +#define R_SPARC_GOT13 14 /* 13 bit GOT entry */ +#define R_SPARC_GOT22 15 /* 22 bit GOT entry shifted */ +#define R_SPARC_PC10 16 /* PC relative 10 bit truncated */ +#define R_SPARC_PC22 17 /* PC relative 22 bit shifted */ +#define R_SPARC_WPLT30 18 /* 30 bit PC relative PLT address */ +#define R_SPARC_COPY 19 /* Copy symbol at runtime */ +#define R_SPARC_GLOB_DAT 20 /* Create GOT entry */ +#define R_SPARC_JMP_SLOT 21 /* Create PLT entry */ +#define R_SPARC_RELATIVE 22 /* Adjust by program base */ +#define R_SPARC_UA32 23 /* Direct 32 bit unaligned */ + +/* Additional Sparc64 relocs. */ + +#define R_SPARC_PLT32 24 /* Direct 32 bit ref to PLT entry */ +#define R_SPARC_HIPLT22 25 /* High 22 bit PLT entry */ +#define R_SPARC_LOPLT10 26 /* Truncated 10 bit PLT entry */ +#define R_SPARC_PCPLT32 27 /* PC rel 32 bit ref to PLT entry */ +#define R_SPARC_PCPLT22 28 /* PC rel high 22 bit PLT entry */ +#define R_SPARC_PCPLT10 29 /* PC rel trunc 10 bit PLT entry */ +#define R_SPARC_10 30 /* Direct 10 bit */ +#define R_SPARC_11 31 /* Direct 11 bit */ +#define R_SPARC_64 32 /* Direct 64 bit */ +#define R_SPARC_OLO10 33 /* 10bit with secondary 13bit addend */ +#define R_SPARC_HH22 34 /* Top 22 bits of direct 64 bit */ +#define R_SPARC_HM10 35 /* High middle 10 bits of ... */ +#define R_SPARC_LM22 36 /* Low middle 22 bits of ... */ +#define R_SPARC_PC_HH22 37 /* Top 22 bits of pc rel 64 bit */ +#define R_SPARC_PC_HM10 38 /* High middle 10 bit of ... */ +#define R_SPARC_PC_LM22 39 /* Low miggle 22 bits of ... */ +#define R_SPARC_WDISP16 40 /* PC relative 16 bit shifted */ +#define R_SPARC_WDISP19 41 /* PC relative 19 bit shifted */ +#define R_SPARC_GLOB_JMP 42 /* was part of v9 ABI but was removed */ +#define R_SPARC_7 43 /* Direct 7 bit */ +#define R_SPARC_5 44 /* Direct 5 bit */ +#define R_SPARC_6 45 /* Direct 6 bit */ +#define R_SPARC_DISP64 46 /* PC relative 64 bit */ +#define R_SPARC_PLT64 47 /* Direct 64 bit ref to PLT entry */ +#define R_SPARC_HIX22 48 /* High 22 bit complemented */ +#define R_SPARC_LOX10 49 /* Truncated 11 bit complemented */ +#define R_SPARC_H44 50 /* Direct high 12 of 44 bit */ +#define R_SPARC_M44 51 /* Direct mid 22 of 44 bit */ +#define R_SPARC_L44 52 /* Direct low 10 of 44 bit */ +#define R_SPARC_REGISTER 53 /* Global register usage */ +#define R_SPARC_UA64 54 /* Direct 64 bit unaligned */ +#define R_SPARC_UA16 55 /* Direct 16 bit unaligned */ +#define R_SPARC_TLS_GD_HI22 56 +#define R_SPARC_TLS_GD_LO10 57 +#define R_SPARC_TLS_GD_ADD 58 +#define R_SPARC_TLS_GD_CALL 59 +#define R_SPARC_TLS_LDM_HI22 60 +#define R_SPARC_TLS_LDM_LO10 61 +#define R_SPARC_TLS_LDM_ADD 62 +#define R_SPARC_TLS_LDM_CALL 63 +#define R_SPARC_TLS_LDO_HIX22 64 +#define R_SPARC_TLS_LDO_LOX10 65 +#define R_SPARC_TLS_LDO_ADD 66 +#define R_SPARC_TLS_IE_HI22 67 +#define R_SPARC_TLS_IE_LO10 68 +#define R_SPARC_TLS_IE_LD 69 +#define R_SPARC_TLS_IE_LDX 70 +#define R_SPARC_TLS_IE_ADD 71 +#define R_SPARC_TLS_LE_HIX22 72 +#define R_SPARC_TLS_LE_LOX10 73 +#define R_SPARC_TLS_DTPMOD32 74 +#define R_SPARC_TLS_DTPMOD64 75 +#define R_SPARC_TLS_DTPOFF32 76 +#define R_SPARC_TLS_DTPOFF64 77 +#define R_SPARC_TLS_TPOFF32 78 +#define R_SPARC_TLS_TPOFF64 79 +#define R_SPARC_GOTDATA_HIX22 80 +#define R_SPARC_GOTDATA_LOX10 81 +#define R_SPARC_GOTDATA_OP_HIX22 82 +#define R_SPARC_GOTDATA_OP_LOX10 83 +#define R_SPARC_GOTDATA_OP 84 +#define R_SPARC_H34 85 +#define R_SPARC_SIZE32 86 +#define R_SPARC_SIZE64 87 +#define R_SPARC_JMP_IREL 248 +#define R_SPARC_IRELATIVE 249 +#define R_SPARC_GNU_VTINHERIT 250 +#define R_SPARC_GNU_VTENTRY 251 +#define R_SPARC_REV32 252 +/* Keep this the last entry. */ +#define R_SPARC_NUM 253 + +/* For Sparc64, legal values for d_tag of Elf64_Dyn. */ + +#define DT_SPARC_REGISTER 0x70000001 +#define DT_SPARC_NUM 2 + +/* Bits present in AT_HWCAP on SPARC. */ + +#define HWCAP_SPARC_FLUSH 1 /* The CPU supports flush insn. */ +#define HWCAP_SPARC_STBAR 2 +#define HWCAP_SPARC_SWAP 4 +#define HWCAP_SPARC_MULDIV 8 +#define HWCAP_SPARC_V9 16 /* The CPU is v9, so v8plus is ok. */ +#define HWCAP_SPARC_ULTRA3 32 +#define HWCAP_SPARC_BLKINIT 64 /* Sun4v with block-init/load-twin. */ +#define HWCAP_SPARC_N2 128 + +/* MIPS R3000 specific definitions. */ + +/* Legal values for e_flags field of Elf32_Ehdr. */ + +#define EF_MIPS_NOREORDER 1 /* A .noreorder directive was used */ +#define EF_MIPS_PIC 2 /* Contains PIC code */ +#define EF_MIPS_CPIC 4 /* Uses PIC calling sequence */ +#define EF_MIPS_XGOT 8 +#define EF_MIPS_64BIT_WHIRL 16 +#define EF_MIPS_ABI2 32 +#define EF_MIPS_ABI_ON32 64 +#define EF_MIPS_ARCH 0xf0000000 /* MIPS architecture level */ + +/* Legal values for MIPS architecture level. */ + +#define EF_MIPS_ARCH_1 0x00000000 /* -mips1 code. */ +#define EF_MIPS_ARCH_2 0x10000000 /* -mips2 code. */ +#define EF_MIPS_ARCH_3 0x20000000 /* -mips3 code. */ +#define EF_MIPS_ARCH_4 0x30000000 /* -mips4 code. */ +#define EF_MIPS_ARCH_5 0x40000000 /* -mips5 code. */ +#define EF_MIPS_ARCH_32 0x60000000 /* MIPS32 code. */ +#define EF_MIPS_ARCH_64 0x70000000 /* MIPS64 code. */ + +/* The following are non-official names and should not be used. */ + +#define E_MIPS_ARCH_1 0x00000000 /* -mips1 code. */ +#define E_MIPS_ARCH_2 0x10000000 /* -mips2 code. */ +#define E_MIPS_ARCH_3 0x20000000 /* -mips3 code. */ +#define E_MIPS_ARCH_4 0x30000000 /* -mips4 code. */ +#define E_MIPS_ARCH_5 0x40000000 /* -mips5 code. */ +#define E_MIPS_ARCH_32 0x60000000 /* MIPS32 code. */ +#define E_MIPS_ARCH_64 0x70000000 /* MIPS64 code. */ + +/* Special section indices. */ + +#define SHN_MIPS_ACOMMON 0xff00 /* Allocated common symbols */ +#define SHN_MIPS_TEXT 0xff01 /* Allocated test symbols. */ +#define SHN_MIPS_DATA 0xff02 /* Allocated data symbols. */ +#define SHN_MIPS_SCOMMON 0xff03 /* Small common symbols */ +#define SHN_MIPS_SUNDEFINED 0xff04 /* Small undefined symbols */ + +/* Legal values for sh_type field of Elf32_Shdr. */ + +#define SHT_MIPS_LIBLIST 0x70000000 /* Shared objects used in link */ +#define SHT_MIPS_MSYM 0x70000001 +#define SHT_MIPS_CONFLICT 0x70000002 /* Conflicting symbols */ +#define SHT_MIPS_GPTAB 0x70000003 /* Global data area sizes */ +#define SHT_MIPS_UCODE 0x70000004 /* Reserved for SGI/MIPS compilers */ +#define SHT_MIPS_DEBUG 0x70000005 /* MIPS ECOFF debugging information*/ +#define SHT_MIPS_REGINFO 0x70000006 /* Register usage information */ +#define SHT_MIPS_PACKAGE 0x70000007 +#define SHT_MIPS_PACKSYM 0x70000008 +#define SHT_MIPS_RELD 0x70000009 +#define SHT_MIPS_IFACE 0x7000000b +#define SHT_MIPS_CONTENT 0x7000000c +#define SHT_MIPS_OPTIONS 0x7000000d /* Miscellaneous options. */ +#define SHT_MIPS_SHDR 0x70000010 +#define SHT_MIPS_FDESC 0x70000011 +#define SHT_MIPS_EXTSYM 0x70000012 +#define SHT_MIPS_DENSE 0x70000013 +#define SHT_MIPS_PDESC 0x70000014 +#define SHT_MIPS_LOCSYM 0x70000015 +#define SHT_MIPS_AUXSYM 0x70000016 +#define SHT_MIPS_OPTSYM 0x70000017 +#define SHT_MIPS_LOCSTR 0x70000018 +#define SHT_MIPS_LINE 0x70000019 +#define SHT_MIPS_RFDESC 0x7000001a +#define SHT_MIPS_DELTASYM 0x7000001b +#define SHT_MIPS_DELTAINST 0x7000001c +#define SHT_MIPS_DELTACLASS 0x7000001d +#define SHT_MIPS_DWARF 0x7000001e /* DWARF debugging information. */ +#define SHT_MIPS_DELTADECL 0x7000001f +#define SHT_MIPS_SYMBOL_LIB 0x70000020 +#define SHT_MIPS_EVENTS 0x70000021 /* Event section. */ +#define SHT_MIPS_TRANSLATE 0x70000022 +#define SHT_MIPS_PIXIE 0x70000023 +#define SHT_MIPS_XLATE 0x70000024 +#define SHT_MIPS_XLATE_DEBUG 0x70000025 +#define SHT_MIPS_WHIRL 0x70000026 +#define SHT_MIPS_EH_REGION 0x70000027 +#define SHT_MIPS_XLATE_OLD 0x70000028 +#define SHT_MIPS_PDR_EXCEPTION 0x70000029 + +/* Legal values for sh_flags field of Elf32_Shdr. */ + +#define SHF_MIPS_GPREL 0x10000000 /* Must be part of global data area */ +#define SHF_MIPS_MERGE 0x20000000 +#define SHF_MIPS_ADDR 0x40000000 +#define SHF_MIPS_STRINGS 0x80000000 +#define SHF_MIPS_NOSTRIP 0x08000000 +#define SHF_MIPS_LOCAL 0x04000000 +#define SHF_MIPS_NAMES 0x02000000 +#define SHF_MIPS_NODUPE 0x01000000 + + +/* Symbol tables. */ + +/* MIPS specific values for `st_other'. */ +#define STO_MIPS_DEFAULT 0x0 +#define STO_MIPS_INTERNAL 0x1 +#define STO_MIPS_HIDDEN 0x2 +#define STO_MIPS_PROTECTED 0x3 +#define STO_MIPS_PLT 0x8 +#define STO_MIPS_SC_ALIGN_UNUSED 0xff + +/* MIPS specific values for `st_info'. */ +#define STB_MIPS_SPLIT_COMMON 13 + +/* Entries found in sections of type SHT_MIPS_GPTAB. */ + +typedef union +{ + struct + { + Elf32_Word gt_current_g_value; /* -G value used for compilation */ + Elf32_Word gt_unused; /* Not used */ + } gt_header; /* First entry in section */ + struct + { + Elf32_Word gt_g_value; /* If this value were used for -G */ + Elf32_Word gt_bytes; /* This many bytes would be used */ + } gt_entry; /* Subsequent entries in section */ +} Elf32_gptab; + +/* Entry found in sections of type SHT_MIPS_REGINFO. */ + +typedef struct +{ + Elf32_Word ri_gprmask; /* General registers used */ + Elf32_Word ri_cprmask[4]; /* Coprocessor registers used */ + Elf32_Sword ri_gp_value; /* $gp register value */ +} Elf32_RegInfo; + +/* Entries found in sections of type SHT_MIPS_OPTIONS. */ + +typedef struct +{ + unsigned char kind; /* Determines interpretation of the + variable part of descriptor. */ + unsigned char size; /* Size of descriptor, including header. */ + Elf32_Section section; /* Section header index of section affected, + 0 for global options. */ + Elf32_Word info; /* Kind-specific information. */ +} Elf_Options; + +/* Values for `kind' field in Elf_Options. */ + +#define ODK_NULL 0 /* Undefined. */ +#define ODK_REGINFO 1 /* Register usage information. */ +#define ODK_EXCEPTIONS 2 /* Exception processing options. */ +#define ODK_PAD 3 /* Section padding options. */ +#define ODK_HWPATCH 4 /* Hardware workarounds performed */ +#define ODK_FILL 5 /* record the fill value used by the linker. */ +#define ODK_TAGS 6 /* reserve space for desktop tools to write. */ +#define ODK_HWAND 7 /* HW workarounds. 'AND' bits when merging. */ +#define ODK_HWOR 8 /* HW workarounds. 'OR' bits when merging. */ + +/* Values for `info' in Elf_Options for ODK_EXCEPTIONS entries. */ + +#define OEX_FPU_MIN 0x1f /* FPE's which MUST be enabled. */ +#define OEX_FPU_MAX 0x1f00 /* FPE's which MAY be enabled. */ +#define OEX_PAGE0 0x10000 /* page zero must be mapped. */ +#define OEX_SMM 0x20000 /* Force sequential memory mode? */ +#define OEX_FPDBUG 0x40000 /* Force floating point debug mode? */ +#define OEX_PRECISEFP OEX_FPDBUG +#define OEX_DISMISS 0x80000 /* Dismiss invalid address faults? */ + +#define OEX_FPU_INVAL 0x10 +#define OEX_FPU_DIV0 0x08 +#define OEX_FPU_OFLO 0x04 +#define OEX_FPU_UFLO 0x02 +#define OEX_FPU_INEX 0x01 + +/* Masks for `info' in Elf_Options for an ODK_HWPATCH entry. */ + +#define OHW_R4KEOP 0x1 /* R4000 end-of-page patch. */ +#define OHW_R8KPFETCH 0x2 /* may need R8000 prefetch patch. */ +#define OHW_R5KEOP 0x4 /* R5000 end-of-page patch. */ +#define OHW_R5KCVTL 0x8 /* R5000 cvt.[ds].l bug. clean=1. */ + +#define OPAD_PREFIX 0x1 +#define OPAD_POSTFIX 0x2 +#define OPAD_SYMBOL 0x4 + +/* Entry found in `.options' section. */ + +typedef struct +{ + Elf32_Word hwp_flags1; /* Extra flags. */ + Elf32_Word hwp_flags2; /* Extra flags. */ +} Elf_Options_Hw; + +/* Masks for `info' in ElfOptions for ODK_HWAND and ODK_HWOR entries. */ + +#define OHWA0_R4KEOP_CHECKED 0x00000001 +#define OHWA1_R4KEOP_CLEAN 0x00000002 + +/* MIPS relocs. */ + +#define R_MIPS_NONE 0 /* No reloc */ +#define R_MIPS_16 1 /* Direct 16 bit */ +#define R_MIPS_32 2 /* Direct 32 bit */ +#define R_MIPS_REL32 3 /* PC relative 32 bit */ +#define R_MIPS_26 4 /* Direct 26 bit shifted */ +#define R_MIPS_HI16 5 /* High 16 bit */ +#define R_MIPS_LO16 6 /* Low 16 bit */ +#define R_MIPS_GPREL16 7 /* GP relative 16 bit */ +#define R_MIPS_LITERAL 8 /* 16 bit literal entry */ +#define R_MIPS_GOT16 9 /* 16 bit GOT entry */ +#define R_MIPS_PC16 10 /* PC relative 16 bit */ +#define R_MIPS_CALL16 11 /* 16 bit GOT entry for function */ +#define R_MIPS_GPREL32 12 /* GP relative 32 bit */ + +#define R_MIPS_SHIFT5 16 +#define R_MIPS_SHIFT6 17 +#define R_MIPS_64 18 +#define R_MIPS_GOT_DISP 19 +#define R_MIPS_GOT_PAGE 20 +#define R_MIPS_GOT_OFST 21 +#define R_MIPS_GOT_HI16 22 +#define R_MIPS_GOT_LO16 23 +#define R_MIPS_SUB 24 +#define R_MIPS_INSERT_A 25 +#define R_MIPS_INSERT_B 26 +#define R_MIPS_DELETE 27 +#define R_MIPS_HIGHER 28 +#define R_MIPS_HIGHEST 29 +#define R_MIPS_CALL_HI16 30 +#define R_MIPS_CALL_LO16 31 +#define R_MIPS_SCN_DISP 32 +#define R_MIPS_REL16 33 +#define R_MIPS_ADD_IMMEDIATE 34 +#define R_MIPS_PJUMP 35 +#define R_MIPS_RELGOT 36 +#define R_MIPS_JALR 37 +#define R_MIPS_TLS_DTPMOD32 38 /* Module number 32 bit */ +#define R_MIPS_TLS_DTPREL32 39 /* Module-relative offset 32 bit */ +#define R_MIPS_TLS_DTPMOD64 40 /* Module number 64 bit */ +#define R_MIPS_TLS_DTPREL64 41 /* Module-relative offset 64 bit */ +#define R_MIPS_TLS_GD 42 /* 16 bit GOT offset for GD */ +#define R_MIPS_TLS_LDM 43 /* 16 bit GOT offset for LDM */ +#define R_MIPS_TLS_DTPREL_HI16 44 /* Module-relative offset, high 16 bits */ +#define R_MIPS_TLS_DTPREL_LO16 45 /* Module-relative offset, low 16 bits */ +#define R_MIPS_TLS_GOTTPREL 46 /* 16 bit GOT offset for IE */ +#define R_MIPS_TLS_TPREL32 47 /* TP-relative offset, 32 bit */ +#define R_MIPS_TLS_TPREL64 48 /* TP-relative offset, 64 bit */ +#define R_MIPS_TLS_TPREL_HI16 49 /* TP-relative offset, high 16 bits */ +#define R_MIPS_TLS_TPREL_LO16 50 /* TP-relative offset, low 16 bits */ +#define R_MIPS_GLOB_DAT 51 +#define R_MIPS_COPY 126 +#define R_MIPS_JUMP_SLOT 127 +/* Keep this the last entry. */ +#define R_MIPS_NUM 128 + +/* Legal values for p_type field of Elf32_Phdr. */ + +#define PT_MIPS_REGINFO 0x70000000 /* Register usage information */ +#define PT_MIPS_RTPROC 0x70000001 /* Runtime procedure table. */ +#define PT_MIPS_OPTIONS 0x70000002 + +/* Special program header types. */ + +#define PF_MIPS_LOCAL 0x10000000 + +/* Legal values for d_tag field of Elf32_Dyn. */ + +#define DT_MIPS_RLD_VERSION 0x70000001 /* Runtime linker interface version */ +#define DT_MIPS_TIME_STAMP 0x70000002 /* Timestamp */ +#define DT_MIPS_ICHECKSUM 0x70000003 /* Checksum */ +#define DT_MIPS_IVERSION 0x70000004 /* Version string (string tbl index) */ +#define DT_MIPS_FLAGS 0x70000005 /* Flags */ +#define DT_MIPS_BASE_ADDRESS 0x70000006 /* Base address */ +#define DT_MIPS_MSYM 0x70000007 +#define DT_MIPS_CONFLICT 0x70000008 /* Address of CONFLICT section */ +#define DT_MIPS_LIBLIST 0x70000009 /* Address of LIBLIST section */ +#define DT_MIPS_LOCAL_GOTNO 0x7000000a /* Number of local GOT entries */ +#define DT_MIPS_CONFLICTNO 0x7000000b /* Number of CONFLICT entries */ +#define DT_MIPS_LIBLISTNO 0x70000010 /* Number of LIBLIST entries */ +#define DT_MIPS_SYMTABNO 0x70000011 /* Number of DYNSYM entries */ +#define DT_MIPS_UNREFEXTNO 0x70000012 /* First external DYNSYM */ +#define DT_MIPS_GOTSYM 0x70000013 /* First GOT entry in DYNSYM */ +#define DT_MIPS_HIPAGENO 0x70000014 /* Number of GOT page table entries */ +#define DT_MIPS_RLD_MAP 0x70000016 /* Address of run time loader map. */ +#define DT_MIPS_DELTA_CLASS 0x70000017 /* Delta C++ class definition. */ +#define DT_MIPS_DELTA_CLASS_NO 0x70000018 /* Number of entries in + DT_MIPS_DELTA_CLASS. */ +#define DT_MIPS_DELTA_INSTANCE 0x70000019 /* Delta C++ class instances. */ +#define DT_MIPS_DELTA_INSTANCE_NO 0x7000001a /* Number of entries in + DT_MIPS_DELTA_INSTANCE. */ +#define DT_MIPS_DELTA_RELOC 0x7000001b /* Delta relocations. */ +#define DT_MIPS_DELTA_RELOC_NO 0x7000001c /* Number of entries in + DT_MIPS_DELTA_RELOC. */ +#define DT_MIPS_DELTA_SYM 0x7000001d /* Delta symbols that Delta + relocations refer to. */ +#define DT_MIPS_DELTA_SYM_NO 0x7000001e /* Number of entries in + DT_MIPS_DELTA_SYM. */ +#define DT_MIPS_DELTA_CLASSSYM 0x70000020 /* Delta symbols that hold the + class declaration. */ +#define DT_MIPS_DELTA_CLASSSYM_NO 0x70000021 /* Number of entries in + DT_MIPS_DELTA_CLASSSYM. */ +#define DT_MIPS_CXX_FLAGS 0x70000022 /* Flags indicating for C++ flavor. */ +#define DT_MIPS_PIXIE_INIT 0x70000023 +#define DT_MIPS_SYMBOL_LIB 0x70000024 +#define DT_MIPS_LOCALPAGE_GOTIDX 0x70000025 +#define DT_MIPS_LOCAL_GOTIDX 0x70000026 +#define DT_MIPS_HIDDEN_GOTIDX 0x70000027 +#define DT_MIPS_PROTECTED_GOTIDX 0x70000028 +#define DT_MIPS_OPTIONS 0x70000029 /* Address of .options. */ +#define DT_MIPS_INTERFACE 0x7000002a /* Address of .interface. */ +#define DT_MIPS_DYNSTR_ALIGN 0x7000002b +#define DT_MIPS_INTERFACE_SIZE 0x7000002c /* Size of the .interface section. */ +#define DT_MIPS_RLD_TEXT_RESOLVE_ADDR 0x7000002d /* Address of rld_text_rsolve + function stored in GOT. */ +#define DT_MIPS_PERF_SUFFIX 0x7000002e /* Default suffix of dso to be added + by rld on dlopen() calls. */ +#define DT_MIPS_COMPACT_SIZE 0x7000002f /* (O32)Size of compact rel section. */ +#define DT_MIPS_GP_VALUE 0x70000030 /* GP value for aux GOTs. */ +#define DT_MIPS_AUX_DYNAMIC 0x70000031 /* Address of aux .dynamic. */ +/* The address of .got.plt in an executable using the new non-PIC ABI. */ +#define DT_MIPS_PLTGOT 0x70000032 +/* The base of the PLT in an executable using the new non-PIC ABI if that + PLT is writable. For a non-writable PLT, this is omitted or has a zero + value. */ +#define DT_MIPS_RWPLT 0x70000034 +#define DT_MIPS_NUM 0x35 + +/* Legal values for DT_MIPS_FLAGS Elf32_Dyn entry. */ + +#define RHF_NONE 0 /* No flags */ +#define RHF_QUICKSTART (1 << 0) /* Use quickstart */ +#define RHF_NOTPOT (1 << 1) /* Hash size not power of 2 */ +#define RHF_NO_LIBRARY_REPLACEMENT (1 << 2) /* Ignore LD_LIBRARY_PATH */ +#define RHF_NO_MOVE (1 << 3) +#define RHF_SGI_ONLY (1 << 4) +#define RHF_GUARANTEE_INIT (1 << 5) +#define RHF_DELTA_C_PLUS_PLUS (1 << 6) +#define RHF_GUARANTEE_START_INIT (1 << 7) +#define RHF_PIXIE (1 << 8) +#define RHF_DEFAULT_DELAY_LOAD (1 << 9) +#define RHF_REQUICKSTART (1 << 10) +#define RHF_REQUICKSTARTED (1 << 11) +#define RHF_CORD (1 << 12) +#define RHF_NO_UNRES_UNDEF (1 << 13) +#define RHF_RLD_ORDER_SAFE (1 << 14) + +/* Entries found in sections of type SHT_MIPS_LIBLIST. */ + +typedef struct +{ + Elf32_Word l_name; /* Name (string table index) */ + Elf32_Word l_time_stamp; /* Timestamp */ + Elf32_Word l_checksum; /* Checksum */ + Elf32_Word l_version; /* Interface version */ + Elf32_Word l_flags; /* Flags */ +} Elf32_Lib; + +typedef struct +{ + Elf64_Word l_name; /* Name (string table index) */ + Elf64_Word l_time_stamp; /* Timestamp */ + Elf64_Word l_checksum; /* Checksum */ + Elf64_Word l_version; /* Interface version */ + Elf64_Word l_flags; /* Flags */ +} Elf64_Lib; + + +/* Legal values for l_flags. */ + +#define LL_NONE 0 +#define LL_EXACT_MATCH (1 << 0) /* Require exact match */ +#define LL_IGNORE_INT_VER (1 << 1) /* Ignore interface version */ +#define LL_REQUIRE_MINOR (1 << 2) +#define LL_EXPORTS (1 << 3) +#define LL_DELAY_LOAD (1 << 4) +#define LL_DELTA (1 << 5) + +/* Entries found in sections of type SHT_MIPS_CONFLICT. */ + +typedef Elf32_Addr Elf32_Conflict; + + +/* HPPA specific definitions. */ + +/* Legal values for e_flags field of Elf32_Ehdr. */ + +#define EF_PARISC_TRAPNIL 0x00010000 /* Trap nil pointer dereference. */ +#define EF_PARISC_EXT 0x00020000 /* Program uses arch. extensions. */ +#define EF_PARISC_LSB 0x00040000 /* Program expects little endian. */ +#define EF_PARISC_WIDE 0x00080000 /* Program expects wide mode. */ +#define EF_PARISC_NO_KABP 0x00100000 /* No kernel assisted branch + prediction. */ +#define EF_PARISC_LAZYSWAP 0x00400000 /* Allow lazy swapping. */ +#define EF_PARISC_ARCH 0x0000ffff /* Architecture version. */ + +/* Defined values for `e_flags & EF_PARISC_ARCH' are: */ + +#define EFA_PARISC_1_0 0x020b /* PA-RISC 1.0 big-endian. */ +#define EFA_PARISC_1_1 0x0210 /* PA-RISC 1.1 big-endian. */ +#define EFA_PARISC_2_0 0x0214 /* PA-RISC 2.0 big-endian. */ + +/* Additional section indeces. */ + +#define SHN_PARISC_ANSI_COMMON 0xff00 /* Section for tenatively declared + symbols in ANSI C. */ +#define SHN_PARISC_HUGE_COMMON 0xff01 /* Common blocks in huge model. */ + +/* Legal values for sh_type field of Elf32_Shdr. */ + +#define SHT_PARISC_EXT 0x70000000 /* Contains product specific ext. */ +#define SHT_PARISC_UNWIND 0x70000001 /* Unwind information. */ +#define SHT_PARISC_DOC 0x70000002 /* Debug info for optimized code. */ + +/* Legal values for sh_flags field of Elf32_Shdr. */ + +#define SHF_PARISC_SHORT 0x20000000 /* Section with short addressing. */ +#define SHF_PARISC_HUGE 0x40000000 /* Section far from gp. */ +#define SHF_PARISC_SBP 0x80000000 /* Static branch prediction code. */ + +/* Legal values for ST_TYPE subfield of st_info (symbol type). */ + +#define STT_PARISC_MILLICODE 13 /* Millicode function entry point. */ + +#define STT_HP_OPAQUE (STT_LOOS + 0x1) +#define STT_HP_STUB (STT_LOOS + 0x2) + +/* HPPA relocs. */ + +#define R_PARISC_NONE 0 /* No reloc. */ +#define R_PARISC_DIR32 1 /* Direct 32-bit reference. */ +#define R_PARISC_DIR21L 2 /* Left 21 bits of eff. address. */ +#define R_PARISC_DIR17R 3 /* Right 17 bits of eff. address. */ +#define R_PARISC_DIR17F 4 /* 17 bits of eff. address. */ +#define R_PARISC_DIR14R 6 /* Right 14 bits of eff. address. */ +#define R_PARISC_PCREL32 9 /* 32-bit rel. address. */ +#define R_PARISC_PCREL21L 10 /* Left 21 bits of rel. address. */ +#define R_PARISC_PCREL17R 11 /* Right 17 bits of rel. address. */ +#define R_PARISC_PCREL17F 12 /* 17 bits of rel. address. */ +#define R_PARISC_PCREL14R 14 /* Right 14 bits of rel. address. */ +#define R_PARISC_DPREL21L 18 /* Left 21 bits of rel. address. */ +#define R_PARISC_DPREL14R 22 /* Right 14 bits of rel. address. */ +#define R_PARISC_GPREL21L 26 /* GP-relative, left 21 bits. */ +#define R_PARISC_GPREL14R 30 /* GP-relative, right 14 bits. */ +#define R_PARISC_LTOFF21L 34 /* LT-relative, left 21 bits. */ +#define R_PARISC_LTOFF14R 38 /* LT-relative, right 14 bits. */ +#define R_PARISC_SECREL32 41 /* 32 bits section rel. address. */ +#define R_PARISC_SEGBASE 48 /* No relocation, set segment base. */ +#define R_PARISC_SEGREL32 49 /* 32 bits segment rel. address. */ +#define R_PARISC_PLTOFF21L 50 /* PLT rel. address, left 21 bits. */ +#define R_PARISC_PLTOFF14R 54 /* PLT rel. address, right 14 bits. */ +#define R_PARISC_LTOFF_FPTR32 57 /* 32 bits LT-rel. function pointer. */ +#define R_PARISC_LTOFF_FPTR21L 58 /* LT-rel. fct ptr, left 21 bits. */ +#define R_PARISC_LTOFF_FPTR14R 62 /* LT-rel. fct ptr, right 14 bits. */ +#define R_PARISC_FPTR64 64 /* 64 bits function address. */ +#define R_PARISC_PLABEL32 65 /* 32 bits function address. */ +#define R_PARISC_PLABEL21L 66 /* Left 21 bits of fdesc address. */ +#define R_PARISC_PLABEL14R 70 /* Right 14 bits of fdesc address. */ +#define R_PARISC_PCREL64 72 /* 64 bits PC-rel. address. */ +#define R_PARISC_PCREL22F 74 /* 22 bits PC-rel. address. */ +#define R_PARISC_PCREL14WR 75 /* PC-rel. address, right 14 bits. */ +#define R_PARISC_PCREL14DR 76 /* PC rel. address, right 14 bits. */ +#define R_PARISC_PCREL16F 77 /* 16 bits PC-rel. address. */ +#define R_PARISC_PCREL16WF 78 /* 16 bits PC-rel. address. */ +#define R_PARISC_PCREL16DF 79 /* 16 bits PC-rel. address. */ +#define R_PARISC_DIR64 80 /* 64 bits of eff. address. */ +#define R_PARISC_DIR14WR 83 /* 14 bits of eff. address. */ +#define R_PARISC_DIR14DR 84 /* 14 bits of eff. address. */ +#define R_PARISC_DIR16F 85 /* 16 bits of eff. address. */ +#define R_PARISC_DIR16WF 86 /* 16 bits of eff. address. */ +#define R_PARISC_DIR16DF 87 /* 16 bits of eff. address. */ +#define R_PARISC_GPREL64 88 /* 64 bits of GP-rel. address. */ +#define R_PARISC_GPREL14WR 91 /* GP-rel. address, right 14 bits. */ +#define R_PARISC_GPREL14DR 92 /* GP-rel. address, right 14 bits. */ +#define R_PARISC_GPREL16F 93 /* 16 bits GP-rel. address. */ +#define R_PARISC_GPREL16WF 94 /* 16 bits GP-rel. address. */ +#define R_PARISC_GPREL16DF 95 /* 16 bits GP-rel. address. */ +#define R_PARISC_LTOFF64 96 /* 64 bits LT-rel. address. */ +#define R_PARISC_LTOFF14WR 99 /* LT-rel. address, right 14 bits. */ +#define R_PARISC_LTOFF14DR 100 /* LT-rel. address, right 14 bits. */ +#define R_PARISC_LTOFF16F 101 /* 16 bits LT-rel. address. */ +#define R_PARISC_LTOFF16WF 102 /* 16 bits LT-rel. address. */ +#define R_PARISC_LTOFF16DF 103 /* 16 bits LT-rel. address. */ +#define R_PARISC_SECREL64 104 /* 64 bits section rel. address. */ +#define R_PARISC_SEGREL64 112 /* 64 bits segment rel. address. */ +#define R_PARISC_PLTOFF14WR 115 /* PLT-rel. address, right 14 bits. */ +#define R_PARISC_PLTOFF14DR 116 /* PLT-rel. address, right 14 bits. */ +#define R_PARISC_PLTOFF16F 117 /* 16 bits LT-rel. address. */ +#define R_PARISC_PLTOFF16WF 118 /* 16 bits PLT-rel. address. */ +#define R_PARISC_PLTOFF16DF 119 /* 16 bits PLT-rel. address. */ +#define R_PARISC_LTOFF_FPTR64 120 /* 64 bits LT-rel. function ptr. */ +#define R_PARISC_LTOFF_FPTR14WR 123 /* LT-rel. fct. ptr., right 14 bits. */ +#define R_PARISC_LTOFF_FPTR14DR 124 /* LT-rel. fct. ptr., right 14 bits. */ +#define R_PARISC_LTOFF_FPTR16F 125 /* 16 bits LT-rel. function ptr. */ +#define R_PARISC_LTOFF_FPTR16WF 126 /* 16 bits LT-rel. function ptr. */ +#define R_PARISC_LTOFF_FPTR16DF 127 /* 16 bits LT-rel. function ptr. */ +#define R_PARISC_LORESERVE 128 +#define R_PARISC_COPY 128 /* Copy relocation. */ +#define R_PARISC_IPLT 129 /* Dynamic reloc, imported PLT */ +#define R_PARISC_EPLT 130 /* Dynamic reloc, exported PLT */ +#define R_PARISC_TPREL32 153 /* 32 bits TP-rel. address. */ +#define R_PARISC_TPREL21L 154 /* TP-rel. address, left 21 bits. */ +#define R_PARISC_TPREL14R 158 /* TP-rel. address, right 14 bits. */ +#define R_PARISC_LTOFF_TP21L 162 /* LT-TP-rel. address, left 21 bits. */ +#define R_PARISC_LTOFF_TP14R 166 /* LT-TP-rel. address, right 14 bits.*/ +#define R_PARISC_LTOFF_TP14F 167 /* 14 bits LT-TP-rel. address. */ +#define R_PARISC_TPREL64 216 /* 64 bits TP-rel. address. */ +#define R_PARISC_TPREL14WR 219 /* TP-rel. address, right 14 bits. */ +#define R_PARISC_TPREL14DR 220 /* TP-rel. address, right 14 bits. */ +#define R_PARISC_TPREL16F 221 /* 16 bits TP-rel. address. */ +#define R_PARISC_TPREL16WF 222 /* 16 bits TP-rel. address. */ +#define R_PARISC_TPREL16DF 223 /* 16 bits TP-rel. address. */ +#define R_PARISC_LTOFF_TP64 224 /* 64 bits LT-TP-rel. address. */ +#define R_PARISC_LTOFF_TP14WR 227 /* LT-TP-rel. address, right 14 bits.*/ +#define R_PARISC_LTOFF_TP14DR 228 /* LT-TP-rel. address, right 14 bits.*/ +#define R_PARISC_LTOFF_TP16F 229 /* 16 bits LT-TP-rel. address. */ +#define R_PARISC_LTOFF_TP16WF 230 /* 16 bits LT-TP-rel. address. */ +#define R_PARISC_LTOFF_TP16DF 231 /* 16 bits LT-TP-rel. address. */ +#define R_PARISC_GNU_VTENTRY 232 +#define R_PARISC_GNU_VTINHERIT 233 +#define R_PARISC_TLS_GD21L 234 /* GD 21-bit left. */ +#define R_PARISC_TLS_GD14R 235 /* GD 14-bit right. */ +#define R_PARISC_TLS_GDCALL 236 /* GD call to __t_g_a. */ +#define R_PARISC_TLS_LDM21L 237 /* LD module 21-bit left. */ +#define R_PARISC_TLS_LDM14R 238 /* LD module 14-bit right. */ +#define R_PARISC_TLS_LDMCALL 239 /* LD module call to __t_g_a. */ +#define R_PARISC_TLS_LDO21L 240 /* LD offset 21-bit left. */ +#define R_PARISC_TLS_LDO14R 241 /* LD offset 14-bit right. */ +#define R_PARISC_TLS_DTPMOD32 242 /* DTP module 32-bit. */ +#define R_PARISC_TLS_DTPMOD64 243 /* DTP module 64-bit. */ +#define R_PARISC_TLS_DTPOFF32 244 /* DTP offset 32-bit. */ +#define R_PARISC_TLS_DTPOFF64 245 /* DTP offset 32-bit. */ +#define R_PARISC_TLS_LE21L R_PARISC_TPREL21L +#define R_PARISC_TLS_LE14R R_PARISC_TPREL14R +#define R_PARISC_TLS_IE21L R_PARISC_LTOFF_TP21L +#define R_PARISC_TLS_IE14R R_PARISC_LTOFF_TP14R +#define R_PARISC_TLS_TPREL32 R_PARISC_TPREL32 +#define R_PARISC_TLS_TPREL64 R_PARISC_TPREL64 +#define R_PARISC_HIRESERVE 255 + +/* Legal values for p_type field of Elf32_Phdr/Elf64_Phdr. */ + +#define PT_HP_TLS (PT_LOOS + 0x0) +#define PT_HP_CORE_NONE (PT_LOOS + 0x1) +#define PT_HP_CORE_VERSION (PT_LOOS + 0x2) +#define PT_HP_CORE_KERNEL (PT_LOOS + 0x3) +#define PT_HP_CORE_COMM (PT_LOOS + 0x4) +#define PT_HP_CORE_PROC (PT_LOOS + 0x5) +#define PT_HP_CORE_LOADABLE (PT_LOOS + 0x6) +#define PT_HP_CORE_STACK (PT_LOOS + 0x7) +#define PT_HP_CORE_SHM (PT_LOOS + 0x8) +#define PT_HP_CORE_MMF (PT_LOOS + 0x9) +#define PT_HP_PARALLEL (PT_LOOS + 0x10) +#define PT_HP_FASTBIND (PT_LOOS + 0x11) +#define PT_HP_OPT_ANNOT (PT_LOOS + 0x12) +#define PT_HP_HSL_ANNOT (PT_LOOS + 0x13) +#define PT_HP_STACK (PT_LOOS + 0x14) + +#define PT_PARISC_ARCHEXT 0x70000000 +#define PT_PARISC_UNWIND 0x70000001 + +/* Legal values for p_flags field of Elf32_Phdr/Elf64_Phdr. */ + +#define PF_PARISC_SBP 0x08000000 + +#define PF_HP_PAGE_SIZE 0x00100000 +#define PF_HP_FAR_SHARED 0x00200000 +#define PF_HP_NEAR_SHARED 0x00400000 +#define PF_HP_CODE 0x01000000 +#define PF_HP_MODIFY 0x02000000 +#define PF_HP_LAZYSWAP 0x04000000 +#define PF_HP_SBP 0x08000000 + + +/* Alpha specific definitions. */ + +/* Legal values for e_flags field of Elf64_Ehdr. */ + +#define EF_ALPHA_32BIT 1 /* All addresses must be < 2GB. */ +#define EF_ALPHA_CANRELAX 2 /* Relocations for relaxing exist. */ + +/* Legal values for sh_type field of Elf64_Shdr. */ + +/* These two are primerily concerned with ECOFF debugging info. */ +#define SHT_ALPHA_DEBUG 0x70000001 +#define SHT_ALPHA_REGINFO 0x70000002 + +/* Legal values for sh_flags field of Elf64_Shdr. */ + +#define SHF_ALPHA_GPREL 0x10000000 + +/* Legal values for st_other field of Elf64_Sym. */ +#define STO_ALPHA_NOPV 0x80 /* No PV required. */ +#define STO_ALPHA_STD_GPLOAD 0x88 /* PV only used for initial ldgp. */ + +/* Alpha relocs. */ + +#define R_ALPHA_NONE 0 /* No reloc */ +#define R_ALPHA_REFLONG 1 /* Direct 32 bit */ +#define R_ALPHA_REFQUAD 2 /* Direct 64 bit */ +#define R_ALPHA_GPREL32 3 /* GP relative 32 bit */ +#define R_ALPHA_LITERAL 4 /* GP relative 16 bit w/optimization */ +#define R_ALPHA_LITUSE 5 /* Optimization hint for LITERAL */ +#define R_ALPHA_GPDISP 6 /* Add displacement to GP */ +#define R_ALPHA_BRADDR 7 /* PC+4 relative 23 bit shifted */ +#define R_ALPHA_HINT 8 /* PC+4 relative 16 bit shifted */ +#define R_ALPHA_SREL16 9 /* PC relative 16 bit */ +#define R_ALPHA_SREL32 10 /* PC relative 32 bit */ +#define R_ALPHA_SREL64 11 /* PC relative 64 bit */ +#define R_ALPHA_GPRELHIGH 17 /* GP relative 32 bit, high 16 bits */ +#define R_ALPHA_GPRELLOW 18 /* GP relative 32 bit, low 16 bits */ +#define R_ALPHA_GPREL16 19 /* GP relative 16 bit */ +#define R_ALPHA_COPY 24 /* Copy symbol at runtime */ +#define R_ALPHA_GLOB_DAT 25 /* Create GOT entry */ +#define R_ALPHA_JMP_SLOT 26 /* Create PLT entry */ +#define R_ALPHA_RELATIVE 27 /* Adjust by program base */ +#define R_ALPHA_TLS_GD_HI 28 +#define R_ALPHA_TLSGD 29 +#define R_ALPHA_TLS_LDM 30 +#define R_ALPHA_DTPMOD64 31 +#define R_ALPHA_GOTDTPREL 32 +#define R_ALPHA_DTPREL64 33 +#define R_ALPHA_DTPRELHI 34 +#define R_ALPHA_DTPRELLO 35 +#define R_ALPHA_DTPREL16 36 +#define R_ALPHA_GOTTPREL 37 +#define R_ALPHA_TPREL64 38 +#define R_ALPHA_TPRELHI 39 +#define R_ALPHA_TPRELLO 40 +#define R_ALPHA_TPREL16 41 +/* Keep this the last entry. */ +#define R_ALPHA_NUM 46 + +/* Magic values of the LITUSE relocation addend. */ +#define LITUSE_ALPHA_ADDR 0 +#define LITUSE_ALPHA_BASE 1 +#define LITUSE_ALPHA_BYTOFF 2 +#define LITUSE_ALPHA_JSR 3 +#define LITUSE_ALPHA_TLS_GD 4 +#define LITUSE_ALPHA_TLS_LDM 5 + +/* Legal values for d_tag of Elf64_Dyn. */ +#define DT_ALPHA_PLTRO (DT_LOPROC + 0) +#define DT_ALPHA_NUM 1 + +/* PowerPC specific declarations */ + +/* Values for Elf32/64_Ehdr.e_flags. */ +#define EF_PPC_EMB 0x80000000 /* PowerPC embedded flag */ + +/* Cygnus local bits below */ +#define EF_PPC_RELOCATABLE 0x00010000 /* PowerPC -mrelocatable flag*/ +#define EF_PPC_RELOCATABLE_LIB 0x00008000 /* PowerPC -mrelocatable-lib + flag */ + +/* PowerPC relocations defined by the ABIs */ +#define R_PPC_NONE 0 +#define R_PPC_ADDR32 1 /* 32bit absolute address */ +#define R_PPC_ADDR24 2 /* 26bit address, 2 bits ignored. */ +#define R_PPC_ADDR16 3 /* 16bit absolute address */ +#define R_PPC_ADDR16_LO 4 /* lower 16bit of absolute address */ +#define R_PPC_ADDR16_HI 5 /* high 16bit of absolute address */ +#define R_PPC_ADDR16_HA 6 /* adjusted high 16bit */ +#define R_PPC_ADDR14 7 /* 16bit address, 2 bits ignored */ +#define R_PPC_ADDR14_BRTAKEN 8 +#define R_PPC_ADDR14_BRNTAKEN 9 +#define R_PPC_REL24 10 /* PC relative 26 bit */ +#define R_PPC_REL14 11 /* PC relative 16 bit */ +#define R_PPC_REL14_BRTAKEN 12 +#define R_PPC_REL14_BRNTAKEN 13 +#define R_PPC_GOT16 14 +#define R_PPC_GOT16_LO 15 +#define R_PPC_GOT16_HI 16 +#define R_PPC_GOT16_HA 17 +#define R_PPC_PLTREL24 18 +#define R_PPC_COPY 19 +#define R_PPC_GLOB_DAT 20 +#define R_PPC_JMP_SLOT 21 +#define R_PPC_RELATIVE 22 +#define R_PPC_LOCAL24PC 23 +#define R_PPC_UADDR32 24 +#define R_PPC_UADDR16 25 +#define R_PPC_REL32 26 +#define R_PPC_PLT32 27 +#define R_PPC_PLTREL32 28 +#define R_PPC_PLT16_LO 29 +#define R_PPC_PLT16_HI 30 +#define R_PPC_PLT16_HA 31 +#define R_PPC_SDAREL16 32 +#define R_PPC_SECTOFF 33 +#define R_PPC_SECTOFF_LO 34 +#define R_PPC_SECTOFF_HI 35 +#define R_PPC_SECTOFF_HA 36 + +/* PowerPC relocations defined for the TLS access ABI. */ +#define R_PPC_TLS 67 /* none (sym+add)@tls */ +#define R_PPC_DTPMOD32 68 /* word32 (sym+add)@dtpmod */ +#define R_PPC_TPREL16 69 /* half16* (sym+add)@tprel */ +#define R_PPC_TPREL16_LO 70 /* half16 (sym+add)@tprel@l */ +#define R_PPC_TPREL16_HI 71 /* half16 (sym+add)@tprel@h */ +#define R_PPC_TPREL16_HA 72 /* half16 (sym+add)@tprel@ha */ +#define R_PPC_TPREL32 73 /* word32 (sym+add)@tprel */ +#define R_PPC_DTPREL16 74 /* half16* (sym+add)@dtprel */ +#define R_PPC_DTPREL16_LO 75 /* half16 (sym+add)@dtprel@l */ +#define R_PPC_DTPREL16_HI 76 /* half16 (sym+add)@dtprel@h */ +#define R_PPC_DTPREL16_HA 77 /* half16 (sym+add)@dtprel@ha */ +#define R_PPC_DTPREL32 78 /* word32 (sym+add)@dtprel */ +#define R_PPC_GOT_TLSGD16 79 /* half16* (sym+add)@got@tlsgd */ +#define R_PPC_GOT_TLSGD16_LO 80 /* half16 (sym+add)@got@tlsgd@l */ +#define R_PPC_GOT_TLSGD16_HI 81 /* half16 (sym+add)@got@tlsgd@h */ +#define R_PPC_GOT_TLSGD16_HA 82 /* half16 (sym+add)@got@tlsgd@ha */ +#define R_PPC_GOT_TLSLD16 83 /* half16* (sym+add)@got@tlsld */ +#define R_PPC_GOT_TLSLD16_LO 84 /* half16 (sym+add)@got@tlsld@l */ +#define R_PPC_GOT_TLSLD16_HI 85 /* half16 (sym+add)@got@tlsld@h */ +#define R_PPC_GOT_TLSLD16_HA 86 /* half16 (sym+add)@got@tlsld@ha */ +#define R_PPC_GOT_TPREL16 87 /* half16* (sym+add)@got@tprel */ +#define R_PPC_GOT_TPREL16_LO 88 /* half16 (sym+add)@got@tprel@l */ +#define R_PPC_GOT_TPREL16_HI 89 /* half16 (sym+add)@got@tprel@h */ +#define R_PPC_GOT_TPREL16_HA 90 /* half16 (sym+add)@got@tprel@ha */ +#define R_PPC_GOT_DTPREL16 91 /* half16* (sym+add)@got@dtprel */ +#define R_PPC_GOT_DTPREL16_LO 92 /* half16* (sym+add)@got@dtprel@l */ +#define R_PPC_GOT_DTPREL16_HI 93 /* half16* (sym+add)@got@dtprel@h */ +#define R_PPC_GOT_DTPREL16_HA 94 /* half16* (sym+add)@got@dtprel@ha */ + +/* The remaining relocs are from the Embedded ELF ABI, and are not + in the SVR4 ELF ABI. */ +#define R_PPC_EMB_NADDR32 101 +#define R_PPC_EMB_NADDR16 102 +#define R_PPC_EMB_NADDR16_LO 103 +#define R_PPC_EMB_NADDR16_HI 104 +#define R_PPC_EMB_NADDR16_HA 105 +#define R_PPC_EMB_SDAI16 106 +#define R_PPC_EMB_SDA2I16 107 +#define R_PPC_EMB_SDA2REL 108 +#define R_PPC_EMB_SDA21 109 /* 16 bit offset in SDA */ +#define R_PPC_EMB_MRKREF 110 +#define R_PPC_EMB_RELSEC16 111 +#define R_PPC_EMB_RELST_LO 112 +#define R_PPC_EMB_RELST_HI 113 +#define R_PPC_EMB_RELST_HA 114 +#define R_PPC_EMB_BIT_FLD 115 +#define R_PPC_EMB_RELSDA 116 /* 16 bit relative offset in SDA */ + +/* Diab tool relocations. */ +#define R_PPC_DIAB_SDA21_LO 180 /* like EMB_SDA21, but lower 16 bit */ +#define R_PPC_DIAB_SDA21_HI 181 /* like EMB_SDA21, but high 16 bit */ +#define R_PPC_DIAB_SDA21_HA 182 /* like EMB_SDA21, adjusted high 16 */ +#define R_PPC_DIAB_RELSDA_LO 183 /* like EMB_RELSDA, but lower 16 bit */ +#define R_PPC_DIAB_RELSDA_HI 184 /* like EMB_RELSDA, but high 16 bit */ +#define R_PPC_DIAB_RELSDA_HA 185 /* like EMB_RELSDA, adjusted high 16 */ + +/* GNU extension to support local ifunc. */ +#define R_PPC_IRELATIVE 248 + +/* GNU relocs used in PIC code sequences. */ +#define R_PPC_REL16 249 /* half16 (sym+add-.) */ +#define R_PPC_REL16_LO 250 /* half16 (sym+add-.)@l */ +#define R_PPC_REL16_HI 251 /* half16 (sym+add-.)@h */ +#define R_PPC_REL16_HA 252 /* half16 (sym+add-.)@ha */ + +/* This is a phony reloc to handle any old fashioned TOC16 references + that may still be in object files. */ +#define R_PPC_TOC16 255 + +/* PowerPC specific values for the Dyn d_tag field. */ +#define DT_PPC_GOT (DT_LOPROC + 0) +#define DT_PPC_NUM 1 + +/* PowerPC64 relocations defined by the ABIs */ +#define R_PPC64_NONE R_PPC_NONE +#define R_PPC64_ADDR32 R_PPC_ADDR32 /* 32bit absolute address */ +#define R_PPC64_ADDR24 R_PPC_ADDR24 /* 26bit address, word aligned */ +#define R_PPC64_ADDR16 R_PPC_ADDR16 /* 16bit absolute address */ +#define R_PPC64_ADDR16_LO R_PPC_ADDR16_LO /* lower 16bits of address */ +#define R_PPC64_ADDR16_HI R_PPC_ADDR16_HI /* high 16bits of address. */ +#define R_PPC64_ADDR16_HA R_PPC_ADDR16_HA /* adjusted high 16bits. */ +#define R_PPC64_ADDR14 R_PPC_ADDR14 /* 16bit address, word aligned */ +#define R_PPC64_ADDR14_BRTAKEN R_PPC_ADDR14_BRTAKEN +#define R_PPC64_ADDR14_BRNTAKEN R_PPC_ADDR14_BRNTAKEN +#define R_PPC64_REL24 R_PPC_REL24 /* PC-rel. 26 bit, word aligned */ +#define R_PPC64_REL14 R_PPC_REL14 /* PC relative 16 bit */ +#define R_PPC64_REL14_BRTAKEN R_PPC_REL14_BRTAKEN +#define R_PPC64_REL14_BRNTAKEN R_PPC_REL14_BRNTAKEN +#define R_PPC64_GOT16 R_PPC_GOT16 +#define R_PPC64_GOT16_LO R_PPC_GOT16_LO +#define R_PPC64_GOT16_HI R_PPC_GOT16_HI +#define R_PPC64_GOT16_HA R_PPC_GOT16_HA + +#define R_PPC64_COPY R_PPC_COPY +#define R_PPC64_GLOB_DAT R_PPC_GLOB_DAT +#define R_PPC64_JMP_SLOT R_PPC_JMP_SLOT +#define R_PPC64_RELATIVE R_PPC_RELATIVE + +#define R_PPC64_UADDR32 R_PPC_UADDR32 +#define R_PPC64_UADDR16 R_PPC_UADDR16 +#define R_PPC64_REL32 R_PPC_REL32 +#define R_PPC64_PLT32 R_PPC_PLT32 +#define R_PPC64_PLTREL32 R_PPC_PLTREL32 +#define R_PPC64_PLT16_LO R_PPC_PLT16_LO +#define R_PPC64_PLT16_HI R_PPC_PLT16_HI +#define R_PPC64_PLT16_HA R_PPC_PLT16_HA + +#define R_PPC64_SECTOFF R_PPC_SECTOFF +#define R_PPC64_SECTOFF_LO R_PPC_SECTOFF_LO +#define R_PPC64_SECTOFF_HI R_PPC_SECTOFF_HI +#define R_PPC64_SECTOFF_HA R_PPC_SECTOFF_HA +#define R_PPC64_ADDR30 37 /* word30 (S + A - P) >> 2 */ +#define R_PPC64_ADDR64 38 /* doubleword64 S + A */ +#define R_PPC64_ADDR16_HIGHER 39 /* half16 #higher(S + A) */ +#define R_PPC64_ADDR16_HIGHERA 40 /* half16 #highera(S + A) */ +#define R_PPC64_ADDR16_HIGHEST 41 /* half16 #highest(S + A) */ +#define R_PPC64_ADDR16_HIGHESTA 42 /* half16 #highesta(S + A) */ +#define R_PPC64_UADDR64 43 /* doubleword64 S + A */ +#define R_PPC64_REL64 44 /* doubleword64 S + A - P */ +#define R_PPC64_PLT64 45 /* doubleword64 L + A */ +#define R_PPC64_PLTREL64 46 /* doubleword64 L + A - P */ +#define R_PPC64_TOC16 47 /* half16* S + A - .TOC */ +#define R_PPC64_TOC16_LO 48 /* half16 #lo(S + A - .TOC.) */ +#define R_PPC64_TOC16_HI 49 /* half16 #hi(S + A - .TOC.) */ +#define R_PPC64_TOC16_HA 50 /* half16 #ha(S + A - .TOC.) */ +#define R_PPC64_TOC 51 /* doubleword64 .TOC */ +#define R_PPC64_PLTGOT16 52 /* half16* M + A */ +#define R_PPC64_PLTGOT16_LO 53 /* half16 #lo(M + A) */ +#define R_PPC64_PLTGOT16_HI 54 /* half16 #hi(M + A) */ +#define R_PPC64_PLTGOT16_HA 55 /* half16 #ha(M + A) */ + +#define R_PPC64_ADDR16_DS 56 /* half16ds* (S + A) >> 2 */ +#define R_PPC64_ADDR16_LO_DS 57 /* half16ds #lo(S + A) >> 2 */ +#define R_PPC64_GOT16_DS 58 /* half16ds* (G + A) >> 2 */ +#define R_PPC64_GOT16_LO_DS 59 /* half16ds #lo(G + A) >> 2 */ +#define R_PPC64_PLT16_LO_DS 60 /* half16ds #lo(L + A) >> 2 */ +#define R_PPC64_SECTOFF_DS 61 /* half16ds* (R + A) >> 2 */ +#define R_PPC64_SECTOFF_LO_DS 62 /* half16ds #lo(R + A) >> 2 */ +#define R_PPC64_TOC16_DS 63 /* half16ds* (S + A - .TOC.) >> 2 */ +#define R_PPC64_TOC16_LO_DS 64 /* half16ds #lo(S + A - .TOC.) >> 2 */ +#define R_PPC64_PLTGOT16_DS 65 /* half16ds* (M + A) >> 2 */ +#define R_PPC64_PLTGOT16_LO_DS 66 /* half16ds #lo(M + A) >> 2 */ + +/* PowerPC64 relocations defined for the TLS access ABI. */ +#define R_PPC64_TLS 67 /* none (sym+add)@tls */ +#define R_PPC64_DTPMOD64 68 /* doubleword64 (sym+add)@dtpmod */ +#define R_PPC64_TPREL16 69 /* half16* (sym+add)@tprel */ +#define R_PPC64_TPREL16_LO 70 /* half16 (sym+add)@tprel@l */ +#define R_PPC64_TPREL16_HI 71 /* half16 (sym+add)@tprel@h */ +#define R_PPC64_TPREL16_HA 72 /* half16 (sym+add)@tprel@ha */ +#define R_PPC64_TPREL64 73 /* doubleword64 (sym+add)@tprel */ +#define R_PPC64_DTPREL16 74 /* half16* (sym+add)@dtprel */ +#define R_PPC64_DTPREL16_LO 75 /* half16 (sym+add)@dtprel@l */ +#define R_PPC64_DTPREL16_HI 76 /* half16 (sym+add)@dtprel@h */ +#define R_PPC64_DTPREL16_HA 77 /* half16 (sym+add)@dtprel@ha */ +#define R_PPC64_DTPREL64 78 /* doubleword64 (sym+add)@dtprel */ +#define R_PPC64_GOT_TLSGD16 79 /* half16* (sym+add)@got@tlsgd */ +#define R_PPC64_GOT_TLSGD16_LO 80 /* half16 (sym+add)@got@tlsgd@l */ +#define R_PPC64_GOT_TLSGD16_HI 81 /* half16 (sym+add)@got@tlsgd@h */ +#define R_PPC64_GOT_TLSGD16_HA 82 /* half16 (sym+add)@got@tlsgd@ha */ +#define R_PPC64_GOT_TLSLD16 83 /* half16* (sym+add)@got@tlsld */ +#define R_PPC64_GOT_TLSLD16_LO 84 /* half16 (sym+add)@got@tlsld@l */ +#define R_PPC64_GOT_TLSLD16_HI 85 /* half16 (sym+add)@got@tlsld@h */ +#define R_PPC64_GOT_TLSLD16_HA 86 /* half16 (sym+add)@got@tlsld@ha */ +#define R_PPC64_GOT_TPREL16_DS 87 /* half16ds* (sym+add)@got@tprel */ +#define R_PPC64_GOT_TPREL16_LO_DS 88 /* half16ds (sym+add)@got@tprel@l */ +#define R_PPC64_GOT_TPREL16_HI 89 /* half16 (sym+add)@got@tprel@h */ +#define R_PPC64_GOT_TPREL16_HA 90 /* half16 (sym+add)@got@tprel@ha */ +#define R_PPC64_GOT_DTPREL16_DS 91 /* half16ds* (sym+add)@got@dtprel */ +#define R_PPC64_GOT_DTPREL16_LO_DS 92 /* half16ds (sym+add)@got@dtprel@l */ +#define R_PPC64_GOT_DTPREL16_HI 93 /* half16 (sym+add)@got@dtprel@h */ +#define R_PPC64_GOT_DTPREL16_HA 94 /* half16 (sym+add)@got@dtprel@ha */ +#define R_PPC64_TPREL16_DS 95 /* half16ds* (sym+add)@tprel */ +#define R_PPC64_TPREL16_LO_DS 96 /* half16ds (sym+add)@tprel@l */ +#define R_PPC64_TPREL16_HIGHER 97 /* half16 (sym+add)@tprel@higher */ +#define R_PPC64_TPREL16_HIGHERA 98 /* half16 (sym+add)@tprel@highera */ +#define R_PPC64_TPREL16_HIGHEST 99 /* half16 (sym+add)@tprel@highest */ +#define R_PPC64_TPREL16_HIGHESTA 100 /* half16 (sym+add)@tprel@highesta */ +#define R_PPC64_DTPREL16_DS 101 /* half16ds* (sym+add)@dtprel */ +#define R_PPC64_DTPREL16_LO_DS 102 /* half16ds (sym+add)@dtprel@l */ +#define R_PPC64_DTPREL16_HIGHER 103 /* half16 (sym+add)@dtprel@higher */ +#define R_PPC64_DTPREL16_HIGHERA 104 /* half16 (sym+add)@dtprel@highera */ +#define R_PPC64_DTPREL16_HIGHEST 105 /* half16 (sym+add)@dtprel@highest */ +#define R_PPC64_DTPREL16_HIGHESTA 106 /* half16 (sym+add)@dtprel@highesta */ + +/* GNU extension to support local ifunc. */ +#define R_PPC64_JMP_IREL 247 +#define R_PPC64_IRELATIVE 248 +#define R_PPC64_REL16 249 /* half16 (sym+add-.) */ +#define R_PPC64_REL16_LO 250 /* half16 (sym+add-.)@l */ +#define R_PPC64_REL16_HI 251 /* half16 (sym+add-.)@h */ +#define R_PPC64_REL16_HA 252 /* half16 (sym+add-.)@ha */ + +/* PowerPC64 specific values for the Dyn d_tag field. */ +#define DT_PPC64_GLINK (DT_LOPROC + 0) +#define DT_PPC64_OPD (DT_LOPROC + 1) +#define DT_PPC64_OPDSZ (DT_LOPROC + 2) +#define DT_PPC64_NUM 3 + + +/* ARM specific declarations */ + +/* Processor specific flags for the ELF header e_flags field. */ +#define EF_ARM_RELEXEC 0x01 +#define EF_ARM_HASENTRY 0x02 +#define EF_ARM_INTERWORK 0x04 +#define EF_ARM_APCS_26 0x08 +#define EF_ARM_APCS_FLOAT 0x10 +#define EF_ARM_PIC 0x20 +#define EF_ARM_ALIGN8 0x40 /* 8-bit structure alignment is in use */ +#define EF_ARM_NEW_ABI 0x80 +#define EF_ARM_OLD_ABI 0x100 +#define EF_ARM_SOFT_FLOAT 0x200 +#define EF_ARM_VFP_FLOAT 0x400 +#define EF_ARM_MAVERICK_FLOAT 0x800 + + +/* Other constants defined in the ARM ELF spec. version B-01. */ +/* NB. These conflict with values defined above. */ +#define EF_ARM_SYMSARESORTED 0x04 +#define EF_ARM_DYNSYMSUSESEGIDX 0x08 +#define EF_ARM_MAPSYMSFIRST 0x10 +#define EF_ARM_EABIMASK 0XFF000000 + +/* Constants defined in AAELF. */ +#define EF_ARM_BE8 0x00800000 +#define EF_ARM_LE8 0x00400000 + +#define EF_ARM_EABI_VERSION(flags) ((flags) & EF_ARM_EABIMASK) +#define EF_ARM_EABI_UNKNOWN 0x00000000 +#define EF_ARM_EABI_VER1 0x01000000 +#define EF_ARM_EABI_VER2 0x02000000 +#define EF_ARM_EABI_VER3 0x03000000 +#define EF_ARM_EABI_VER4 0x04000000 +#define EF_ARM_EABI_VER5 0x05000000 + +/* Additional symbol types for Thumb. */ +#define STT_ARM_TFUNC STT_LOPROC /* A Thumb function. */ +#define STT_ARM_16BIT STT_HIPROC /* A Thumb label. */ + +/* ARM-specific values for sh_flags */ +#define SHF_ARM_ENTRYSECT 0x10000000 /* Section contains an entry point */ +#define SHF_ARM_COMDEF 0x80000000 /* Section may be multiply defined + in the input to a link step. */ + +/* ARM-specific program header flags */ +#define PF_ARM_SB 0x10000000 /* Segment contains the location + addressed by the static base. */ +#define PF_ARM_PI 0x20000000 /* Position-independent segment. */ +#define PF_ARM_ABS 0x40000000 /* Absolute segment. */ + +/* Processor specific values for the Phdr p_type field. */ +#define PT_ARM_EXIDX (PT_LOPROC + 1) /* ARM unwind segment. */ + +/* Processor specific values for the Shdr sh_type field. */ +#define SHT_ARM_EXIDX (SHT_LOPROC + 1) /* ARM unwind section. */ +#define SHT_ARM_PREEMPTMAP (SHT_LOPROC + 2) /* Preemption details. */ +#define SHT_ARM_ATTRIBUTES (SHT_LOPROC + 3) /* ARM attributes section. */ + + +/* ARM relocs. */ + +#define R_ARM_NONE 0 /* No reloc */ +#define R_ARM_PC24 1 /* PC relative 26 bit branch */ +#define R_ARM_ABS32 2 /* Direct 32 bit */ +#define R_ARM_REL32 3 /* PC relative 32 bit */ +#define R_ARM_PC13 4 +#define R_ARM_ABS16 5 /* Direct 16 bit */ +#define R_ARM_ABS12 6 /* Direct 12 bit */ +#define R_ARM_THM_ABS5 7 +#define R_ARM_ABS8 8 /* Direct 8 bit */ +#define R_ARM_SBREL32 9 +#define R_ARM_THM_PC22 10 +#define R_ARM_THM_PC8 11 +#define R_ARM_AMP_VCALL9 12 +#define R_ARM_SWI24 13 +#define R_ARM_THM_SWI8 14 +#define R_ARM_XPC25 15 +#define R_ARM_THM_XPC22 16 +#define R_ARM_TLS_DTPMOD32 17 /* ID of module containing symbol */ +#define R_ARM_TLS_DTPOFF32 18 /* Offset in TLS block */ +#define R_ARM_TLS_TPOFF32 19 /* Offset in static TLS block */ +#define R_ARM_COPY 20 /* Copy symbol at runtime */ +#define R_ARM_GLOB_DAT 21 /* Create GOT entry */ +#define R_ARM_JUMP_SLOT 22 /* Create PLT entry */ +#define R_ARM_RELATIVE 23 /* Adjust by program base */ +#define R_ARM_GOTOFF 24 /* 32 bit offset to GOT */ +#define R_ARM_GOTPC 25 /* 32 bit PC relative offset to GOT */ +#define R_ARM_GOT32 26 /* 32 bit GOT entry */ +#define R_ARM_PLT32 27 /* 32 bit PLT address */ +#define R_ARM_ALU_PCREL_7_0 32 +#define R_ARM_ALU_PCREL_15_8 33 +#define R_ARM_ALU_PCREL_23_15 34 +#define R_ARM_LDR_SBREL_11_0 35 +#define R_ARM_ALU_SBREL_19_12 36 +#define R_ARM_ALU_SBREL_27_20 37 +#define R_ARM_GNU_VTENTRY 100 +#define R_ARM_GNU_VTINHERIT 101 +#define R_ARM_THM_PC11 102 /* thumb unconditional branch */ +#define R_ARM_THM_PC9 103 /* thumb conditional branch */ +#define R_ARM_TLS_GD32 104 /* PC-rel 32 bit for global dynamic + thread local data */ +#define R_ARM_TLS_LDM32 105 /* PC-rel 32 bit for local dynamic + thread local data */ +#define R_ARM_TLS_LDO32 106 /* 32 bit offset relative to TLS + block */ +#define R_ARM_TLS_IE32 107 /* PC-rel 32 bit for GOT entry of + static TLS block offset */ +#define R_ARM_TLS_LE32 108 /* 32 bit offset relative to static + TLS block */ +#define R_ARM_RXPC25 249 +#define R_ARM_RSBREL32 250 +#define R_ARM_THM_RPC22 251 +#define R_ARM_RREL32 252 +#define R_ARM_RABS22 253 +#define R_ARM_RPC24 254 +#define R_ARM_RBASE 255 +/* Keep this the last entry. */ +#define R_ARM_NUM 256 + +/* IA-64 specific declarations. */ + +/* Processor specific flags for the Ehdr e_flags field. */ +#define EF_IA_64_MASKOS 0x0000000f /* os-specific flags */ +#define EF_IA_64_ABI64 0x00000010 /* 64-bit ABI */ +#define EF_IA_64_ARCH 0xff000000 /* arch. version mask */ + +/* Processor specific values for the Phdr p_type field. */ +#define PT_IA_64_ARCHEXT (PT_LOPROC + 0) /* arch extension bits */ +#define PT_IA_64_UNWIND (PT_LOPROC + 1) /* ia64 unwind bits */ +#define PT_IA_64_HP_OPT_ANOT (PT_LOOS + 0x12) +#define PT_IA_64_HP_HSL_ANOT (PT_LOOS + 0x13) +#define PT_IA_64_HP_STACK (PT_LOOS + 0x14) + +/* Processor specific flags for the Phdr p_flags field. */ +#define PF_IA_64_NORECOV 0x80000000 /* spec insns w/o recovery */ + +/* Processor specific values for the Shdr sh_type field. */ +#define SHT_IA_64_EXT (SHT_LOPROC + 0) /* extension bits */ +#define SHT_IA_64_UNWIND (SHT_LOPROC + 1) /* unwind bits */ + +/* Processor specific flags for the Shdr sh_flags field. */ +#define SHF_IA_64_SHORT 0x10000000 /* section near gp */ +#define SHF_IA_64_NORECOV 0x20000000 /* spec insns w/o recovery */ + +/* Processor specific values for the Dyn d_tag field. */ +#define DT_IA_64_PLT_RESERVE (DT_LOPROC + 0) +#define DT_IA_64_NUM 1 + +/* IA-64 relocations. */ +#define R_IA64_NONE 0x00 /* none */ +#define R_IA64_IMM14 0x21 /* symbol + addend, add imm14 */ +#define R_IA64_IMM22 0x22 /* symbol + addend, add imm22 */ +#define R_IA64_IMM64 0x23 /* symbol + addend, mov imm64 */ +#define R_IA64_DIR32MSB 0x24 /* symbol + addend, data4 MSB */ +#define R_IA64_DIR32LSB 0x25 /* symbol + addend, data4 LSB */ +#define R_IA64_DIR64MSB 0x26 /* symbol + addend, data8 MSB */ +#define R_IA64_DIR64LSB 0x27 /* symbol + addend, data8 LSB */ +#define R_IA64_GPREL22 0x2a /* @gprel(sym + add), add imm22 */ +#define R_IA64_GPREL64I 0x2b /* @gprel(sym + add), mov imm64 */ +#define R_IA64_GPREL32MSB 0x2c /* @gprel(sym + add), data4 MSB */ +#define R_IA64_GPREL32LSB 0x2d /* @gprel(sym + add), data4 LSB */ +#define R_IA64_GPREL64MSB 0x2e /* @gprel(sym + add), data8 MSB */ +#define R_IA64_GPREL64LSB 0x2f /* @gprel(sym + add), data8 LSB */ +#define R_IA64_LTOFF22 0x32 /* @ltoff(sym + add), add imm22 */ +#define R_IA64_LTOFF64I 0x33 /* @ltoff(sym + add), mov imm64 */ +#define R_IA64_PLTOFF22 0x3a /* @pltoff(sym + add), add imm22 */ +#define R_IA64_PLTOFF64I 0x3b /* @pltoff(sym + add), mov imm64 */ +#define R_IA64_PLTOFF64MSB 0x3e /* @pltoff(sym + add), data8 MSB */ +#define R_IA64_PLTOFF64LSB 0x3f /* @pltoff(sym + add), data8 LSB */ +#define R_IA64_FPTR64I 0x43 /* @fptr(sym + add), mov imm64 */ +#define R_IA64_FPTR32MSB 0x44 /* @fptr(sym + add), data4 MSB */ +#define R_IA64_FPTR32LSB 0x45 /* @fptr(sym + add), data4 LSB */ +#define R_IA64_FPTR64MSB 0x46 /* @fptr(sym + add), data8 MSB */ +#define R_IA64_FPTR64LSB 0x47 /* @fptr(sym + add), data8 LSB */ +#define R_IA64_PCREL60B 0x48 /* @pcrel(sym + add), brl */ +#define R_IA64_PCREL21B 0x49 /* @pcrel(sym + add), ptb, call */ +#define R_IA64_PCREL21M 0x4a /* @pcrel(sym + add), chk.s */ +#define R_IA64_PCREL21F 0x4b /* @pcrel(sym + add), fchkf */ +#define R_IA64_PCREL32MSB 0x4c /* @pcrel(sym + add), data4 MSB */ +#define R_IA64_PCREL32LSB 0x4d /* @pcrel(sym + add), data4 LSB */ +#define R_IA64_PCREL64MSB 0x4e /* @pcrel(sym + add), data8 MSB */ +#define R_IA64_PCREL64LSB 0x4f /* @pcrel(sym + add), data8 LSB */ +#define R_IA64_LTOFF_FPTR22 0x52 /* @ltoff(@fptr(s+a)), imm22 */ +#define R_IA64_LTOFF_FPTR64I 0x53 /* @ltoff(@fptr(s+a)), imm64 */ +#define R_IA64_LTOFF_FPTR32MSB 0x54 /* @ltoff(@fptr(s+a)), data4 MSB */ +#define R_IA64_LTOFF_FPTR32LSB 0x55 /* @ltoff(@fptr(s+a)), data4 LSB */ +#define R_IA64_LTOFF_FPTR64MSB 0x56 /* @ltoff(@fptr(s+a)), data8 MSB */ +#define R_IA64_LTOFF_FPTR64LSB 0x57 /* @ltoff(@fptr(s+a)), data8 LSB */ +#define R_IA64_SEGREL32MSB 0x5c /* @segrel(sym + add), data4 MSB */ +#define R_IA64_SEGREL32LSB 0x5d /* @segrel(sym + add), data4 LSB */ +#define R_IA64_SEGREL64MSB 0x5e /* @segrel(sym + add), data8 MSB */ +#define R_IA64_SEGREL64LSB 0x5f /* @segrel(sym + add), data8 LSB */ +#define R_IA64_SECREL32MSB 0x64 /* @secrel(sym + add), data4 MSB */ +#define R_IA64_SECREL32LSB 0x65 /* @secrel(sym + add), data4 LSB */ +#define R_IA64_SECREL64MSB 0x66 /* @secrel(sym + add), data8 MSB */ +#define R_IA64_SECREL64LSB 0x67 /* @secrel(sym + add), data8 LSB */ +#define R_IA64_REL32MSB 0x6c /* data 4 + REL */ +#define R_IA64_REL32LSB 0x6d /* data 4 + REL */ +#define R_IA64_REL64MSB 0x6e /* data 8 + REL */ +#define R_IA64_REL64LSB 0x6f /* data 8 + REL */ +#define R_IA64_LTV32MSB 0x74 /* symbol + addend, data4 MSB */ +#define R_IA64_LTV32LSB 0x75 /* symbol + addend, data4 LSB */ +#define R_IA64_LTV64MSB 0x76 /* symbol + addend, data8 MSB */ +#define R_IA64_LTV64LSB 0x77 /* symbol + addend, data8 LSB */ +#define R_IA64_PCREL21BI 0x79 /* @pcrel(sym + add), 21bit inst */ +#define R_IA64_PCREL22 0x7a /* @pcrel(sym + add), 22bit inst */ +#define R_IA64_PCREL64I 0x7b /* @pcrel(sym + add), 64bit inst */ +#define R_IA64_IPLTMSB 0x80 /* dynamic reloc, imported PLT, MSB */ +#define R_IA64_IPLTLSB 0x81 /* dynamic reloc, imported PLT, LSB */ +#define R_IA64_COPY 0x84 /* copy relocation */ +#define R_IA64_SUB 0x85 /* Addend and symbol difference */ +#define R_IA64_LTOFF22X 0x86 /* LTOFF22, relaxable. */ +#define R_IA64_LDXMOV 0x87 /* Use of LTOFF22X. */ +#define R_IA64_TPREL14 0x91 /* @tprel(sym + add), imm14 */ +#define R_IA64_TPREL22 0x92 /* @tprel(sym + add), imm22 */ +#define R_IA64_TPREL64I 0x93 /* @tprel(sym + add), imm64 */ +#define R_IA64_TPREL64MSB 0x96 /* @tprel(sym + add), data8 MSB */ +#define R_IA64_TPREL64LSB 0x97 /* @tprel(sym + add), data8 LSB */ +#define R_IA64_LTOFF_TPREL22 0x9a /* @ltoff(@tprel(s+a)), imm2 */ +#define R_IA64_DTPMOD64MSB 0xa6 /* @dtpmod(sym + add), data8 MSB */ +#define R_IA64_DTPMOD64LSB 0xa7 /* @dtpmod(sym + add), data8 LSB */ +#define R_IA64_LTOFF_DTPMOD22 0xaa /* @ltoff(@dtpmod(sym + add)), imm22 */ +#define R_IA64_DTPREL14 0xb1 /* @dtprel(sym + add), imm14 */ +#define R_IA64_DTPREL22 0xb2 /* @dtprel(sym + add), imm22 */ +#define R_IA64_DTPREL64I 0xb3 /* @dtprel(sym + add), imm64 */ +#define R_IA64_DTPREL32MSB 0xb4 /* @dtprel(sym + add), data4 MSB */ +#define R_IA64_DTPREL32LSB 0xb5 /* @dtprel(sym + add), data4 LSB */ +#define R_IA64_DTPREL64MSB 0xb6 /* @dtprel(sym + add), data8 MSB */ +#define R_IA64_DTPREL64LSB 0xb7 /* @dtprel(sym + add), data8 LSB */ +#define R_IA64_LTOFF_DTPREL22 0xba /* @ltoff(@dtprel(s+a)), imm22 */ + +/* SH specific declarations */ + +/* Processor specific flags for the ELF header e_flags field. */ +#define EF_SH_MACH_MASK 0x1f +#define EF_SH_UNKNOWN 0x0 +#define EF_SH1 0x1 +#define EF_SH2 0x2 +#define EF_SH3 0x3 +#define EF_SH_DSP 0x4 +#define EF_SH3_DSP 0x5 +#define EF_SH4AL_DSP 0x6 +#define EF_SH3E 0x8 +#define EF_SH4 0x9 +#define EF_SH2E 0xb +#define EF_SH4A 0xc +#define EF_SH2A 0xd +#define EF_SH4_NOFPU 0x10 +#define EF_SH4A_NOFPU 0x11 +#define EF_SH4_NOMMU_NOFPU 0x12 +#define EF_SH2A_NOFPU 0x13 +#define EF_SH3_NOMMU 0x14 +#define EF_SH2A_SH4_NOFPU 0x15 +#define EF_SH2A_SH3_NOFPU 0x16 +#define EF_SH2A_SH4 0x17 +#define EF_SH2A_SH3E 0x18 + +/* SH relocs. */ +#define R_SH_NONE 0 +#define R_SH_DIR32 1 +#define R_SH_REL32 2 +#define R_SH_DIR8WPN 3 +#define R_SH_IND12W 4 +#define R_SH_DIR8WPL 5 +#define R_SH_DIR8WPZ 6 +#define R_SH_DIR8BP 7 +#define R_SH_DIR8W 8 +#define R_SH_DIR8L 9 +#define R_SH_SWITCH16 25 +#define R_SH_SWITCH32 26 +#define R_SH_USES 27 +#define R_SH_COUNT 28 +#define R_SH_ALIGN 29 +#define R_SH_CODE 30 +#define R_SH_DATA 31 +#define R_SH_LABEL 32 +#define R_SH_SWITCH8 33 +#define R_SH_GNU_VTINHERIT 34 +#define R_SH_GNU_VTENTRY 35 +#define R_SH_TLS_GD_32 144 +#define R_SH_TLS_LD_32 145 +#define R_SH_TLS_LDO_32 146 +#define R_SH_TLS_IE_32 147 +#define R_SH_TLS_LE_32 148 +#define R_SH_TLS_DTPMOD32 149 +#define R_SH_TLS_DTPOFF32 150 +#define R_SH_TLS_TPOFF32 151 +#define R_SH_GOT32 160 +#define R_SH_PLT32 161 +#define R_SH_COPY 162 +#define R_SH_GLOB_DAT 163 +#define R_SH_JMP_SLOT 164 +#define R_SH_RELATIVE 165 +#define R_SH_GOTOFF 166 +#define R_SH_GOTPC 167 +/* Keep this the last entry. */ +#define R_SH_NUM 256 + +/* S/390 specific definitions. */ + +/* Valid values for the e_flags field. */ + +#define EF_S390_HIGH_GPRS 0x00000001 /* High GPRs kernel facility needed. */ + +/* Additional s390 relocs */ + +#define R_390_NONE 0 /* No reloc. */ +#define R_390_8 1 /* Direct 8 bit. */ +#define R_390_12 2 /* Direct 12 bit. */ +#define R_390_16 3 /* Direct 16 bit. */ +#define R_390_32 4 /* Direct 32 bit. */ +#define R_390_PC32 5 /* PC relative 32 bit. */ +#define R_390_GOT12 6 /* 12 bit GOT offset. */ +#define R_390_GOT32 7 /* 32 bit GOT offset. */ +#define R_390_PLT32 8 /* 32 bit PC relative PLT address. */ +#define R_390_COPY 9 /* Copy symbol at runtime. */ +#define R_390_GLOB_DAT 10 /* Create GOT entry. */ +#define R_390_JMP_SLOT 11 /* Create PLT entry. */ +#define R_390_RELATIVE 12 /* Adjust by program base. */ +#define R_390_GOTOFF32 13 /* 32 bit offset to GOT. */ +#define R_390_GOTPC 14 /* 32 bit PC relative offset to GOT. */ +#define R_390_GOT16 15 /* 16 bit GOT offset. */ +#define R_390_PC16 16 /* PC relative 16 bit. */ +#define R_390_PC16DBL 17 /* PC relative 16 bit shifted by 1. */ +#define R_390_PLT16DBL 18 /* 16 bit PC rel. PLT shifted by 1. */ +#define R_390_PC32DBL 19 /* PC relative 32 bit shifted by 1. */ +#define R_390_PLT32DBL 20 /* 32 bit PC rel. PLT shifted by 1. */ +#define R_390_GOTPCDBL 21 /* 32 bit PC rel. GOT shifted by 1. */ +#define R_390_64 22 /* Direct 64 bit. */ +#define R_390_PC64 23 /* PC relative 64 bit. */ +#define R_390_GOT64 24 /* 64 bit GOT offset. */ +#define R_390_PLT64 25 /* 64 bit PC relative PLT address. */ +#define R_390_GOTENT 26 /* 32 bit PC rel. to GOT entry >> 1. */ +#define R_390_GOTOFF16 27 /* 16 bit offset to GOT. */ +#define R_390_GOTOFF64 28 /* 64 bit offset to GOT. */ +#define R_390_GOTPLT12 29 /* 12 bit offset to jump slot. */ +#define R_390_GOTPLT16 30 /* 16 bit offset to jump slot. */ +#define R_390_GOTPLT32 31 /* 32 bit offset to jump slot. */ +#define R_390_GOTPLT64 32 /* 64 bit offset to jump slot. */ +#define R_390_GOTPLTENT 33 /* 32 bit rel. offset to jump slot. */ +#define R_390_PLTOFF16 34 /* 16 bit offset from GOT to PLT. */ +#define R_390_PLTOFF32 35 /* 32 bit offset from GOT to PLT. */ +#define R_390_PLTOFF64 36 /* 16 bit offset from GOT to PLT. */ +#define R_390_TLS_LOAD 37 /* Tag for load insn in TLS code. */ +#define R_390_TLS_GDCALL 38 /* Tag for function call in general + dynamic TLS code. */ +#define R_390_TLS_LDCALL 39 /* Tag for function call in local + dynamic TLS code. */ +#define R_390_TLS_GD32 40 /* Direct 32 bit for general dynamic + thread local data. */ +#define R_390_TLS_GD64 41 /* Direct 64 bit for general dynamic + thread local data. */ +#define R_390_TLS_GOTIE12 42 /* 12 bit GOT offset for static TLS + block offset. */ +#define R_390_TLS_GOTIE32 43 /* 32 bit GOT offset for static TLS + block offset. */ +#define R_390_TLS_GOTIE64 44 /* 64 bit GOT offset for static TLS + block offset. */ +#define R_390_TLS_LDM32 45 /* Direct 32 bit for local dynamic + thread local data in LE code. */ +#define R_390_TLS_LDM64 46 /* Direct 64 bit for local dynamic + thread local data in LE code. */ +#define R_390_TLS_IE32 47 /* 32 bit address of GOT entry for + negated static TLS block offset. */ +#define R_390_TLS_IE64 48 /* 64 bit address of GOT entry for + negated static TLS block offset. */ +#define R_390_TLS_IEENT 49 /* 32 bit rel. offset to GOT entry for + negated static TLS block offset. */ +#define R_390_TLS_LE32 50 /* 32 bit negated offset relative to + static TLS block. */ +#define R_390_TLS_LE64 51 /* 64 bit negated offset relative to + static TLS block. */ +#define R_390_TLS_LDO32 52 /* 32 bit offset relative to TLS + block. */ +#define R_390_TLS_LDO64 53 /* 64 bit offset relative to TLS + block. */ +#define R_390_TLS_DTPMOD 54 /* ID of module containing symbol. */ +#define R_390_TLS_DTPOFF 55 /* Offset in TLS block. */ +#define R_390_TLS_TPOFF 56 /* Negated offset in static TLS + block. */ +#define R_390_20 57 /* Direct 20 bit. */ +#define R_390_GOT20 58 /* 20 bit GOT offset. */ +#define R_390_GOTPLT20 59 /* 20 bit offset to jump slot. */ +#define R_390_TLS_GOTIE20 60 /* 20 bit GOT offset for static TLS + block offset. */ +/* Keep this the last entry. */ +#define R_390_NUM 61 + + +/* CRIS relocations. */ +#define R_CRIS_NONE 0 +#define R_CRIS_8 1 +#define R_CRIS_16 2 +#define R_CRIS_32 3 +#define R_CRIS_8_PCREL 4 +#define R_CRIS_16_PCREL 5 +#define R_CRIS_32_PCREL 6 +#define R_CRIS_GNU_VTINHERIT 7 +#define R_CRIS_GNU_VTENTRY 8 +#define R_CRIS_COPY 9 +#define R_CRIS_GLOB_DAT 10 +#define R_CRIS_JUMP_SLOT 11 +#define R_CRIS_RELATIVE 12 +#define R_CRIS_16_GOT 13 +#define R_CRIS_32_GOT 14 +#define R_CRIS_16_GOTPLT 15 +#define R_CRIS_32_GOTPLT 16 +#define R_CRIS_32_GOTREL 17 +#define R_CRIS_32_PLT_GOTREL 18 +#define R_CRIS_32_PLT_PCREL 19 + +#define R_CRIS_NUM 20 + + +/* AMD x86-64 relocations. */ +#define R_X86_64_NONE 0 /* No reloc */ +#define R_X86_64_64 1 /* Direct 64 bit */ +#define R_X86_64_PC32 2 /* PC relative 32 bit signed */ +#define R_X86_64_GOT32 3 /* 32 bit GOT entry */ +#define R_X86_64_PLT32 4 /* 32 bit PLT address */ +#define R_X86_64_COPY 5 /* Copy symbol at runtime */ +#define R_X86_64_GLOB_DAT 6 /* Create GOT entry */ +#define R_X86_64_JUMP_SLOT 7 /* Create PLT entry */ +#define R_X86_64_RELATIVE 8 /* Adjust by program base */ +#define R_X86_64_GOTPCREL 9 /* 32 bit signed PC relative + offset to GOT */ +#define R_X86_64_32 10 /* Direct 32 bit zero extended */ +#define R_X86_64_32S 11 /* Direct 32 bit sign extended */ +#define R_X86_64_16 12 /* Direct 16 bit zero extended */ +#define R_X86_64_PC16 13 /* 16 bit sign extended pc relative */ +#define R_X86_64_8 14 /* Direct 8 bit sign extended */ +#define R_X86_64_PC8 15 /* 8 bit sign extended pc relative */ +#define R_X86_64_DTPMOD64 16 /* ID of module containing symbol */ +#define R_X86_64_DTPOFF64 17 /* Offset in module's TLS block */ +#define R_X86_64_TPOFF64 18 /* Offset in initial TLS block */ +#define R_X86_64_TLSGD 19 /* 32 bit signed PC relative offset + to two GOT entries for GD symbol */ +#define R_X86_64_TLSLD 20 /* 32 bit signed PC relative offset + to two GOT entries for LD symbol */ +#define R_X86_64_DTPOFF32 21 /* Offset in TLS block */ +#define R_X86_64_GOTTPOFF 22 /* 32 bit signed PC relative offset + to GOT entry for IE symbol */ +#define R_X86_64_TPOFF32 23 /* Offset in initial TLS block */ +#define R_X86_64_PC64 24 /* PC relative 64 bit */ +#define R_X86_64_GOTOFF64 25 /* 64 bit offset to GOT */ +#define R_X86_64_GOTPC32 26 /* 32 bit signed pc relative + offset to GOT */ +#define R_X86_64_GOT64 27 /* 64-bit GOT entry offset */ +#define R_X86_64_GOTPCREL64 28 /* 64-bit PC relative offset + to GOT entry */ +#define R_X86_64_GOTPC64 29 /* 64-bit PC relative offset to GOT */ +#define R_X86_64_GOTPLT64 30 /* like GOT64, says PLT entry needed */ +#define R_X86_64_PLTOFF64 31 /* 64-bit GOT relative offset + to PLT entry */ +#define R_X86_64_SIZE32 32 /* Size of symbol plus 32-bit addend */ +#define R_X86_64_SIZE64 33 /* Size of symbol plus 64-bit addend */ +#define R_X86_64_GOTPC32_TLSDESC 34 /* GOT offset for TLS descriptor. */ +#define R_X86_64_TLSDESC_CALL 35 /* Marker for call through TLS + descriptor. */ +#define R_X86_64_TLSDESC 36 /* TLS descriptor. */ +#define R_X86_64_IRELATIVE 37 /* Adjust indirectly by program base */ + +#define R_X86_64_NUM 38 + + +/* AM33 relocations. */ +#define R_MN10300_NONE 0 /* No reloc. */ +#define R_MN10300_32 1 /* Direct 32 bit. */ +#define R_MN10300_16 2 /* Direct 16 bit. */ +#define R_MN10300_8 3 /* Direct 8 bit. */ +#define R_MN10300_PCREL32 4 /* PC-relative 32-bit. */ +#define R_MN10300_PCREL16 5 /* PC-relative 16-bit signed. */ +#define R_MN10300_PCREL8 6 /* PC-relative 8-bit signed. */ +#define R_MN10300_GNU_VTINHERIT 7 /* Ancient C++ vtable garbage... */ +#define R_MN10300_GNU_VTENTRY 8 /* ... collection annotation. */ +#define R_MN10300_24 9 /* Direct 24 bit. */ +#define R_MN10300_GOTPC32 10 /* 32-bit PCrel offset to GOT. */ +#define R_MN10300_GOTPC16 11 /* 16-bit PCrel offset to GOT. */ +#define R_MN10300_GOTOFF32 12 /* 32-bit offset from GOT. */ +#define R_MN10300_GOTOFF24 13 /* 24-bit offset from GOT. */ +#define R_MN10300_GOTOFF16 14 /* 16-bit offset from GOT. */ +#define R_MN10300_PLT32 15 /* 32-bit PCrel to PLT entry. */ +#define R_MN10300_PLT16 16 /* 16-bit PCrel to PLT entry. */ +#define R_MN10300_GOT32 17 /* 32-bit offset to GOT entry. */ +#define R_MN10300_GOT24 18 /* 24-bit offset to GOT entry. */ +#define R_MN10300_GOT16 19 /* 16-bit offset to GOT entry. */ +#define R_MN10300_COPY 20 /* Copy symbol at runtime. */ +#define R_MN10300_GLOB_DAT 21 /* Create GOT entry. */ +#define R_MN10300_JMP_SLOT 22 /* Create PLT entry. */ +#define R_MN10300_RELATIVE 23 /* Adjust by program base. */ + +#define R_MN10300_NUM 24 + + +/* M32R relocs. */ +#define R_M32R_NONE 0 /* No reloc. */ +#define R_M32R_16 1 /* Direct 16 bit. */ +#define R_M32R_32 2 /* Direct 32 bit. */ +#define R_M32R_24 3 /* Direct 24 bit. */ +#define R_M32R_10_PCREL 4 /* PC relative 10 bit shifted. */ +#define R_M32R_18_PCREL 5 /* PC relative 18 bit shifted. */ +#define R_M32R_26_PCREL 6 /* PC relative 26 bit shifted. */ +#define R_M32R_HI16_ULO 7 /* High 16 bit with unsigned low. */ +#define R_M32R_HI16_SLO 8 /* High 16 bit with signed low. */ +#define R_M32R_LO16 9 /* Low 16 bit. */ +#define R_M32R_SDA16 10 /* 16 bit offset in SDA. */ +#define R_M32R_GNU_VTINHERIT 11 +#define R_M32R_GNU_VTENTRY 12 +/* M32R relocs use SHT_RELA. */ +#define R_M32R_16_RELA 33 /* Direct 16 bit. */ +#define R_M32R_32_RELA 34 /* Direct 32 bit. */ +#define R_M32R_24_RELA 35 /* Direct 24 bit. */ +#define R_M32R_10_PCREL_RELA 36 /* PC relative 10 bit shifted. */ +#define R_M32R_18_PCREL_RELA 37 /* PC relative 18 bit shifted. */ +#define R_M32R_26_PCREL_RELA 38 /* PC relative 26 bit shifted. */ +#define R_M32R_HI16_ULO_RELA 39 /* High 16 bit with unsigned low */ +#define R_M32R_HI16_SLO_RELA 40 /* High 16 bit with signed low */ +#define R_M32R_LO16_RELA 41 /* Low 16 bit */ +#define R_M32R_SDA16_RELA 42 /* 16 bit offset in SDA */ +#define R_M32R_RELA_GNU_VTINHERIT 43 +#define R_M32R_RELA_GNU_VTENTRY 44 +#define R_M32R_REL32 45 /* PC relative 32 bit. */ + +#define R_M32R_GOT24 48 /* 24 bit GOT entry */ +#define R_M32R_26_PLTREL 49 /* 26 bit PC relative to PLT shifted */ +#define R_M32R_COPY 50 /* Copy symbol at runtime */ +#define R_M32R_GLOB_DAT 51 /* Create GOT entry */ +#define R_M32R_JMP_SLOT 52 /* Create PLT entry */ +#define R_M32R_RELATIVE 53 /* Adjust by program base */ +#define R_M32R_GOTOFF 54 /* 24 bit offset to GOT */ +#define R_M32R_GOTPC24 55 /* 24 bit PC relative offset to GOT */ +#define R_M32R_GOT16_HI_ULO 56 /* High 16 bit GOT entry with unsigned + low */ +#define R_M32R_GOT16_HI_SLO 57 /* High 16 bit GOT entry with signed + low */ +#define R_M32R_GOT16_LO 58 /* Low 16 bit GOT entry */ +#define R_M32R_GOTPC_HI_ULO 59 /* High 16 bit PC relative offset to + GOT with unsigned low */ +#define R_M32R_GOTPC_HI_SLO 60 /* High 16 bit PC relative offset to + GOT with signed low */ +#define R_M32R_GOTPC_LO 61 /* Low 16 bit PC relative offset to + GOT */ +#define R_M32R_GOTOFF_HI_ULO 62 /* High 16 bit offset to GOT + with unsigned low */ +#define R_M32R_GOTOFF_HI_SLO 63 /* High 16 bit offset to GOT + with signed low */ +#define R_M32R_GOTOFF_LO 64 /* Low 16 bit offset to GOT */ +#define R_M32R_NUM 256 /* Keep this the last entry. */ + + +#endif /* elf.h */ diff --git a/libguile/eq.c b/libguile/eq.c index 02ce0a9b5..5a6f574d2 100644 --- a/libguile/eq.c +++ b/libguile/eq.c @@ -372,7 +372,7 @@ scm_equal_p (SCM x, SCM y) generic_equal: if (SCM_UNPACK (g_scm_i_equal_p)) - return scm_call_generic_2 (g_scm_i_equal_p, x, y); + return scm_call_2 (g_scm_i_equal_p, x, y); else return SCM_BOOL_F; } diff --git a/libguile/error.h b/libguile/error.h index 8cc68b752..1611fd529 100644 --- a/libguile/error.h +++ b/libguile/error.h @@ -3,7 +3,7 @@ #ifndef SCM_ERROR_H #define SCM_ERROR_H -/* Copyright (C) 1995,1996,1997,1998,2000,2001, 2002, 2006, 2008 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1997,1998,2000,2001, 2002, 2006, 2008, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -36,6 +36,16 @@ SCM_API SCM scm_misc_error_key; +#define SCM_ASSERT(_cond, _arg, _pos, _subr) \ + do { if (SCM_UNLIKELY (!(_cond))) \ + scm_wrong_type_arg (_subr, _pos, _arg); } while (0) +#define SCM_ASSERT_TYPE(_cond, _arg, _pos, _subr, _msg) \ + do { if (SCM_UNLIKELY (!(_cond))) \ + scm_wrong_type_arg_msg(_subr, _pos, _arg, _msg); } while (0) + + + + SCM_API void scm_error (SCM key, const char *subr, const char *message, SCM args, SCM rest) SCM_NORETURN; SCM_API SCM scm_error_scm (SCM key, SCM subr, SCM message, diff --git a/libguile/eval.c b/libguile/eval.c index 0526f078d..f743ed78e 100644 --- a/libguile/eval.c +++ b/libguile/eval.c @@ -1,4 +1,5 @@ -/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2013 +/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004, + * 2005,2006,2007,2008,2009,2010,2011,2012,2013 * Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or @@ -230,10 +231,9 @@ eval (SCM x, SCM env) mx = SCM_MEMOIZED_ARGS (x); switch (SCM_MEMOIZED_TAG (x)) { - case SCM_M_BEGIN: - for (; !scm_is_null (CDR (mx)); mx = CDR (mx)) - eval (CAR (mx), env); - x = CAR (mx); + case SCM_M_SEQ: + eval (CAR (mx), env); + x = CDR (mx); goto loop; case SCM_M_IF: @@ -267,14 +267,14 @@ eval (SCM x, SCM env) case SCM_M_DYNWIND: { - SCM in, out, res, old_winds; + SCM in, out, res; + scm_i_thread *t = SCM_I_CURRENT_THREAD; in = EVAL1 (CAR (mx), env); out = EVAL1 (CDDR (mx), env); scm_call_0 (in); - old_winds = scm_i_dynwinds (); - scm_i_set_dynwinds (scm_acons (in, out, old_winds)); + scm_dynstack_push_dynwind (&t->dynstack, in, out); res = eval (CADR (mx), env); - scm_i_set_dynwinds (old_winds); + scm_dynstack_pop (&t->dynstack); scm_call_0 (out); return res; } @@ -282,7 +282,9 @@ eval (SCM x, SCM env) case SCM_M_WITH_FLUIDS: { long i, len; - SCM *fluidv, *valuesv, walk, wf, res; + SCM *fluidv, *valuesv, walk, res; + scm_i_thread *thread = SCM_I_CURRENT_THREAD; + len = scm_ilength (CAR (mx)); fluidv = alloca (sizeof (SCM)*len); for (i = 0, walk = CAR (mx); i < len; i++, walk = CDR (walk)) @@ -291,12 +293,10 @@ eval (SCM x, SCM env) for (i = 0, walk = CADR (mx); i < len; i++, walk = CDR (walk)) valuesv[i] = EVAL1 (CAR (walk), env); - wf = scm_i_make_with_fluids (len, fluidv, valuesv); - scm_i_swap_with_fluids (wf, SCM_I_CURRENT_THREAD->dynamic_state); - scm_i_set_dynwinds (scm_cons (wf, scm_i_dynwinds ())); + scm_dynstack_push_fluids (&thread->dynstack, len, fluidv, valuesv, + thread->dynamic_state); res = eval (CDDR (mx), env); - scm_i_swap_with_fluids (wf, SCM_I_CURRENT_THREAD->dynamic_state); - scm_i_set_dynwinds (CDR (scm_i_dynwinds ())); + scm_dynstack_unwind_fluids (&thread->dynstack, thread->dynamic_state); return res; } @@ -438,20 +438,26 @@ eval (SCM x, SCM env) case SCM_M_PROMPT: { - SCM vm, res; - /* We need the prompt and handler values after a longjmp case, - so make sure they are volatile. */ - volatile SCM handler, prompt; + SCM vm, k, res; + scm_i_jmp_buf registers; + /* We need the handler after nonlocal return to the setjmp, so + make sure it is volatile. */ + volatile SCM handler; - vm = scm_the_vm (); - prompt = scm_c_make_prompt (EVAL1 (CAR (mx), env), - SCM_VM_DATA (vm)->fp, - SCM_VM_DATA (vm)->sp, SCM_VM_DATA (vm)->ip, - 0, -1, scm_i_dynwinds ()); + k = EVAL1 (CAR (mx), env); handler = EVAL1 (CDDR (mx), env); - scm_i_set_dynwinds (scm_cons (prompt, scm_i_dynwinds ())); + vm = scm_the_vm (); + + /* Push the prompt onto the dynamic stack. */ + scm_dynstack_push_prompt (&SCM_I_CURRENT_THREAD->dynstack, + SCM_F_DYNSTACK_PROMPT_ESCAPE_ONLY, + k, + SCM_VM_DATA (vm)->fp, + SCM_VM_DATA (vm)->sp, + SCM_VM_DATA (vm)->ip, + ®isters); - if (SCM_PROMPT_SETJMP (prompt)) + if (SCM_I_SETJMP (registers)) { /* The prompt exited nonlocally. */ proc = handler; @@ -460,7 +466,7 @@ eval (SCM x, SCM env) } res = eval (CADR (mx), env); - scm_i_set_dynwinds (CDR (scm_i_dynwinds ())); + scm_dynstack_pop (&SCM_I_CURRENT_THREAD->dynstack); return res; } @@ -968,16 +974,16 @@ static int boot_closure_print (SCM closure, SCM port, scm_print_state *pstate) { SCM args; - scm_puts ("#<boot-closure ", port); - scm_uintprint ((scm_t_bits)SCM2PTR (closure), 16, port); - scm_putc (' ', port); + scm_puts_unlocked ("#<boot-closure ", port); + scm_uintprint (SCM_UNPACK (closure), 16, port); + scm_putc_unlocked (' ', port); args = scm_make_list (scm_from_int (BOOT_CLOSURE_NUM_REQUIRED_ARGS (closure)), scm_from_latin1_symbol ("_")); if (!BOOT_CLOSURE_IS_FIXED (closure) && BOOT_CLOSURE_HAS_REST_ARGS (closure)) args = scm_cons_star (scm_from_latin1_symbol ("_"), args); /* FIXME: optionals and rests */ scm_display (args, port); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); return 1; } diff --git a/libguile/evalext.c b/libguile/evalext.c index c1d46b56d..3e04a7a59 100644 --- a/libguile/evalext.c +++ b/libguile/evalext.c @@ -76,6 +76,8 @@ SCM_DEFINE (scm_self_evaluating_p, "self-evaluating?", 1, 0, 0, case scm_tc7_wvect: case scm_tc7_pointer: case scm_tc7_hashtable: + case scm_tc7_weak_set: + case scm_tc7_weak_table: case scm_tc7_fluid: case scm_tc7_dynamic_state: case scm_tc7_frame: diff --git a/libguile/evalext.h b/libguile/evalext.h index fc3f1e617..7718ec621 100644 --- a/libguile/evalext.h +++ b/libguile/evalext.h @@ -3,7 +3,7 @@ #ifndef SCM_EVALEXT_H #define SCM_EVALEXT_H -/* Copyright (C) 1998,1999,2000, 2003, 2006, 2008 Free Software Foundation, Inc. +/* Copyright (C) 1998,1999,2000, 2003, 2006, 2008, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -31,12 +31,6 @@ SCM_API SCM scm_defined_p (SCM sym, SCM env); SCM_API SCM scm_self_evaluating_p (SCM obj); SCM_INTERNAL void scm_init_evalext (void); -#if (SCM_ENABLE_DEPRECATED == 1) - -#define scm_definedp scm_defined_p - -#endif - #endif /* SCM_EVALEXT_H */ /* diff --git a/libguile/expand.c b/libguile/expand.c index cae552086..cb32e371c 100644 --- a/libguile/expand.c +++ b/libguile/expand.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2012 +/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012 * Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or @@ -74,10 +74,10 @@ static const char** exp_field_names[SCM_NUM_EXPANDED_TYPES]; SCM_MAKE_EXPANDED_TOPLEVEL_DEFINE(src, name, exp) #define CONDITIONAL(src, test, consequent, alternate) \ SCM_MAKE_EXPANDED_CONDITIONAL(src, test, consequent, alternate) -#define APPLICATION(src, proc, exps) \ - SCM_MAKE_EXPANDED_APPLICATION(src, proc, exps) -#define SEQUENCE(src, exps) \ - SCM_MAKE_EXPANDED_SEQUENCE(src, exps) +#define CALL(src, proc, exps) \ + SCM_MAKE_EXPANDED_CALL(src, proc, exps) +#define SEQ(src, head, tail) \ + SCM_MAKE_EXPANDED_SEQ(src, head, tail) #define LAMBDA(src, meta, body) \ SCM_MAKE_EXPANDED_LAMBDA(src, meta, body) #define LAMBDA_CASE(src, req, opt, rest, kw, inits, gensyms, body, alternate) \ @@ -362,9 +362,9 @@ expand (SCM exp, SCM env) arg_exps = CDR (arg_exps)) args = scm_cons (expand (CAR (arg_exps), env), args); if (scm_is_null (arg_exps)) - return APPLICATION (scm_source_properties (exp), - expand (proc, env), - scm_reverse_x (args, SCM_UNDEFINED)); + return CALL (scm_source_properties (exp), + expand (proc, env), + scm_reverse_x (args, SCM_UNDEFINED)); else syntax_error ("expected a proper list", exp, SCM_UNDEFINED); } @@ -399,7 +399,9 @@ expand_sequence (const SCM forms, const SCM env) if (scm_is_null (CDR (forms))) return expand (CAR (forms), env); else - return SEQUENCE (SCM_BOOL_F, expand_exprs (forms, env)); + return SEQ (scm_source_properties (forms), + expand (CAR (forms), env), + expand_sequence (CDR (forms), env)); } @@ -490,10 +492,10 @@ expand_cond_clauses (SCM clause, SCM rest, int elp, int alp, SCM env) scm_list_1 (expand (test, env)), CONDITIONAL (SCM_BOOL_F, LEXICAL_REF (SCM_BOOL_F, tmp, tmp), - APPLICATION (SCM_BOOL_F, - expand (CADDR (clause), new_env), - scm_list_1 (LEXICAL_REF (SCM_BOOL_F, - tmp, tmp))), + CALL (SCM_BOOL_F, + expand (CADDR (clause), new_env), + scm_list_1 (LEXICAL_REF (SCM_BOOL_F, + tmp, tmp))), rest)); } /* FIXME length == 1 case */ @@ -996,9 +998,9 @@ expand_named_let (const SCM expr, SCM env) SCM_BOOL_F, SCM_BOOL_F, var_syms, expand_sequence (CDDDR (expr), inner_env), SCM_BOOL_F))), - APPLICATION (SCM_BOOL_F, - LEXICAL_REF (SCM_BOOL_F, name, name_sym), - expand_exprs (inits, env))); + CALL (SCM_BOOL_F, + LEXICAL_REF (SCM_BOOL_F, name, name_sym), + expand_exprs (inits, env))); } static SCM @@ -1215,13 +1217,13 @@ make_exp_vtable (size_t n) (scm_string_append (scm_make_list (scm_from_size_t (exp_nfields[n]), scm_from_locale_string ("pw")))); printer = SCM_BOOL_F; - name = scm_from_locale_symbol (exp_names[n]); + name = scm_from_utf8_symbol (exp_names[n]); code = scm_from_size_t (n); fields = SCM_EOL; { size_t m = exp_nfields[n]; while (m--) - fields = scm_cons (scm_from_locale_symbol (exp_field_names[n][m]), fields); + fields = scm_cons (scm_from_utf8_symbol (exp_field_names[n][m]), fields); } return scm_c_make_struct (scm_exp_vtable_vtable, 0, 5, @@ -1246,8 +1248,9 @@ scm_init_expand () DEFINE_NAMES (TOPLEVEL_SET); DEFINE_NAMES (TOPLEVEL_DEFINE); DEFINE_NAMES (CONDITIONAL); - DEFINE_NAMES (APPLICATION); - DEFINE_NAMES (SEQUENCE); + DEFINE_NAMES (CALL); + DEFINE_NAMES (PRIMCALL); + DEFINE_NAMES (SEQ); DEFINE_NAMES (LAMBDA); DEFINE_NAMES (LAMBDA_CASE); DEFINE_NAMES (LET); diff --git a/libguile/expand.h b/libguile/expand.h index 02e6e179e..f5e7af5d4 100644 --- a/libguile/expand.h +++ b/libguile/expand.h @@ -47,8 +47,9 @@ typedef enum SCM_EXPANDED_TOPLEVEL_SET, SCM_EXPANDED_TOPLEVEL_DEFINE, SCM_EXPANDED_CONDITIONAL, - SCM_EXPANDED_APPLICATION, - SCM_EXPANDED_SEQUENCE, + SCM_EXPANDED_CALL, + SCM_EXPANDED_PRIMCALL, + SCM_EXPANDED_SEQ, SCM_EXPANDED_LAMBDA, SCM_EXPANDED_LAMBDA_CASE, SCM_EXPANDED_LET, @@ -228,30 +229,44 @@ enum #define SCM_MAKE_EXPANDED_CONDITIONAL(src, test, consequent, alternate) \ scm_c_make_struct (exp_vtables[SCM_EXPANDED_CONDITIONAL], 0, SCM_NUM_EXPANDED_CONDITIONAL_FIELDS, SCM_UNPACK (src), SCM_UNPACK (test), SCM_UNPACK (consequent), SCM_UNPACK (alternate)) -#define SCM_EXPANDED_APPLICATION_TYPE_NAME "application" -#define SCM_EXPANDED_APPLICATION_FIELD_NAMES \ +#define SCM_EXPANDED_CALL_TYPE_NAME "call" +#define SCM_EXPANDED_CALL_FIELD_NAMES \ { "src", "proc", "args", } enum { - SCM_EXPANDED_APPLICATION_SRC, - SCM_EXPANDED_APPLICATION_PROC, - SCM_EXPANDED_APPLICATION_ARGS, - SCM_NUM_EXPANDED_APPLICATION_FIELDS, + SCM_EXPANDED_CALL_SRC, + SCM_EXPANDED_CALL_PROC, + SCM_EXPANDED_CALL_ARGS, + SCM_NUM_EXPANDED_CALL_FIELDS, }; -#define SCM_MAKE_EXPANDED_APPLICATION(src, proc, args) \ - scm_c_make_struct (exp_vtables[SCM_EXPANDED_APPLICATION], 0, SCM_NUM_EXPANDED_APPLICATION_FIELDS, SCM_UNPACK (src), SCM_UNPACK (proc), SCM_UNPACK (args)) +#define SCM_MAKE_EXPANDED_CALL(src, proc, args) \ + scm_c_make_struct (exp_vtables[SCM_EXPANDED_CALL], 0, SCM_NUM_EXPANDED_CALL_FIELDS, SCM_UNPACK (src), SCM_UNPACK (proc), SCM_UNPACK (args)) -#define SCM_EXPANDED_SEQUENCE_TYPE_NAME "sequence" -#define SCM_EXPANDED_SEQUENCE_FIELD_NAMES \ - { "src", "exps", } +#define SCM_EXPANDED_PRIMCALL_TYPE_NAME "primcall" +#define SCM_EXPANDED_PRIMCALL_FIELD_NAMES \ + { "src", "name", "args", } enum { - SCM_EXPANDED_SEQUENCE_SRC, - SCM_EXPANDED_SEQUENCE_EXPS, - SCM_NUM_EXPANDED_SEQUENCE_FIELDS, + SCM_EXPANDED_PRIMCALL_SRC, + SCM_EXPANDED_PRIMCALL_NAME, + SCM_EXPANDED_PRIMCALL_ARGS, + SCM_NUM_EXPANDED_PRIMCALL_FIELDS, }; -#define SCM_MAKE_EXPANDED_SEQUENCE(src, exps) \ - scm_c_make_struct (exp_vtables[SCM_EXPANDED_SEQUENCE], 0, SCM_NUM_EXPANDED_SEQUENCE_FIELDS, SCM_UNPACK (src), SCM_UNPACK (exps)) +#define SCM_MAKE_EXPANDED_PRIMCALL(src, name, args) \ + scm_c_make_struct (exp_vtables[SCM_EXPANDED_PRIMCALL], 0, SCM_NUM_EXPANDED_PRIMCALL_FIELDS, SCM_UNPACK (src), SCM_UNPACK (name), SCM_UNPACK (args)) + +#define SCM_EXPANDED_SEQ_TYPE_NAME "seq" +#define SCM_EXPANDED_SEQ_FIELD_NAMES \ + { "src", "head", "tail", } +enum + { + SCM_EXPANDED_SEQ_SRC, + SCM_EXPANDED_SEQ_HEAD, + SCM_EXPANDED_SEQ_TAIL, + SCM_NUM_EXPANDED_SEQ_FIELDS, + }; +#define SCM_MAKE_EXPANDED_SEQ(src, head, tail) \ + scm_c_make_struct (exp_vtables[SCM_EXPANDED_SEQ], 0, SCM_NUM_EXPANDED_SEQ_FIELDS, SCM_UNPACK (src), SCM_UNPACK (head), SCM_UNPACK (tail)) #define SCM_EXPANDED_LAMBDA_TYPE_NAME "lambda" #define SCM_EXPANDED_LAMBDA_FIELD_NAMES \ diff --git a/libguile/feature.c b/libguile/feature.c index 464697508..9eb82ee7d 100644 --- a/libguile/feature.c +++ b/libguile/feature.c @@ -45,7 +45,7 @@ void scm_add_feature (const char *str) { SCM old = SCM_VARIABLE_REF (features_var); - SCM new = scm_cons (scm_from_locale_symbol (str), old); + SCM new = scm_cons (scm_from_utf8_symbol (str), old); SCM_VARIABLE_SET (features_var, new); } @@ -110,15 +110,9 @@ scm_init_feature() #ifdef vms scm_add_feature(s_ed); #endif -#ifdef SICP - scm_add_feature("sicp"); -#endif #ifndef GO32 scm_add_feature("char-ready?"); #endif -#ifndef CHEAP_CONTINUATIONS - scm_add_feature ("full-continuation"); -#endif #if SCM_USE_PTHREAD_THREADS scm_add_feature ("threads"); #endif diff --git a/libguile/filesys.c b/libguile/filesys.c index 9c39307b6..3d5b1fb3e 100644 --- a/libguile/filesys.c +++ b/libguile/filesys.c @@ -1003,7 +1003,7 @@ SCM_DEFINE (scm_fsync, "fsync", 1, 0, 0, if (SCM_OPFPORTP (object)) { - scm_flush (object); + scm_flush_unlocked (object); fdes = SCM_FPORT_FDES (object); } else @@ -1784,12 +1784,12 @@ SCM_DEFINE (scm_closedir, "closedir", 1, 0, 0, static int scm_dir_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED) { - scm_puts ("#<", port); + scm_puts_unlocked ("#<", port); if (!SCM_DIR_OPEN_P (exp)) - scm_puts ("closed: ", port); - scm_puts ("directory stream ", port); + scm_puts_unlocked ("closed: ", port); + scm_puts_unlocked ("directory stream ", port); scm_uintprint (SCM_SMOB_DATA_1 (exp), 16, port); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); return 1; } diff --git a/libguile/filesys.h b/libguile/filesys.h index 967ce7450..c420992bd 100644 --- a/libguile/filesys.h +++ b/libguile/filesys.h @@ -3,7 +3,7 @@ #ifndef SCM_FILESYS_H #define SCM_FILESYS_H -/* Copyright (C) 1995,1997,1998,1999,2000,2001, 2006, 2008, 2009, 2010 Free Software Foundation, Inc. +/* Copyright (C) 1995,1997,1998,1999,2000,2001, 2006, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -31,7 +31,7 @@ SCM_API scm_t_bits scm_tc16_dir; #define SCM_DIR_FLAG_OPEN (1L << 0) -#define SCM_DIRP(x) (!SCM_IMP (x) && (SCM_TYP16 (x) == scm_tc16_dir)) +#define SCM_DIRP(x) (SCM_HAS_TYP16 (x, scm_tc16_dir)) #define SCM_DIR_OPEN_P(x) (SCM_SMOB_FLAGS (x) & SCM_DIR_FLAG_OPEN) diff --git a/libguile/finalizers.c b/libguile/finalizers.c index a179479f5..7fadd2248 100644 --- a/libguile/finalizers.c +++ b/libguile/finalizers.c @@ -1,4 +1,4 @@ -/* Copyright (C) 2012 Free Software Foundation, Inc. +/* Copyright (C) 2012, 2013 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -23,6 +23,13 @@ # include <config.h> #endif +#ifdef HAVE_UNISTD_H +#include <unistd.h> +#endif +#include <fcntl.h> + +#include <full-write.h> + #include "libguile/bdw-gc.h" #include "libguile/_scm.h" #include "libguile/finalizers.h" @@ -36,6 +43,17 @@ static size_t finalization_count; +#ifndef HAVE_GC_SET_FINALIZER_NOTIFIER +static void +GC_set_finalizer_notifier (void (*notifier) (void)) +{ + GC_finalizer_notifier = notifier; +} +#endif + + + + void scm_i_set_finalizer (void *obj, scm_t_finalizer_proc proc, void *data) { @@ -161,13 +179,189 @@ queue_finalizer_async (void) -#ifndef HAVE_GC_SET_FINALIZER_NOTIFIER +#if SCM_USE_PTHREAD_THREADS + +static int finalization_pipe[2]; +static scm_i_pthread_mutex_t finalization_thread_lock = + SCM_I_PTHREAD_MUTEX_INITIALIZER; +static pthread_t finalization_thread; + static void -GC_set_finalizer_notifier (void (*notifier) (void)) +notify_finalizers_to_run (void) { - GC_finalizer_notifier = notifier; + char byte = 0; + full_write (finalization_pipe[1], &byte, 1); +} + +static void +notify_about_to_fork (void) +{ + char byte = 1; + full_write (finalization_pipe[1], &byte, 1); +} + +struct finalization_pipe_data +{ + char byte; + ssize_t n; + int err; +}; + +static void* +read_finalization_pipe_data (void *data) +{ + struct finalization_pipe_data *fdata = data; + + fdata->n = read (finalization_pipe[0], &fdata->byte, 1); + fdata->err = errno; + + return NULL; +} + +static void* +finalization_thread_proc (void *unused) +{ + while (1) + { + struct finalization_pipe_data data; + + scm_without_guile (read_finalization_pipe_data, &data); + + if (data.n <= 0 && data.err != EINTR) + { + perror ("error in finalization thread"); + return NULL; + } + + switch (data.byte) + { + case 0: + finalization_count += GC_invoke_finalizers (); + break; + case 1: + return NULL; + default: + abort (); + } + } +} + +static void* +run_finalization_thread (void *arg) +{ + return scm_with_guile (finalization_thread_proc, arg); +} + +static void +start_finalization_thread (void) +{ + scm_i_pthread_mutex_lock (&finalization_thread_lock); + if (!finalization_thread) + /* Use the raw pthread API and scm_with_guile, because we don't want + to block on any lock that scm_spawn_thread might want to take, + and we don't want to inherit the dynamic state (fluids) of the + caller. */ + if (pthread_create (&finalization_thread, NULL, + run_finalization_thread, NULL)) + perror ("error creating finalization thread"); + scm_i_pthread_mutex_unlock (&finalization_thread_lock); +} + +static void +stop_finalization_thread (void) +{ + scm_i_pthread_mutex_lock (&finalization_thread_lock); + if (finalization_thread) + { + notify_about_to_fork (); + if (pthread_join (finalization_thread, NULL)) + perror ("joining finalization thread"); + finalization_thread = 0; + } + scm_i_pthread_mutex_unlock (&finalization_thread_lock); +} + +static void +spawn_finalizer_thread (void) +{ + GC_set_finalizer_notifier (notify_finalizers_to_run); + start_finalization_thread (); } + +#endif /* SCM_USE_PTHREAD_THREADS */ + + + + +void +scm_i_finalizer_pre_fork (void) +{ +#if SCM_USE_PTHREAD_THREADS + stop_finalization_thread (); + GC_set_finalizer_notifier (spawn_finalizer_thread); #endif +} + + + + +static void* +weak_pointer_ref (void *weak_pointer) +{ + return *(void **) weak_pointer; +} + +static void +weak_gc_finalizer (void *ptr, void *data) +{ + void **weak = ptr; + void *val; + void (*callback) (SCM) = weak[1]; + + val = GC_call_with_alloc_lock (weak_pointer_ref, &weak[0]); + + if (!val) + return; + + callback (SCM_PACK_POINTER (val)); + + scm_i_set_finalizer (ptr, weak_gc_finalizer, data); +} + +/* CALLBACK will be called on OBJ, as long as OBJ is accessible. It + will be called from a finalizer, which may be from an async or from + another thread. + + As an implementation detail, the way this works is that we allocate + a fresh pointer-less object holding two words. We know that this + object should get collected the next time GC is run, so we attach a + finalizer to it so that we get a callback after GC happens. + + The first word of the object holds a weak reference to OBJ, and the + second holds the callback pointer. When the callback is called, we + check if the weak reference on OBJ still holds. If it doesn't hold, + then OBJ is no longer accessible, and we're done. Otherwise we call + the callback and re-register a finalizer for our two-word GC object, + effectively resuscitating the object so that we will get a callback + on the next GC. + + We could use the scm_after_gc_hook, but using a finalizer has the + advantage of potentially running in another thread, decreasing pause + time. */ +void +scm_i_register_weak_gc_callback (SCM obj, void (*callback) (SCM)) +{ + void **weak = GC_MALLOC_ATOMIC (sizeof (void*) * 2); + + weak[0] = SCM_UNPACK_POINTER (obj); + weak[1] = (void*)callback; + GC_GENERAL_REGISTER_DISAPPEARING_LINK (weak, SCM2PTR (obj)); + + scm_i_set_finalizer (weak, weak_gc_finalizer, NULL); +} + + + void scm_init_finalizers (void) @@ -180,3 +374,13 @@ scm_init_finalizers (void) SCM_BOOL_F); GC_set_finalizer_notifier (queue_finalizer_async); } + +void +scm_init_finalizer_thread (void) +{ +#if SCM_USE_PTHREAD_THREADS + if (pipe2 (finalization_pipe, O_CLOEXEC) != 0) + scm_syserror (NULL); + GC_set_finalizer_notifier (spawn_finalizer_thread); +#endif +} diff --git a/libguile/finalizers.h b/libguile/finalizers.h index bad96e145..2ef075197 100644 --- a/libguile/finalizers.h +++ b/libguile/finalizers.h @@ -1,7 +1,7 @@ #ifndef SCM_FINALIZERS_H #define SCM_FINALIZERS_H -/* Copyright (C) 2012 Free Software Foundation, Inc. +/* Copyright (C) 2012, 2013 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -34,6 +34,14 @@ SCM_INTERNAL void scm_i_add_finalizer (void *obj, scm_t_finalizer_proc, SCM_INTERNAL void scm_i_add_resuscitator (void *obj, scm_t_finalizer_proc, void *data); +SCM_INTERNAL void scm_i_finalizer_pre_fork (void); + +/* CALLBACK will be called on OBJ after each garbage collection, as long + as OBJ is accessible. It will be called from a finalizer, which may + be from an async or from another thread. */ +SCM_INTERNAL void scm_i_register_weak_gc_callback (SCM obj, void (*callback) (SCM)); + SCM_INTERNAL void scm_init_finalizers (void); +SCM_INTERNAL void scm_init_finalizer_thread (void); #endif /* SCM_FINALIZERS_H */ diff --git a/libguile/fluids.c b/libguile/fluids.c index f1c09cb30..8e36acde6 100644 --- a/libguile/fluids.c +++ b/libguile/fluids.c @@ -20,7 +20,6 @@ # include <config.h> #endif -#include <alloca.h> #include <stdio.h> #include <string.h> @@ -79,25 +78,17 @@ grow_dynamic_state (SCM state) void scm_i_fluid_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED) { - scm_puts ("#<fluid ", port); + scm_puts_unlocked ("#<fluid ", port); scm_intprint ((int) FLUID_NUM (exp), 10, port); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); } void scm_i_dynamic_state_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED) { - scm_puts ("#<dynamic-state ", port); + scm_puts_unlocked ("#<dynamic-state ", port); scm_intprint (SCM_UNPACK (exp), 16, port); - scm_putc ('>', port); -} - -void -scm_i_with_fluids_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED) -{ - scm_puts ("#<with-fluids ", port); - scm_intprint (SCM_UNPACK (exp), 16, port); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); } @@ -156,7 +147,7 @@ new_fluid (SCM init) allocated_fluids_len += FLUID_GROW; } - allocated_fluids[n] = SCM2PTR (fluid); + allocated_fluids[n] = SCM_UNPACK_POINTER (fluid); SCM_SET_CELL_WORD_0 (fluid, (scm_tc7_fluid | (n << 8))); GC_GENERAL_REGISTER_DISAPPEARING_LINK (&allocated_fluids[n], @@ -310,76 +301,67 @@ apply_thunk (void *thunk) return scm_call_0 (SCM_PACK (thunk)); } -SCM -scm_i_make_with_fluids (size_t n, SCM *fluids, SCM *vals) +size_t +scm_prepare_fluids (size_t n, SCM *fluids, SCM *values) { - SCM ret; + size_t j = n; /* Ensure that there are no duplicates in the fluids set -- an N^2 operation, but N will usually be small, so perhaps that's OK. */ - { - size_t i, j = n; + while (j--) + { + size_t i; + + if (SCM_UNLIKELY (!IS_FLUID (fluids[j]))) + scm_wrong_type_arg ("with-fluids", 0, fluids[j]); - while (j--) for (i = 0; i < j; i++) if (scm_is_eq (fluids[i], fluids[j])) { - vals[i] = vals[j]; /* later bindings win */ + values[i] = values[j]; /* later bindings win */ n--; break; } - } - - ret = scm_words (scm_tc7_with_fluids | (n << 8), 1 + n*2); - SCM_SET_CELL_WORD_1 (ret, n); - - while (n--) - { - if (SCM_UNLIKELY (!IS_FLUID (fluids[n]))) - scm_wrong_type_arg ("with-fluids", 0, fluids[n]); - SCM_SET_CELL_OBJECT (ret, 1 + n * 2, fluids[n]); - SCM_SET_CELL_OBJECT (ret, 2 + n * 2, vals[n]); } - return ret; + return n; } void -scm_i_swap_with_fluids (SCM wf, SCM dynstate) +scm_swap_fluids (size_t n, SCM *fluids, SCM *values, SCM dynstate) { - SCM fluids; + SCM fluid_vector; size_t i, max = 0; - fluids = DYNAMIC_STATE_FLUIDS (dynstate); + fluid_vector = DYNAMIC_STATE_FLUIDS (dynstate); /* We could cache the max in the with-fluids, but that would take more mem, and we're touching all the fluids anyway, so this per-swap traversal should be OK. */ - for (i = 0; i < SCM_WITH_FLUIDS_LEN (wf); i++) + for (i = 0; i < n; i++) { - size_t num = FLUID_NUM (SCM_WITH_FLUIDS_NTH_FLUID (wf, i)); + size_t num = FLUID_NUM (fluids[i]); max = (max > num) ? max : num; } - if (SCM_UNLIKELY (max >= SCM_SIMPLE_VECTOR_LENGTH (fluids))) + if (SCM_UNLIKELY (max >= SCM_SIMPLE_VECTOR_LENGTH (fluid_vector))) { /* Lazily grow the current thread's dynamic state. */ grow_dynamic_state (dynstate); - fluids = DYNAMIC_STATE_FLUIDS (dynstate); + fluid_vector = DYNAMIC_STATE_FLUIDS (dynstate); } /* Bind the fluids. Order doesn't matter, as all fluids are distinct. */ - for (i = 0; i < SCM_WITH_FLUIDS_LEN (wf); i++) + for (i = 0; i < n; i++) { size_t fluid_num; SCM x; - fluid_num = FLUID_NUM (SCM_WITH_FLUIDS_NTH_FLUID (wf, i)); - x = SCM_SIMPLE_VECTOR_REF (fluids, fluid_num); - SCM_SIMPLE_VECTOR_SET (fluids, fluid_num, - SCM_WITH_FLUIDS_NTH_VAL (wf, i)); - SCM_WITH_FLUIDS_SET_NTH_VAL (wf, i, x); + fluid_num = FLUID_NUM (fluids[i]); + x = SCM_SIMPLE_VECTOR_REF (fluid_vector, fluid_num); + SCM_SIMPLE_VECTOR_SET (fluid_vector, fluid_num, values[i]); + values[i] = x; } } @@ -400,9 +382,10 @@ SCM scm_c_with_fluids (SCM fluids, SCM values, SCM (*cproc) (), void *cdata) #define FUNC_NAME "scm_c_with_fluids" { - SCM wf, ans; + SCM ans; long flen, vlen, i; SCM *fluidsv, *valuesv; + scm_i_thread *thread = SCM_I_CURRENT_THREAD; SCM_VALIDATE_LIST_COPYLEN (1, fluids, flen); SCM_VALIDATE_LIST_COPYLEN (2, values, vlen); @@ -423,12 +406,10 @@ scm_c_with_fluids (SCM fluids, SCM values, SCM (*cproc) (), void *cdata) values = SCM_CDR (values); } - wf = scm_i_make_with_fluids (flen, fluidsv, valuesv); - scm_i_swap_with_fluids (wf, SCM_I_CURRENT_THREAD->dynamic_state); - scm_i_set_dynwinds (scm_cons (wf, scm_i_dynwinds ())); + scm_dynstack_push_fluids (&thread->dynstack, flen, fluidsv, valuesv, + thread->dynamic_state); ans = cproc (cdata); - scm_i_swap_with_fluids (wf, SCM_I_CURRENT_THREAD->dynamic_state); - scm_i_set_dynwinds (scm_cdr (scm_i_dynwinds ())); + scm_dynstack_unwind_fluids (&thread->dynstack, thread->dynamic_state); return ans; } @@ -449,14 +430,13 @@ SCM scm_c_with_fluid (SCM fluid, SCM value, SCM (*cproc) (), void *cdata) #define FUNC_NAME "scm_c_with_fluid" { - SCM ans, wf; + SCM ans; + scm_i_thread *thread = SCM_I_CURRENT_THREAD; - wf = scm_i_make_with_fluids (1, &fluid, &value); - scm_i_swap_with_fluids (wf, SCM_I_CURRENT_THREAD->dynamic_state); - scm_i_set_dynwinds (scm_cons (wf, scm_i_dynwinds ())); + scm_dynstack_push_fluids (&thread->dynstack, 1, &fluid, &value, + thread->dynamic_state); ans = cproc (cdata); - scm_i_swap_with_fluids (wf, SCM_I_CURRENT_THREAD->dynamic_state); - scm_i_set_dynwinds (scm_cdr (scm_i_dynwinds ())); + scm_dynstack_unwind_fluids (&thread->dynstack, thread->dynamic_state); return ans; } diff --git a/libguile/fluids.h b/libguile/fluids.h index 2b91ff3d1..227877251 100644 --- a/libguile/fluids.h +++ b/libguile/fluids.h @@ -3,7 +3,7 @@ #ifndef SCM_FLUIDS_H #define SCM_FLUIDS_H -/* Copyright (C) 1996,2000,2001, 2006, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. +/* Copyright (C) 1996,2000,2001, 2006, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -27,17 +27,6 @@ #include "libguile/root.h" #include "libguile/vectors.h" -/* These "with-fluids" objects live on the dynamic stack, and record previous - values of fluids. Guile uses shallow binding, so the current fluid values are - always in the same place for a given thread, in the dynamic-state vector. - */ - -#define SCM_WITH_FLUIDS_P(x) (!SCM_IMP (x) && SCM_TYP7(x) == scm_tc7_with_fluids) -#define SCM_WITH_FLUIDS_LEN(x) (SCM_CELL_WORD ((x), 0) >> 8) -#define SCM_WITH_FLUIDS_NTH_FLUID(x,n) (SCM_CELL_OBJECT ((x), 1 + (n)*2)) -#define SCM_WITH_FLUIDS_NTH_VAL(x,n) (SCM_CELL_OBJECT ((x), 2 + (n)*2)) -#define SCM_WITH_FLUIDS_SET_NTH_VAL(x,n,v) (SCM_SET_CELL_OBJECT ((x), 2 + (n)*2, (v))) - /* Fluids. @@ -54,7 +43,7 @@ grow. */ -#define SCM_FLUID_P(x) (!SCM_IMP (x) && SCM_TYP7 (x) == scm_tc7_fluid) +#define SCM_FLUID_P(x) (SCM_HAS_TYP7 (x, scm_tc7_fluid)) #ifdef BUILDING_LIBGUILE #define SCM_I_FLUID_NUM(x) ((size_t)(SCM_CELL_WORD_0 (x) >> 8)) #define SCM_I_FLUID_DEFAULT(x) (SCM_CELL_OBJECT_1 (x)) @@ -70,8 +59,9 @@ SCM_API SCM scm_fluid_set_x (SCM fluid, SCM value); SCM_API SCM scm_fluid_unset_x (SCM fluid); SCM_API SCM scm_fluid_bound_p (SCM fluid); -SCM_INTERNAL SCM scm_i_make_with_fluids (size_t n, SCM *fluids, SCM *vals); -SCM_INTERNAL void scm_i_swap_with_fluids (SCM with_fluids, SCM dynamic_state); +SCM_INTERNAL size_t scm_prepare_fluids (size_t n, SCM *fluids, SCM *vals); +SCM_INTERNAL void scm_swap_fluids (size_t n, SCM *fluids, SCM *vals, + SCM dynamic_state); SCM_API SCM scm_c_with_fluids (SCM fluids, SCM vals, SCM (*cproc)(void *), void *cdata); @@ -83,7 +73,7 @@ SCM_API SCM scm_with_fluid (SCM fluid, SCM val, SCM thunk); SCM_API void scm_dynwind_fluid (SCM fluid, SCM value); #ifdef BUILDING_LIBGUILE -#define SCM_I_DYNAMIC_STATE_P(x) (!SCM_IMP (x) && SCM_TYP7 (x) == scm_tc7_dynamic_state) +#define SCM_I_DYNAMIC_STATE_P(x) (SCM_HAS_TYP7 (x, scm_tc7_dynamic_state)) #define SCM_I_DYNAMIC_STATE_FLUIDS(x) SCM_PACK (SCM_CELL_WORD_1 (x)) #endif @@ -101,7 +91,6 @@ SCM_INTERNAL SCM scm_i_make_initial_dynamic_state (void); SCM_INTERNAL void scm_i_fluid_print (SCM exp, SCM port, scm_print_state *pstate); SCM_INTERNAL void scm_i_dynamic_state_print (SCM exp, SCM port, scm_print_state *pstate); -SCM_INTERNAL void scm_i_with_fluids_print (SCM exp, SCM port, scm_print_state *pstate); SCM_INTERNAL void scm_init_fluids (void); #endif /* SCM_FLUIDS_H */ diff --git a/libguile/foreign.c b/libguile/foreign.c index f5819c455..c81c5f407 100644 --- a/libguile/foreign.c +++ b/libguile/foreign.c @@ -89,22 +89,19 @@ static SCM cif_to_procedure (SCM cif, SCM func_ptr); static SCM pointer_weak_refs = SCM_BOOL_F; -static scm_i_pthread_mutex_t weak_refs_lock = SCM_I_PTHREAD_MUTEX_INITIALIZER; static void register_weak_reference (SCM from, SCM to) { - scm_i_pthread_mutex_lock (&weak_refs_lock); - scm_hashq_set_x (pointer_weak_refs, from, to); - scm_i_pthread_mutex_unlock (&weak_refs_lock); + scm_weak_table_putq_x (pointer_weak_refs, from, to); } static void pointer_finalizer_trampoline (void *ptr, void *data) { scm_t_pointer_finalizer finalizer = data; - finalizer (SCM_POINTER_VALUE (PTR2SCM (ptr))); + finalizer (SCM_POINTER_VALUE (SCM_PACK_POINTER (ptr))); } SCM_DEFINE (scm_pointer_p, "pointer?", 1, 0, 0, @@ -201,7 +198,7 @@ SCM_DEFINE (scm_scm_to_pointer, "scm->pointer", 1, 0, 0, SCM ret; ret = scm_from_pointer ((void*) SCM_UNPACK (scm), NULL); - if (SCM_NIMP (ret)) + if (SCM_HEAP_OBJECT_P (ret)) register_weak_reference (ret, scm); return ret; @@ -273,8 +270,8 @@ SCM_DEFINE (scm_pointer_to_bytevector, "pointer->bytevector", 2, 2, 0, blen = scm_to_size_t (len); ret = scm_c_take_typed_bytevector ((signed char *) ptr + boffset, - blen, btype); - register_weak_reference (ret, pointer); + blen, btype, pointer); + return ret; } #undef FUNC_NAME @@ -326,9 +323,9 @@ SCM_DEFINE (scm_set_pointer_finalizer_x, "set-pointer-finalizer!", 2, 0, 0, void scm_i_pointer_print (SCM pointer, SCM port, scm_print_state *pstate) { - scm_puts ("#<pointer 0x", port); + scm_puts_unlocked ("#<pointer 0x", port); scm_uintprint (scm_to_uintptr (scm_pointer_address (pointer)), 16, port); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); } @@ -541,13 +538,14 @@ SCM_DEFINE (scm_sizeof, "sizeof", 1, 0, 0, (SCM type), { /* a struct */ size_t off = 0; + size_t align = scm_to_size_t (scm_alignof(type)); while (scm_is_pair (type)) { off = ROUND_UP (off, scm_to_size_t (scm_alignof (scm_car (type)))); off += scm_to_size_t (scm_sizeof (scm_car (type))); type = scm_cdr (type); } - return scm_from_size_t (off); + return scm_from_size_t (ROUND_UP(off, align)); } else scm_wrong_type_arg (FUNC_NAME, 1, type); @@ -1120,7 +1118,7 @@ invoke_closure (ffi_cif *cif, void *ret, void **args, void *data) size_t i; SCM proc, *argv, result; - proc = PTR2SCM (data); + proc = SCM_PACK_POINTER (data); argv = alloca (cif->nargs * sizeof (*argv)); @@ -1151,7 +1149,7 @@ SCM_DEFINE (scm_procedure_to_pointer, "procedure->pointer", 3, 0, 0, closure = ffi_closure_alloc (sizeof (ffi_closure), &executable); err = ffi_prep_closure_loc ((ffi_closure *) closure, cif, - invoke_closure, SCM2PTR (proc), + invoke_closure, SCM_UNPACK_POINTER (proc), executable); if (err != FFI_OK) { @@ -1317,7 +1315,7 @@ scm_register_foreign (void) "scm_init_foreign", (scm_t_extension_init_func)scm_init_foreign, NULL); - pointer_weak_refs = scm_make_weak_key_hash_table (SCM_UNDEFINED); + pointer_weak_refs = scm_c_make_weak_table (0, SCM_WEAK_TABLE_KIND_KEY); } /* diff --git a/libguile/foreign.h b/libguile/foreign.h index 41c0b657d..172fa24e3 100644 --- a/libguile/foreign.h +++ b/libguile/foreign.h @@ -48,8 +48,7 @@ typedef enum scm_t_foreign_type scm_t_foreign_type; typedef void (*scm_t_pointer_finalizer) (void *); -#define SCM_POINTER_P(x) \ - (!SCM_IMP (x) && SCM_TYP7(x) == scm_tc7_pointer) +#define SCM_POINTER_P(x) (SCM_HAS_TYP7 (x, scm_tc7_pointer)) #define SCM_VALIDATE_POINTER(pos, x) \ SCM_MAKE_VALIDATE (pos, x, POINTER_P) #define SCM_POINTER_VALUE(x) \ diff --git a/libguile/fports.c b/libguile/fports.c index 10cf6713a..94ce434d1 100644 --- a/libguile/fports.c +++ b/libguile/fports.c @@ -229,7 +229,7 @@ SCM_DEFINE (scm_setvbuf, "setvbuf", 2, 1, 0, ndrained = 0; if (SCM_OUTPUT_PORT_P (port)) - scm_flush (port); + scm_flush_unlocked (port); if (pt->read_buf == pt->putback_buf) { @@ -550,7 +550,7 @@ scm_i_fdes_to_port (int fdes, long mode_bits, SCM name) #define FUNC_NAME "scm_fdes_to_port" { SCM port; - scm_t_port *pt; + scm_t_fport *fp; int flags; /* test that fdes is valid. */ @@ -569,26 +569,21 @@ scm_i_fdes_to_port (int fdes, long mode_bits, SCM name) SCM_MISC_ERROR ("requested file mode not available on fdes", SCM_EOL); } - scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex); + fp = (scm_t_fport *) scm_gc_malloc_pointerless (sizeof (scm_t_fport), + "file port"); + fp->fdes = fdes; + + port = scm_c_make_port (scm_tc16_fport, mode_bits, (scm_t_bits)fp); + + SCM_PTAB_ENTRY (port)->rw_random = SCM_FDES_RANDOM_P (fdes); + + if (mode_bits & SCM_BUF0) + scm_fport_buffer_add (port, 0, 0); + else + scm_fport_buffer_add (port, -1, -1); - port = scm_new_port_table_entry (scm_tc16_fport); - SCM_SET_CELL_TYPE(port, scm_tc16_fport | mode_bits); - pt = SCM_PTAB_ENTRY(port); - { - scm_t_fport *fp - = (scm_t_fport *) scm_gc_malloc_pointerless (sizeof (scm_t_fport), - "file port"); - - fp->fdes = fdes; - pt->rw_random = SCM_FDES_RANDOM_P (fdes); - SCM_SETSTREAM (port, fp); - if (mode_bits & SCM_BUF0) - scm_fport_buffer_add (port, 0, 0); - else - scm_fport_buffer_add (port, -1, -1); - } SCM_SET_FILENAME (port, name); - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); + return port; } #undef FUNC_NAME @@ -653,11 +648,108 @@ fport_input_waiting (SCM port) #endif } + + + +/* Revealed counts --- an oddity inherited from SCSH. */ + +#define SCM_REVEALED(x) (SCM_FSTREAM(x)->revealed) + +static SCM revealed_ports = SCM_EOL; +static scm_i_pthread_mutex_t revealed_lock = SCM_I_PTHREAD_MUTEX_INITIALIZER; + +/* Find a port in the table and return its revealed count. + Also used by the garbage collector. + */ +int +scm_revealed_count (SCM port) +{ + int ret; + + scm_i_pthread_mutex_lock (&revealed_lock); + ret = SCM_REVEALED (port); + scm_i_pthread_mutex_unlock (&revealed_lock); + + return ret; +} + +SCM_DEFINE (scm_port_revealed, "port-revealed", 1, 0, 0, + (SCM port), + "Return the revealed count for @var{port}.") +#define FUNC_NAME s_scm_port_revealed +{ + port = SCM_COERCE_OUTPORT (port); + SCM_VALIDATE_OPFPORT (1, port); + return scm_from_int (scm_revealed_count (port)); +} +#undef FUNC_NAME + +/* Set the revealed count for a port. */ +SCM_DEFINE (scm_set_port_revealed_x, "set-port-revealed!", 2, 0, 0, + (SCM port, SCM rcount), + "Sets the revealed count for a port to a given value.\n" + "The return value is unspecified.") +#define FUNC_NAME s_scm_set_port_revealed_x +{ + int r, prev; + + port = SCM_COERCE_OUTPORT (port); + SCM_VALIDATE_OPFPORT (1, port); + + r = scm_to_int (rcount); + + scm_i_pthread_mutex_lock (&revealed_lock); + + prev = SCM_REVEALED (port); + SCM_REVEALED (port) = r; + + if (r && !prev) + revealed_ports = scm_cons (port, revealed_ports); + else if (prev && !r) + revealed_ports = scm_delq_x (port, revealed_ports); + + scm_i_pthread_mutex_unlock (&revealed_lock); + + return SCM_UNSPECIFIED; +} +#undef FUNC_NAME + +/* Set the revealed count for a port. */ +SCM_DEFINE (scm_adjust_port_revealed_x, "adjust-port-revealed!", 2, 0, 0, + (SCM port, SCM addend), + "Add @var{addend} to the revealed count of @var{port}.\n" + "The return value is unspecified.") +#define FUNC_NAME s_scm_adjust_port_revealed_x +{ + int a; + + port = SCM_COERCE_OUTPORT (port); + SCM_VALIDATE_OPFPORT (1, port); + + a = scm_to_int (addend); + if (!a) + return SCM_UNSPECIFIED; + + scm_i_pthread_mutex_lock (&revealed_lock); + + SCM_REVEALED (port) += a; + if (SCM_REVEALED (port) == a) + revealed_ports = scm_cons (port, revealed_ports); + else if (!SCM_REVEALED (port)) + revealed_ports = scm_delq_x (port, revealed_ports); + + scm_i_pthread_mutex_unlock (&revealed_lock); + + return SCM_UNSPECIFIED; +} +#undef FUNC_NAME + + static int fport_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED) { - scm_puts ("#<", port); + scm_puts_unlocked ("#<", port); scm_print_port_mode (exp, port); if (SCM_OPFPORTP (exp)) { @@ -666,8 +758,8 @@ fport_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED) if (scm_is_string (name) || scm_is_symbol (name)) scm_display (name, port); else - scm_puts (SCM_PTOBNAME (SCM_PTOBNUM (exp)), port); - scm_putc (' ', port); + scm_puts_unlocked (SCM_PTOBNAME (SCM_PTOBNUM (exp)), port); + scm_putc_unlocked (' ', port); fdes = (SCM_FSTREAM (exp))->fdes; #if (defined HAVE_TTYNAME) && (defined HAVE_POSIX) @@ -679,11 +771,11 @@ fport_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED) } else { - scm_puts (SCM_PTOBNAME (SCM_PTOBNUM (exp)), port); - scm_putc (' ', port); + scm_puts_unlocked (SCM_PTOBNAME (SCM_PTOBNUM (exp)), port); + scm_putc_unlocked (' ', port); scm_uintprint ((scm_t_bits) SCM_PTAB_ENTRY (exp), 16, port); } - scm_putc ('>', port); + scm_putc_unlocked ('>', port); return 1; } @@ -738,7 +830,7 @@ fport_seek (SCM port, scm_t_off offset, int whence) if (offset != 0 || whence != SEEK_CUR) { /* could expand to avoid a second seek. */ - scm_end_input (port); + scm_end_input_unlocked (port); result = rv = lseek_or_lseek64 (fp->fdes, offset, whence); } else @@ -872,32 +964,38 @@ fport_end_input (SCM port, int offset) pt->rw_active = SCM_PORT_NEITHER; } +static void +close_the_fd (void *data) +{ + scm_t_fport *fp = data; + + close (fp->fdes); + /* There's already one exception. That's probably enough! */ + errno = 0; +} + static int fport_close (SCM port) { scm_t_fport *fp = SCM_FSTREAM (port); - scm_t_port *pt = SCM_PTAB_ENTRY (port); int rv; + scm_dynwind_begin (0); + scm_dynwind_unwind_handler (close_the_fd, fp, 0); fport_flush (port); - SCM_SYSCALL (rv = close (fp->fdes)); - if (rv == -1 && errno != EBADF) - { - if (scm_gc_running_p) - /* silently ignore the error. scm_error would abort if we - called it now. */ - ; - else - scm_syserror ("fport_close"); - } - if (pt->read_buf == pt->putback_buf) - pt->read_buf = pt->saved_read_buf; - if (pt->read_buf != &pt->shortbuf) - scm_gc_free (pt->read_buf, pt->read_buf_size, "port buffer"); - if (pt->write_buf != &pt->shortbuf) - scm_gc_free (pt->write_buf, pt->write_buf_size, "port buffer"); - scm_gc_free (fp, sizeof (*fp), "file port"); - return rv; + scm_dynwind_end (); + + scm_port_non_buffer (SCM_PTAB_ENTRY (port)); + + rv = close (fp->fdes); + if (rv) + /* It's not useful to retry after EINTR, as the file descriptor is + in an undefined state. See http://lwn.net/Articles/365294/. + Instead just throw an error if close fails, trusting that the fd + was cleaned up. */ + scm_syserror ("fport_close"); + + return 0; } static size_t diff --git a/libguile/fports.h b/libguile/fports.h index cbef0f8ec..4094f14cd 100644 --- a/libguile/fports.h +++ b/libguile/fports.h @@ -3,7 +3,7 @@ #ifndef SCM_FPORTS_H #define SCM_FPORTS_H -/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001, 2006, 2008, 2009 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001, 2006, 2008, 2009, 2011, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -32,6 +32,9 @@ /* struct allocated for each buffered FPORT. */ typedef struct scm_t_fport { int fdes; /* file descriptor. */ + int revealed; /* 0 not revealed, > 1 revealed. + * Revealed ports do not get GC'd. + */ } scm_t_fport; SCM_API scm_t_bits scm_tc16_fport; @@ -39,7 +42,7 @@ SCM_API scm_t_bits scm_tc16_fport; #define SCM_FSTREAM(x) ((scm_t_fport *) SCM_STREAM (x)) #define SCM_FPORT_FDES(x) (SCM_FSTREAM (x)->fdes) -#define SCM_FPORTP(x) (!SCM_IMP (x) && (SCM_TYP16 (x) == scm_tc16_fport)) +#define SCM_FPORTP(x) (SCM_HAS_TYP16 (x, scm_tc16_fport)) #define SCM_OPFPORTP(x) (SCM_FPORTP (x) && (SCM_CELL_WORD_0 (x) & SCM_OPN)) #define SCM_OPINFPORTP(x) (SCM_OPFPORTP (x) && (SCM_CELL_WORD_0 (x) & SCM_RDNG)) #define SCM_OPOUTFPORTP(x) (SCM_OPFPORTP (x) && (SCM_CELL_WORD_0 (x) & SCM_WRTNG)) @@ -54,6 +57,15 @@ SCM_API void scm_evict_ports (int fd); SCM_API SCM scm_open_file (SCM filename, SCM modes); SCM_API SCM scm_fdes_to_port (int fdes, char *mode, SCM name); SCM_API SCM scm_file_port_p (SCM obj); + + +/* Revealed counts. */ +SCM_API int scm_revealed_count (SCM port); +SCM_API SCM scm_port_revealed (SCM port); +SCM_API SCM scm_set_port_revealed_x (SCM port, SCM rcount); +SCM_API SCM scm_adjust_port_revealed_x (SCM port, SCM addend); + + SCM_INTERNAL void scm_init_fports (void); /* internal functions */ diff --git a/libguile/frames.c b/libguile/frames.c index a7143c411..0338d18db 100644 --- a/libguile/frames.c +++ b/libguile/frames.c @@ -52,12 +52,12 @@ scm_c_make_frame (SCM stack_holder, SCM *fp, SCM *sp, void scm_i_frame_print (SCM frame, SCM port, scm_print_state *pstate) { - scm_puts ("#<frame ", port); + scm_puts_unlocked ("#<frame ", port); scm_uintprint (SCM_UNPACK (frame), 16, port); - scm_putc (' ', port); + scm_putc_unlocked (' ', port); scm_write (scm_frame_procedure (frame), port); /* don't write args, they can get us into trouble. */ - scm_puts (">", port); + scm_puts_unlocked (">", port); } diff --git a/libguile/frames.h b/libguile/frames.h index eaed79d43..71d5b124d 100644 --- a/libguile/frames.h +++ b/libguile/frames.h @@ -112,7 +112,7 @@ struct scm_frame scm_t_ptrdiff offset; }; -#define SCM_VM_FRAME_P(x) (SCM_NIMP (x) && SCM_TYP7 (x) == scm_tc7_frame) +#define SCM_VM_FRAME_P(x) (SCM_HAS_TYP7 (x, scm_tc7_frame)) #define SCM_VM_FRAME_DATA(x) ((struct scm_frame*)SCM_CELL_WORD_1 (x)) #define SCM_VM_FRAME_STACK_HOLDER(f) SCM_VM_FRAME_DATA(f)->stack_holder #define SCM_VM_FRAME_FP(f) SCM_VM_FRAME_DATA(f)->fp diff --git a/libguile/gc-malloc.c b/libguile/gc-malloc.c index 2aff4c31a..179558fe1 100644 --- a/libguile/gc-malloc.c +++ b/libguile/gc-malloc.c @@ -45,7 +45,6 @@ extern unsigned long * __libc_ia64_register_backing_store_base; #include "libguile/root.h" #include "libguile/strings.h" #include "libguile/vectors.h" -#include "libguile/weaks.h" #include "libguile/hashtab.h" #include "libguile/tags.h" @@ -265,102 +264,3 @@ scm_gc_strdup (const char *str, const char *what) { return scm_gc_strndup (str, strlen (str), what); } - -#if SCM_ENABLE_DEPRECATED == 1 - -/* {Deprecated front end to malloc} - * - * scm_must_malloc, scm_must_realloc, scm_must_free, scm_done_malloc, - * scm_done_free - * - * These functions provide services comparable to malloc, realloc, and - * free. - * - * There has been a fair amount of confusion around the use of these functions; - * see "Memory Blocks" in the manual. They are totally unnecessary in 2.0 given - * the Boehm GC. - */ - -void * -scm_must_malloc (size_t size, const char *what) -{ - scm_c_issue_deprecation_warning - ("scm_must_malloc is deprecated. " - "Use scm_gc_malloc and scm_gc_free instead."); - - return scm_gc_malloc (size, what); -} - -void * -scm_must_realloc (void *where, - size_t old_size, - size_t size, - const char *what) -{ - scm_c_issue_deprecation_warning - ("scm_must_realloc is deprecated. " - "Use scm_gc_realloc and scm_gc_free instead."); - - return scm_gc_realloc (where, old_size, size, what); -} - -char * -scm_must_strndup (const char *str, size_t length) -{ - scm_c_issue_deprecation_warning - ("scm_must_strndup is deprecated. " - "Use scm_gc_strndup and scm_gc_free instead."); - - return scm_gc_strndup (str, length, "string"); -} - -char * -scm_must_strdup (const char *str) -{ - scm_c_issue_deprecation_warning - ("scm_must_strdup is deprecated. " - "Use scm_gc_strdup and scm_gc_free instead."); - - return scm_gc_strdup (str, "string"); -} - -void -scm_must_free (void *obj) -#define FUNC_NAME "scm_must_free" -{ - scm_c_issue_deprecation_warning - ("scm_must_free is deprecated. " - "Use scm_gc_malloc and scm_gc_free instead."); - - do_gc_free (obj); -} -#undef FUNC_NAME - - -void -scm_done_malloc (long size) -{ - scm_c_issue_deprecation_warning - ("scm_done_malloc is deprecated. " - "Use scm_gc_register_collectable_memory instead."); - - if (size >= 0) - scm_gc_register_collectable_memory (NULL, size, "foreign mallocs"); - else - scm_gc_unregister_collectable_memory (NULL, -size, "foreign mallocs"); -} - -void -scm_done_free (long size) -{ - scm_c_issue_deprecation_warning - ("scm_done_free is deprecated. " - "Use scm_gc_unregister_collectable_memory instead."); - - if (size >= 0) - scm_gc_unregister_collectable_memory (NULL, size, "foreign mallocs"); - else - scm_gc_register_collectable_memory (NULL, -size, "foreign mallocs"); -} - -#endif /* SCM_ENABLE_DEPRECATED == 1 */ diff --git a/libguile/gc.c b/libguile/gc.c index 06b5044e5..d580a65a0 100644 --- a/libguile/gc.c +++ b/libguile/gc.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001, 2002, 2003, 2006, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001, 2002, 2003, 2006, 2008, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -22,8 +22,6 @@ # include <config.h> #endif -#define SCM_BUILDING_DEPRECATED_CODE - #include "libguile/gen-scmconfig.h" #include <stdio.h> @@ -49,7 +47,6 @@ extern unsigned long * __libc_ia64_register_backing_store_base; #include "libguile/root.h" #include "libguile/strings.h" #include "libguile/vectors.h" -#include "libguile/weaks.h" #include "libguile/hashtab.h" #include "libguile/tags.h" @@ -82,14 +79,10 @@ int scm_expensive_debug_cell_accesses_p = 0; */ int scm_debug_cells_gc_interval = 0; -#if SCM_ENABLE_DEPRECATED == 1 /* Hash table that keeps a reference to objects the user wants to protect from - garbage collection. It could arguably be private but applications have come - to rely on it (e.g., Lilypond 2.13.9). */ -SCM scm_protects; -#else + garbage collection. */ static SCM scm_protects; -#endif + #if (SCM_DEBUG_CELL_ACCESSES == 1) @@ -194,35 +187,6 @@ SCM_DEFINE (scm_set_debug_cell_accesses_x, "set-debug-cell-accesses!", 1, 0, 0, -/* Compatibility. */ - -#ifndef HAVE_GC_GET_HEAP_USAGE_SAFE -static void -GC_get_heap_usage_safe (GC_word *pheap_size, GC_word *pfree_bytes, - GC_word *punmapped_bytes, GC_word *pbytes_since_gc, - GC_word *ptotal_bytes) -{ - *pheap_size = GC_get_heap_size (); - *pfree_bytes = GC_get_free_bytes (); -#ifdef HAVE_GC_GET_UNMAPPED_BYTES - *punmapped_bytes = GC_get_unmapped_bytes (); -#else - *punmapped_bytes = 0; -#endif - *pbytes_since_gc = GC_get_bytes_since_gc (); - *ptotal_bytes = GC_get_total_bytes (); -} -#endif - -#ifndef HAVE_GC_GET_FREE_SPACE_DIVISOR -static GC_word -GC_get_free_space_divisor (void) -{ - return GC_free_space_divisor; -} -#endif - - /* Hooks. */ scm_t_c_hook scm_before_gc_c_hook; scm_t_c_hook scm_before_mark_c_hook; @@ -401,9 +365,6 @@ SCM_DEFINE (scm_gc, "gc", 0, 0, 0, void scm_i_gc (const char *what) { -#ifndef HAVE_GC_SET_START_CALLBACK - run_before_gc_c_hook (); -#endif GC_gcollect (); } @@ -618,14 +579,6 @@ scm_getenv_int (const char *var, int def) return res; } -#ifndef HAVE_GC_SET_FINALIZE_ON_DEMAND -static void -GC_set_finalize_on_demand (int foo) -{ - GC_finalize_on_demand = foo; -} -#endif - void scm_storage_prehistory () { @@ -967,6 +920,10 @@ scm_i_tag_name (scm_t_bits tag) return "foreign"; case scm_tc7_hashtable: return "hashtable"; + case scm_tc7_weak_set: + return "weak-set"; + case scm_tc7_weak_table: + return "weak-table"; case scm_tc7_fluid: return "fluid"; case scm_tc7_dynamic_state: @@ -1047,19 +1004,11 @@ scm_init_gc () scm_c_hook_add (&scm_before_gc_c_hook, start_gc_timer, NULL, 0); scm_c_hook_add (&scm_after_gc_c_hook, accumulate_gc_timer, NULL, 0); -#if HAVE_GC_GET_HEAP_USAGE_SAFE /* GC_get_heap_usage does not take a lock, and so can run in the GC start hook. */ scm_c_hook_add (&scm_before_gc_c_hook, adjust_gc_frequency, NULL, 0); -#else - /* GC_get_heap_usage might take a lock (and did from 7.2alpha1 to - 7.2alpha7), so call it in the after_gc_hook. */ - scm_c_hook_add (&scm_after_gc_c_hook, adjust_gc_frequency, NULL, 0); -#endif -#ifdef HAVE_GC_SET_START_CALLBACK GC_set_start_callback (run_before_gc_c_hook); -#endif #include "libguile/gc.x" } diff --git a/libguile/gc.h b/libguile/gc.h index 9f00e017b..b1df82df5 100644 --- a/libguile/gc.h +++ b/libguile/gc.h @@ -3,7 +3,8 @@ #ifndef SCM_GC_H #define SCM_GC_H -/* Copyright (C) 1995,1996,1998,1999,2000,2001, 2002, 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. +/* Copyright (C) 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006, + * 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -35,22 +36,9 @@ typedef struct scm_t_cell SCM word_1; } scm_t_cell; -/* Cray machines have pointers that are incremented once for each - * word, rather than each byte, the 3 most significant bits encode the - * byte within the word. The following macros deal with this by - * storing the native Cray pointers like the ones that looks like scm - * expects. This is done for any pointers that point to a cell, - * pointers to scm_vector elts, functions, &c are not munged. - */ -#ifdef _UNICOS -# define SCM2PTR(x) ((scm_t_cell *) (SCM_UNPACK (x) >> 3)) -# define PTR2SCM(x) (SCM_PACK (((scm_t_bits) (x)) << 3)) -#else -# define SCM2PTR(x) ((scm_t_cell *) (SCM_UNPACK (x))) -# define PTR2SCM(x) (SCM_PACK ((scm_t_bits) (x))) -#endif /* def _UNICOS */ - - +/* FIXME: deprecate. */ +#define PTR2SCM(x) (SCM_PACK_POINTER (x)) +#define SCM2PTR(x) ((scm_t_cell *) (SCM_UNPACK_POINTER (x))) /* Low level cell data accessing macros. These macros should only be used * from within code related to garbage collection issues, since they will @@ -138,20 +126,6 @@ void *scm_ia64_ar_bsp (const void *); -#if (SCM_ENABLE_DEPRECATED == 1) -SCM_DEPRECATED size_t scm_default_init_heap_size_1; -SCM_DEPRECATED int scm_default_min_yield_1; -SCM_DEPRECATED size_t scm_default_init_heap_size_2; -SCM_DEPRECATED int scm_default_min_yield_2; -SCM_DEPRECATED size_t scm_default_max_segment_size; -#else -#define scm_default_init_heap_size_1 deprecated -#define scm_default_min_yield_1 deprecated -#define scm_default_init_heap_size_2 deprecated -#define scm_default_min_yield_2 deprecated -#define scm_default_max_segment_size deprecated -#endif - SCM_API unsigned long scm_gc_ports_collected; SCM_API SCM scm_after_gc_hook; @@ -221,14 +195,14 @@ SCM_API char *scm_gc_strndup (const char *str, size_t n, const char *what) SCM_INLINE SCM scm_cell (scm_t_bits car, scm_t_bits cdr); SCM_INLINE SCM scm_double_cell (scm_t_bits car, scm_t_bits cbr, scm_t_bits ccr, scm_t_bits cdr); -SCM_INLINE SCM scm_words (scm_t_bits car, scm_t_uint16 n_words); +SCM_INLINE SCM scm_words (scm_t_bits car, scm_t_uint32 n_words); #if SCM_CAN_INLINE || defined SCM_INLINE_C_IMPLEMENTING_INLINES SCM_INLINE_IMPLEMENTATION SCM scm_cell (scm_t_bits car, scm_t_bits cdr) { - SCM cell = PTR2SCM (SCM_GC_MALLOC (sizeof (scm_t_cell))); + SCM cell = SCM_PACK_POINTER (SCM_GC_MALLOC (sizeof (scm_t_cell))); /* Initialize the type slot last so that the cell is ignored by the GC until it is completely initialized. This is only relevant when the GC @@ -246,7 +220,7 @@ scm_double_cell (scm_t_bits car, scm_t_bits cbr, { SCM z; - z = PTR2SCM (SCM_GC_MALLOC (2 * sizeof (scm_t_cell))); + z = SCM_PACK_POINTER (SCM_GC_MALLOC (2 * sizeof (scm_t_cell))); /* Initialize the type slot last so that the cell is ignored by the GC until it is completely initialized. This is only relevant when the GC can actually run during this code, which it can't @@ -281,11 +255,11 @@ scm_double_cell (scm_t_bits car, scm_t_bits cbr, } SCM_INLINE_IMPLEMENTATION SCM -scm_words (scm_t_bits car, scm_t_uint16 n_words) +scm_words (scm_t_bits car, scm_t_uint32 n_words) { SCM z; - z = PTR2SCM (SCM_GC_MALLOC (sizeof (scm_t_bits) * n_words)); + z = SCM_PACK_POINTER (SCM_GC_MALLOC (sizeof (scm_t_bits) * n_words)); SCM_GC_SET_CELL_WORD (z, 0, car); /* FIXME: is the following concern even relevant with BDW-GC? */ @@ -352,35 +326,10 @@ SCM_API void scm_gc_register_root (SCM *p); SCM_API void scm_gc_unregister_root (SCM *p); SCM_API void scm_gc_register_roots (SCM *b, unsigned long n); SCM_API void scm_gc_unregister_roots (SCM *b, unsigned long n); -#if SCM_ENABLE_DEPRECATED == 1 -SCM_DEPRECATED SCM scm_protects; -#endif SCM_INTERNAL void scm_storage_prehistory (void); SCM_INTERNAL void scm_init_gc_protect_object (void); SCM_INTERNAL void scm_init_gc (void); -#if SCM_ENABLE_DEPRECATED == 1 - -SCM_DEPRECATED SCM scm_deprecated_newcell (void); -SCM_DEPRECATED SCM scm_deprecated_newcell2 (void); - -#define SCM_NEWCELL(_into) \ - do { _into = scm_deprecated_newcell (); } while (0) -#define SCM_NEWCELL2(_into) \ - do { _into = scm_deprecated_newcell2 (); } while (0) - -SCM_DEPRECATED void * scm_must_malloc (size_t len, const char *what); -SCM_DEPRECATED void * scm_must_realloc (void *where, - size_t olen, size_t len, - const char *what); -SCM_DEPRECATED char *scm_must_strdup (const char *str); -SCM_DEPRECATED char *scm_must_strndup (const char *str, size_t n); -SCM_DEPRECATED void scm_done_malloc (long size); -SCM_DEPRECATED void scm_done_free (long size); -SCM_DEPRECATED void scm_must_free (void *obj); - -#endif - #endif /* SCM_GC_H */ /* diff --git a/libguile/gdbint.c b/libguile/gdbint.c index 7a0ebc985..2df3c5c46 100644 --- a/libguile/gdbint.c +++ b/libguile/gdbint.c @@ -150,7 +150,7 @@ gdb_read (char *str) SCM_BEGIN_FOREIGN_BLOCK; unmark_port (gdb_input_port); scm_seek (gdb_input_port, SCM_INUM0, scm_from_int (SEEK_SET)); - scm_puts (str, gdb_input_port); + scm_puts_unlocked (str, gdb_input_port); scm_truncate_file (gdb_input_port, SCM_UNDEFINED); scm_seek (gdb_input_port, SCM_INUM0, scm_from_int (SEEK_SET)); @@ -158,7 +158,7 @@ gdb_read (char *str) ans = scm_read (gdb_input_port); if (SCM_GC_P) { - if (SCM_NIMP (ans)) + if (SCM_HEAP_OBJECT_P (ans)) { SEND_STRING ("Non-immediate created during gc. Memory may be trashed."); status = -1; @@ -167,7 +167,7 @@ gdb_read (char *str) } gdb_result = ans; /* Protect answer from future GC (FIXME: still needed with BDW-GC?) */ - if (SCM_NIMP (ans)) + if (SCM_HEAP_OBJECT_P (ans)) scm_permanent_object (ans); exit: remark_port (gdb_input_port); @@ -213,7 +213,7 @@ gdb_print (SCM obj) { scm_t_port *pt = SCM_PTAB_ENTRY (gdb_output_port); - scm_flush (gdb_output_port); + scm_flush_unlocked (gdb_output_port); *(pt->write_buf + pt->read_buf_size) = 0; SEND_STRING (pt->read_buf); } diff --git a/libguile/gen-scmconfig.c b/libguile/gen-scmconfig.c index 9e15c622d..d8dea7f54 100644 --- a/libguile/gen-scmconfig.c +++ b/libguile/gen-scmconfig.c @@ -54,9 +54,9 @@ - use 1 and 0 for public #defines instead of "def and undef", i.e. use #define SCM_HAVE_FOO rather than just not defining SCM_HAVE_FOO whenever possible. See GNU Coding Guidelines for - rationale. The only notable non-deprecated exceptions to this - rule are GUILE_DEBUG and GUILE_DEBUG_FREELIST which do not follow - this convention in order to retain backward compatibility. + rationale. The only notable non-deprecated exception to this rule + is GUILE_DEBUG which does not follow this convention in order to + retain backward compatibility. - in the code below, be *VERY* careful not to use or rely on any runtime-dynamic information below. For example, you cannot use @@ -399,15 +399,6 @@ main (int argc, char *argv[]) #endif pf ("\n"); - pf ("#if SCM_ENABLE_DEPRECATED == 1\n" - "# define USE_THREADS 1 /* always true now */\n" - "# define GUILE_ISELECT 1 /* always true now */\n" - "# define READER_EXTENSIONS 1 /* always true now */\n" - "# define DEBUG_EXTENSIONS 1 /* always true now */\n" - "# define DYNAMIC_LINKING 1 /* always true now */\n" - "#endif\n"); - printf ("\n"); - pf ("#define SCM_HAVE_ARRAYS 1 /* always true now */\n"); pf ("\n"); diff --git a/libguile/goops.c b/libguile/goops.c index 9a4027714..355e5efa4 100644 --- a/libguile/goops.c +++ b/libguile/goops.c @@ -53,7 +53,6 @@ #include "libguile/strings.h" #include "libguile/strports.h" #include "libguile/vectors.h" -#include "libguile/weaks.h" #include "libguile/vm.h" #include "libguile/validate.h" @@ -85,13 +84,6 @@ SCM_SYMBOL (sym_change_class, "change-class"); SCM_VARIABLE (scm_var_make_extended_generic, "make-extended-generic"); -/* FIXME, exports should come from the scm file only */ -#define DEFVAR(v, val) \ - { scm_module_define (scm_module_goops, (v), (val)); \ - scm_module_export (scm_module_goops, scm_list_1 ((v))); \ - } - - /* Class redefinition protocol: A class is represented by a heap header h1 which points to a @@ -172,7 +164,6 @@ static SCM class_array; static SCM class_bitvector; static SCM vtable_class_map = SCM_BOOL_F; -static scm_i_pthread_mutex_t vtable_class_map_lock = SCM_I_PTHREAD_MUTEX_INITIALIZER; /* Port classes. Allocate 3 times the maximum number of port types so that input ports, output ports, and in/out ports can be stored at different @@ -200,17 +191,15 @@ scm_i_define_class_for_vtable (SCM vtable) { SCM class; - scm_i_pthread_mutex_lock (&vtable_class_map_lock); - + scm_i_pthread_mutex_lock (&scm_i_misc_mutex); if (scm_is_false (vtable_class_map)) - vtable_class_map = scm_make_weak_key_hash_table (SCM_UNDEFINED); + vtable_class_map = scm_c_make_weak_table (0, SCM_WEAK_TABLE_KIND_KEY); + scm_i_pthread_mutex_unlock (&scm_i_misc_mutex); if (scm_is_false (scm_struct_vtable_p (vtable))) abort (); - class = scm_hashq_ref (vtable_class_map, vtable, SCM_BOOL_F); - - scm_i_pthread_mutex_unlock (&vtable_class_map_lock); + class = scm_weak_table_refq (vtable_class_map, vtable, SCM_BOOL_F); if (scm_is_false (class)) { @@ -229,9 +218,7 @@ scm_i_define_class_for_vtable (SCM vtable) /* Don't worry about races. This only happens when creating a vtable, which happens by definition in one thread. */ - scm_i_pthread_mutex_lock (&vtable_class_map_lock); - scm_hashq_set_x (vtable_class_map, vtable, class); - scm_i_pthread_mutex_unlock (&vtable_class_map_lock); + scm_weak_table_putq_x (vtable_class_map, vtable, class); } return class; @@ -934,7 +921,6 @@ SCM_SYMBOL (sym_cpl, "cpl"); SCM_SYMBOL (sym_default_slot_definition_class, "default-slot-definition-class"); SCM_SYMBOL (sym_slots, "slots"); SCM_SYMBOL (sym_getters_n_setters, "getters-n-setters"); -SCM_SYMBOL (sym_keyword_access, "keyword-access"); SCM_SYMBOL (sym_nfields, "nfields"); @@ -969,7 +955,6 @@ build_class_class_slots (void) scm_list_1 (sym_default_slot_definition_class), scm_list_1 (sym_slots), scm_list_1 (sym_getters_n_setters), - scm_list_1 (sym_keyword_access), scm_list_1 (sym_nfields), SCM_UNDEFINED); } @@ -1000,21 +985,21 @@ create_basic_classes (void) prep_hashsets (scm_class_class); - DEFVAR(name, scm_class_class); + scm_module_define (scm_module_goops, name, scm_class_class); /**** <top> ****/ name = scm_from_latin1_symbol ("<top>"); scm_class_top = scm_basic_make_class (scm_class_class, name, SCM_EOL, SCM_EOL); - DEFVAR(name, scm_class_top); + scm_module_define (scm_module_goops, name, scm_class_top); /**** <object> ****/ name = scm_from_latin1_symbol ("<object>"); scm_class_object = scm_basic_make_class (scm_class_class, name, scm_list_1 (scm_class_top), SCM_EOL); - DEFVAR (name, scm_class_object); + scm_module_define (scm_module_goops, name, scm_class_object); /* <top> <object> and <class> were partially initialized. Correct them here */ SCM_SET_SLOT (scm_class_object, scm_si_direct_subclasses, scm_list_1 (scm_class_class)); @@ -1733,36 +1718,6 @@ SCM_KEYWORD (k_name, "name"); SCM_GLOBAL_SYMBOL (scm_sym_args, "args"); -SCM -scm_apply_generic (SCM gf, SCM args) -{ - return scm_apply (SCM_STRUCT_PROCEDURE (gf), args, SCM_EOL); -} - -SCM -scm_call_generic_0 (SCM gf) -{ - return scm_call_0 (SCM_STRUCT_PROCEDURE (gf)); -} - -SCM -scm_call_generic_1 (SCM gf, SCM a1) -{ - return scm_call_1 (SCM_STRUCT_PROCEDURE (gf), a1); -} - -SCM -scm_call_generic_2 (SCM gf, SCM a1, SCM a2) -{ - return scm_call_2 (SCM_STRUCT_PROCEDURE (gf), a1, a2); -} - -SCM -scm_call_generic_3 (SCM gf, SCM a1, SCM a2, SCM a3) -{ - return scm_call_3 (SCM_STRUCT_PROCEDURE (gf), a1, a2, a3); -} - SCM_SYMBOL (sym_delayed_compile, "delayed-compile"); static SCM make_dispatch_procedure (SCM gf) @@ -1906,6 +1861,47 @@ setup_extended_primitive_generics () } } +/* Dirk:FIXME:: In all of these scm_wta_dispatch_* routines it is + * assumed that 'gf' is zero if uninitialized. It would be cleaner if + * some valid SCM value like SCM_BOOL_F or SCM_UNDEFINED were chosen. + */ + +SCM +scm_wta_dispatch_0 (SCM gf, const char *subr) +{ + if (!SCM_UNPACK (gf)) + scm_error_num_args_subr (subr); + + return scm_call_0 (gf); +} + +SCM +scm_wta_dispatch_1 (SCM gf, SCM a1, int pos, const char *subr) +{ + if (!SCM_UNPACK (gf)) + scm_wrong_type_arg (subr, pos, a1); + + return scm_call_1 (gf, a1); +} + +SCM +scm_wta_dispatch_2 (SCM gf, SCM a1, SCM a2, int pos, const char *subr) +{ + if (!SCM_UNPACK (gf)) + scm_wrong_type_arg (subr, pos, (pos == SCM_ARG1) ? a1 : a2); + + return scm_call_2 (gf, a1, a2); +} + +SCM +scm_wta_dispatch_n (SCM gf, SCM args, int pos, const char *subr) +{ + if (!SCM_UNPACK (gf)) + scm_wrong_type_arg (subr, pos, scm_list_ref (args, scm_from_int (pos))); + + return scm_apply_0 (gf, args); +} + /****************************************************************************** * * Protocol for calling a generic fumction @@ -2367,12 +2363,12 @@ fix_cpl (SCM c, SCM before, SCM after) static void make_stdcls (SCM *var, char *name, SCM meta, SCM super, SCM slots) { - SCM tmp = scm_from_locale_symbol (name); + SCM tmp = scm_from_utf8_symbol (name); *var = scm_basic_make_class (meta, tmp, scm_is_pair (super) ? super : scm_list_1 (super), slots); - DEFVAR(tmp, *var); + scm_module_define (scm_module_goops, tmp, *var); } @@ -2572,30 +2568,25 @@ create_standard_classes (void) static SCM make_class_from_template (char const *template, char const *type_name, SCM supers, int applicablep) { - SCM class, name; + SCM name; if (type_name) { char buffer[100]; sprintf (buffer, template, type_name); - name = scm_from_locale_symbol (buffer); + name = scm_from_utf8_symbol (buffer); } else name = SCM_GOOPS_UNBOUND; - class = scm_basic_make_class (applicablep ? scm_class_procedure_class : scm_class_class, - name, supers, SCM_EOL); - - /* Only define name if doesn't already exist. */ - if (!SCM_GOOPS_UNBOUNDP (name) - && scm_is_false (scm_module_variable (scm_module_goops, name))) - DEFVAR (name, class); - return class; + return scm_basic_make_class (applicablep ? scm_class_procedure_class : scm_class_class, + name, supers, SCM_EOL); } static SCM make_class_from_symbol (SCM type_name_sym, SCM supers, int applicablep) { - SCM class, name; + SCM name; + if (scm_is_true (type_name_sym)) { name = scm_string_append (scm_list_3 (scm_from_locale_string ("<"), @@ -2606,14 +2597,8 @@ make_class_from_symbol (SCM type_name_sym, SCM supers, int applicablep) else name = SCM_GOOPS_UNBOUND; - class = scm_basic_make_class (applicablep ? scm_class_procedure_class : scm_class_class, - name, supers, SCM_EOL); - - /* Only define name if doesn't already exist. */ - if (!SCM_GOOPS_UNBOUNDP (name) - && scm_is_false (scm_module_variable (scm_module_goops, name))) - DEFVAR (name, class); - return class; + return scm_basic_make_class (applicablep ? scm_class_procedure_class : scm_class_class, + name, supers, SCM_EOL); } SCM @@ -2721,7 +2706,7 @@ create_port_classes (void) { long i; - for (i = 0; i < scm_numptob; ++i) + for (i = scm_c_num_port_types () - 1; i >= 0; i--) scm_make_port_classes (i, SCM_PTOBNAME (i)); } @@ -2851,7 +2836,7 @@ scm_init_goops_builtins (void) SCM name = scm_from_latin1_symbol ("no-applicable-method"); scm_no_applicable_method = scm_make (scm_list_3 (scm_class_generic, k_name, name)); - DEFVAR (name, scm_no_applicable_method); + scm_module_define (scm_module_goops, name, scm_no_applicable_method); } return SCM_UNSPECIFIED; diff --git a/libguile/goops.h b/libguile/goops.h index 47a6e4eca..b3071b039 100644 --- a/libguile/goops.h +++ b/libguile/goops.h @@ -79,7 +79,6 @@ "pw" /* default-slot-definition-class */ \ "pw" /* slots */ \ "pw" /* getters-n-setters */ \ - "pw" /* keyword access */ \ "pw" /* nfields */ #define scm_si_redefined (scm_vtable_offset_user + 0) @@ -99,11 +98,9 @@ #define scm_si_cpl (scm_vtable_offset_user + 13) /* (class ...) */ #define scm_si_slotdef_class (scm_vtable_offset_user + 14) #define scm_si_slots (scm_vtable_offset_user + 15) /* ((name . options) ...) */ -#define scm_si_name_access (scm_vtable_offset_user + 16) -#define scm_si_getters_n_setters scm_si_name_access -#define scm_si_keyword_access (scm_vtable_offset_user + 17) -#define scm_si_nfields (scm_vtable_offset_user + 18) /* an integer */ -#define SCM_N_CLASS_SLOTS (scm_vtable_offset_user + 19) +#define scm_si_getters_n_setters (scm_vtable_offset_user + 16) +#define scm_si_nfields (scm_vtable_offset_user + 17) /* an integer */ +#define SCM_N_CLASS_SLOTS (scm_vtable_offset_user + 18) typedef struct scm_t_method { SCM generic_function; @@ -299,13 +296,14 @@ SCM_API SCM scm_make (SCM args); SCM_API SCM scm_find_method (SCM args); SCM_API SCM scm_sys_method_more_specific_p (SCM m1, SCM m2, SCM targs); SCM_API void scm_change_object_class (SCM, SCM, SCM); -/* The following are declared in __scm.h -SCM_API SCM scm_call_generic_0 (SCM gf); -SCM_API SCM scm_call_generic_1 (SCM gf, SCM a1); -SCM_API SCM scm_call_generic_2 (SCM gf, SCM a1, SCM a2); -SCM_API SCM scm_apply_generic (SCM gf, SCM args); -*/ -SCM_API SCM scm_call_generic_3 (SCM gf, SCM a1, SCM a2, SCM a3); + +/* These procedures are for dispatching to a generic when a primitive + fails to apply. They raise a wrong-type-arg error if the primitive's + generic has not been initialized yet. */ +SCM_API SCM scm_wta_dispatch_0 (SCM gf, const char *subr); +SCM_API SCM scm_wta_dispatch_1 (SCM gf, SCM a1, int pos, const char *subr); +SCM_API SCM scm_wta_dispatch_2 (SCM gf, SCM a1, SCM a2, int pos, const char *subr); +SCM_API SCM scm_wta_dispatch_n (SCM gf, SCM args, int pos, const char *subr); SCM_INTERNAL SCM scm_i_define_class_for_vtable (SCM vtable); diff --git a/libguile/gsubr.c b/libguile/gsubr.c index b6f261faf..84846cf35 100644 --- a/libguile/gsubr.c +++ b/libguile/gsubr.c @@ -791,7 +791,7 @@ create_gsubr (int define, const char *name, scm_t_bits flags; /* make objtable */ - sname = scm_from_locale_symbol (name); + sname = scm_from_utf8_symbol (name); table = scm_c_make_vector (generic_loc ? 3 : 2, SCM_UNDEFINED); SCM_SIMPLE_VECTOR_SET (table, 0, scm_from_pointer (fcn, NULL)); SCM_SIMPLE_VECTOR_SET (table, 1, sname); @@ -858,13 +858,13 @@ scm_c_define_gsubr_with_generic (const char *name, SCM gsubr_21l(SCM req1, SCM req2, SCM opt, SCM rst) { - scm_puts ("gsubr-2-1-l:\n req1: ", scm_cur_outp); + scm_puts_unlocked ("gsubr-2-1-l:\n req1: ", scm_cur_outp); scm_display(req1, scm_cur_outp); - scm_puts ("\n req2: ", scm_cur_outp); + scm_puts_unlocked ("\n req2: ", scm_cur_outp); scm_display(req2, scm_cur_outp); - scm_puts ("\n opt: ", scm_cur_outp); + scm_puts_unlocked ("\n opt: ", scm_cur_outp); scm_display(opt, scm_cur_outp); - scm_puts ("\n rest: ", scm_cur_outp); + scm_puts_unlocked ("\n rest: ", scm_cur_outp); scm_display(rst, scm_cur_outp); scm_newline(scm_cur_outp); return SCM_UNSPECIFIED; diff --git a/libguile/guardians.c b/libguile/guardians.c index 022f54e63..8a0d2961c 100644 --- a/libguile/guardians.c +++ b/libguile/guardians.c @@ -58,7 +58,6 @@ #include "libguile/validate.h" #include "libguile/root.h" #include "libguile/hashtab.h" -#include "libguile/weaks.h" #include "libguile/deprecation.h" #include "libguile/eval.h" @@ -88,16 +87,16 @@ guardian_print (SCM guardian, SCM port, scm_print_state *pstate SCM_UNUSED) { t_guardian *g = GUARDIAN_DATA (guardian); - scm_puts ("#<guardian ", port); + scm_puts_unlocked ("#<guardian ", port); scm_uintprint ((scm_t_bits) g, 16, port); - scm_puts (" (reachable: ", port); + scm_puts_unlocked (" (reachable: ", port); scm_display (scm_from_uint (g->live), port); - scm_puts (" unreachable: ", port); + scm_puts_unlocked (" unreachable: ", port); scm_display (scm_length (g->zombies), port); - scm_puts (")", port); + scm_puts_unlocked (")", port); - scm_puts (">", port); + scm_puts_unlocked (">", port); return 1; } @@ -110,9 +109,9 @@ finalize_guarded (void *ptr, void *finalizer_data) SCM cell_pool; SCM obj, guardian_list, proxied_finalizer; - obj = PTR2SCM (ptr); - guardian_list = SCM_CDR (PTR2SCM (finalizer_data)); - proxied_finalizer = SCM_CAR (PTR2SCM (finalizer_data)); + obj = SCM_PACK_POINTER (ptr); + guardian_list = SCM_CDR (SCM_PACK_POINTER (finalizer_data)); + proxied_finalizer = SCM_CAR (SCM_PACK_POINTER (finalizer_data)); #ifdef DEBUG_GUARDIANS printf ("finalizing guarded %p (%u guardians)\n", @@ -132,9 +131,12 @@ finalize_guarded (void *ptr, void *finalizer_data) guardian_list = SCM_CDR (guardian_list)) { SCM zombies; + SCM guardian; t_guardian *g; - if (SCM_WEAK_PAIR_CAR_DELETED_P (guardian_list)) + guardian = scm_c_weak_vector_ref (scm_car (guardian_list), 0); + + if (scm_is_false (guardian)) { /* The guardian itself vanished in the meantime. */ #ifdef DEBUG_GUARDIANS @@ -143,7 +145,7 @@ finalize_guarded (void *ptr, void *finalizer_data) continue; } - g = GUARDIAN_DATA (SCM_CAR (guardian_list)); + g = GUARDIAN_DATA (guardian); if (g->live == 0) abort (); @@ -167,8 +169,8 @@ finalize_guarded (void *ptr, void *finalizer_data) GC_finalization_proc finalizer, prev_finalizer; void *finalizer_data, *prev_finalizer_data; - finalizer = (GC_finalization_proc) SCM2PTR (SCM_CAR (proxied_finalizer)); - finalizer_data = SCM2PTR (SCM_CDR (proxied_finalizer)); + finalizer = (GC_finalization_proc) SCM_UNPACK_POINTER (SCM_CAR (proxied_finalizer)); + finalizer_data = SCM_UNPACK_POINTER (SCM_CDR (proxied_finalizer)); if (finalizer == NULL) abort (); @@ -192,7 +194,7 @@ scm_i_guard (SCM guardian, SCM obj) { t_guardian *g = GUARDIAN_DATA (guardian); - if (SCM_NIMP (obj)) + if (SCM_HEAP_OBJECT_P (obj)) { /* Register a finalizer and pass a pair as the ``client data'' argument. The pair contains in its car `#f' or a pair describing a @@ -210,13 +212,15 @@ scm_i_guard (SCM guardian, SCM obj) g->live++; - /* Note: GUARDIANS_FOR_OBJ is a weak list so that a guardian can be - collected before the objects it guards (see `guardians.test'). */ - guardians_for_obj = scm_weak_car_pair (guardian, SCM_EOL); + /* Note: GUARDIANS_FOR_OBJ holds weak references to guardians so + that a guardian can be collected before the objects it guards + (see `guardians.test'). */ + guardians_for_obj = scm_cons (scm_make_weak_vector (SCM_INUM1, guardian), + SCM_EOL); finalizer_data = scm_cons (SCM_BOOL_F, guardians_for_obj); - GC_REGISTER_FINALIZER_NO_ORDER (SCM2PTR (obj), finalize_guarded, - SCM2PTR (finalizer_data), + GC_REGISTER_FINALIZER_NO_ORDER (SCM_UNPACK_POINTER (obj), finalize_guarded, + SCM_UNPACK_POINTER (finalizer_data), &prev_finalizer, &prev_data); if (prev_finalizer == finalize_guarded) @@ -228,7 +232,7 @@ scm_i_guard (SCM guardian, SCM obj) if (prev_data == NULL) abort (); - prev_finalizer_data = PTR2SCM (prev_data); + prev_finalizer_data = SCM_PACK_POINTER (prev_data); if (!scm_is_pair (prev_finalizer_data)) abort (); @@ -245,8 +249,8 @@ scm_i_guard (SCM guardian, SCM obj) `finalize_guarded ()' has finished. */ SCM proxied_finalizer; - proxied_finalizer = scm_cons (PTR2SCM (prev_finalizer), - PTR2SCM (prev_data)); + proxied_finalizer = scm_cons (SCM_PACK_POINTER (prev_finalizer), + SCM_PACK_POINTER (prev_data)); SCM_SETCAR (finalizer_data, proxied_finalizer); } } diff --git a/libguile/guile.c b/libguile/guile.c index ac22b83df..133afc43e 100644 --- a/libguile/guile.c +++ b/libguile/guile.c @@ -1,5 +1,6 @@ -/* Copyright (C) 1996,1997,2000,2001, 2006, 2008, 2011 Free Software Foundation, Inc. - * +/* Copyright (C) 1996, 1997, 2000, 2001, 2006, 2008, + * 2011 Free Software Foundation, Inc. + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version 3 of @@ -36,6 +37,7 @@ #include <libguile/scmconfig.h> #endif #include <ltdl.h> +#include <locale.h> #ifdef HAVE_WINSOCK2_H #include <winsock2.h> @@ -67,6 +69,14 @@ inner_main (void *closure SCM_UNUSED, int argc, char **argv) int main (int argc, char **argv) { + /* Install the locale right at the beginning so that string conversion + for command-line arguments, along with possible error messages, use + the right locale. See + <https://lists.gnu.org/archive/html/guile-devel/2011-11/msg00041.html> + for the rationale. */ + if (setlocale (LC_ALL, "") == NULL) + fprintf (stderr, "guile: warning: failed to install locale\n"); + scm_install_gmp_memory_functions = 1; scm_boot_guile (argc, argv, inner_main, 0); return 0; /* never reached */ diff --git a/libguile/hash.c b/libguile/hash.c index 8b00a0cb1..740dac11f 100644 --- a/libguile/hash.c +++ b/libguile/hash.c @@ -1,6 +1,6 @@ /* Copyright (C) 1995, 1996, 1997, 2000, 2001, 2003, 2004, 2006, 2008, * 2009, 2010, 2011, 2012 Free Software Foundation, Inc. - * + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version 3 of @@ -46,234 +46,320 @@ extern double floor(); #endif +/* This hash function is originally from + http://burtleburtle.net/bob/c/lookup3.c by Bob Jenkins, May 2006, + Public Domain. No warranty. */ + +#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k)))) +#define mix(a,b,c) \ +{ \ + a -= c; a ^= rot(c, 4); c += b; \ + b -= a; b ^= rot(a, 6); a += c; \ + c -= b; c ^= rot(b, 8); b += a; \ + a -= c; a ^= rot(c,16); c += b; \ + b -= a; b ^= rot(a,19); a += c; \ + c -= b; c ^= rot(b, 4); b += a; \ +} + +#define final(a,b,c) \ +{ \ + c ^= b; c -= rot(b,14); \ + a ^= c; a -= rot(c,11); \ + b ^= a; b -= rot(a,25); \ + c ^= b; c -= rot(b,16); \ + a ^= c; a -= rot(c,4); \ + b ^= a; b -= rot(a,14); \ + c ^= b; c -= rot(b,24); \ +} + +#define JENKINS_LOOKUP3_HASHWORD2(k, length, ret) \ + do { \ + scm_t_uint32 a, b, c; \ + \ + /* Set up the internal state. */ \ + a = b = c = 0xdeadbeef + ((scm_t_uint32)(length<<2)) + 47; \ + \ + /* Handle most of the key. */ \ + while (length > 3) \ + { \ + a += k[0]; \ + b += k[1]; \ + c += k[2]; \ + mix (a, b, c); \ + length -= 3; \ + k += 3; \ + } \ + \ + /* Handle the last 3 elements. */ \ + switch(length) /* All the case statements fall through. */ \ + { \ + case 3 : c += k[2]; \ + case 2 : b += k[1]; \ + case 1 : a += k[0]; \ + final (a, b, c); \ + case 0: /* case 0: nothing left to add */ \ + break; \ + } \ + \ + if (sizeof (ret) == 8) \ + ret = (((unsigned long) c) << 32) | b; \ + else \ + ret = c; \ + } while (0) + + +static unsigned long +narrow_string_hash (const scm_t_uint8 *str, size_t len) +{ + unsigned long ret; + JENKINS_LOOKUP3_HASHWORD2 (str, len, ret); + ret >>= 2; /* Ensure that it fits in a fixnum. */ + return ret; +} + +static unsigned long +wide_string_hash (const scm_t_wchar *str, size_t len) +{ + unsigned long ret; + JENKINS_LOOKUP3_HASHWORD2 (str, len, ret); + ret >>= 2; /* Ensure that it fits in a fixnum. */ + return ret; +} + unsigned long scm_string_hash (const unsigned char *str, size_t len) { - /* from suggestion at: */ - /* http://srfi.schemers.org/srfi-13/mail-archive/msg00112.html */ - - unsigned long h = 0; - while (len-- > 0) - h = *str++ + h*37; - return h; + return narrow_string_hash (str, len); } unsigned long scm_i_string_hash (SCM str) { size_t len = scm_i_string_length (str); - size_t i = 0; - - unsigned long h = 0; - while (len-- > 0) - h = (unsigned long) scm_i_string_ref (str, i++) + h * 37; - scm_remember_upto_here_1 (str); - return h; + if (scm_i_is_narrow_string (str)) + return narrow_string_hash ((const scm_t_uint8 *) scm_i_string_chars (str), + len); + else + return wide_string_hash (scm_i_string_wide_chars (str), len); } unsigned long scm_i_locale_string_hash (const char *str, size_t len) { -#ifdef HAVE_WCHAR_H - mbstate_t state; - wchar_t c; - size_t byte_idx = 0, nbytes; - unsigned long h = 0; - - if (len == (size_t) -1) - len = strlen (str); - - while ((nbytes = mbrtowc (&c, str + byte_idx, len - byte_idx, &state)) > 0) - { - if (nbytes >= (size_t) -2) - /* Invalid input string; punt. */ - return scm_i_string_hash (scm_from_locale_stringn (str, len)); - - h = (unsigned long) c + h * 37; - byte_idx += nbytes; - } - - return h; -#else return scm_i_string_hash (scm_from_locale_stringn (str, len)); -#endif } unsigned long scm_i_latin1_string_hash (const char *str, size_t len) { - const scm_t_uint8 *ustr = (const scm_t_uint8 *) str; - size_t i = 0; - unsigned long h = 0; - if (len == (size_t) -1) len = strlen (str); - for (; i < len; i++) - h = (unsigned long) ustr[i] + h * 37; - - return h; + return narrow_string_hash ((const scm_t_uint8 *) str, len); } +/* A tricky optimization, but probably worth it. */ unsigned long scm_i_utf8_string_hash (const char *str, size_t len) { - const scm_t_uint8 *ustr = (const scm_t_uint8 *) str; - size_t byte_idx = 0; - unsigned long h = 0; - + const scm_t_uint8 *end, *ustr = (const scm_t_uint8 *) str; + unsigned long ret; + + /* The length of the string in characters. This name corresponds to + Jenkins' original name. */ + size_t length; + + scm_t_uint32 a, b, c, u32; + if (len == (size_t) -1) len = strlen (str); - while (byte_idx < len) + end = ustr + len; + + if (u8_check (ustr, len) != NULL) + /* Invalid UTF-8; punt. */ + return scm_i_string_hash (scm_from_utf8_stringn (str, len)); + + length = u8_strnlen (ustr, len); + + /* Set up the internal state. */ + a = b = c = 0xdeadbeef + ((scm_t_uint32)(length<<2)) + 47; + + /* Handle most of the key. */ + while (length > 3) + { + ustr += u8_mbtouc_unsafe (&u32, ustr, end - ustr); + a += u32; + ustr += u8_mbtouc_unsafe (&u32, ustr, end - ustr); + b += u32; + ustr += u8_mbtouc_unsafe (&u32, ustr, end - ustr); + c += u32; + mix (a, b, c); + length -= 3; + } + + /* Handle the last 3 elements's. */ + ustr += u8_mbtouc_unsafe (&u32, ustr, end - ustr); + a += u32; + if (--length) { - ucs4_t c; - int nbytes; - - nbytes = u8_mbtouc (&c, ustr + byte_idx, len - byte_idx); - if (nbytes == 0) - break; - else if (nbytes < 0) - /* Bad UTF-8; punt. */ - return scm_i_string_hash (scm_from_utf8_stringn (str, len)); - - h = (unsigned long) c + h * 37; - byte_idx += nbytes; + ustr += u8_mbtouc_unsafe (&u32, ustr, end - ustr); + b += u32; + if (--length) + { + ustr += u8_mbtouc_unsafe (&u32, ustr, end - ustr); + c += u32; + } } - return h; + final (a, b, c); + + if (sizeof (unsigned long) == 8) + ret = (((unsigned long) c) << 32) | b; + else + ret = c; + + ret >>= 2; /* Ensure that it fits in a fixnum. */ + return ret; } +static unsigned long scm_raw_ihashq (scm_t_bits key); +static unsigned long scm_raw_ihash (SCM obj, size_t depth); + +/* Return the hash of struct OBJ. Traverse OBJ's fields to compute the + result, unless DEPTH is zero. Assumes that OBJ is a struct. */ +static unsigned long +scm_i_struct_hash (SCM obj, size_t depth) +{ + SCM layout; + scm_t_bits *data; + size_t struct_size, field_num; + unsigned long hash; + + layout = SCM_STRUCT_LAYOUT (obj); + struct_size = scm_i_symbol_length (layout) / 2; + data = SCM_STRUCT_DATA (obj); + + hash = scm_raw_ihashq (SCM_UNPACK (SCM_STRUCT_VTABLE (obj))); + if (depth > 0) + for (field_num = 0; field_num < struct_size; field_num++) + { + int protection; + + protection = scm_i_symbol_ref (layout, field_num * 2 + 1); + if (protection != 'h' && protection != 'o') + { + int type; + type = scm_i_symbol_ref (layout, field_num * 2); + switch (type) + { + case 'p': + hash ^= scm_raw_ihash (SCM_PACK (data[field_num]), + depth / 2); + break; + case 'u': + hash ^= scm_raw_ihashq (data[field_num]); + break; + default: + /* Ignore 's' fields. */; + } + } + } -/* Dirk:FIXME:: why downcase for characters? (2x: scm_hasher, scm_ihashv) */ -/* Dirk:FIXME:: scm_hasher could be made static. */ + /* FIXME: Tail elements should be taken into account. */ + return hash; +} -unsigned long -scm_hasher(SCM obj, unsigned long n, size_t d) +/* Thomas Wang's integer hasher, from + http://www.cris.com/~Ttwang/tech/inthash.htm. */ +static unsigned long +scm_raw_ihashq (scm_t_bits key) { - switch (SCM_ITAG3 (obj)) { - case scm_tc3_int_1: - case scm_tc3_int_2: - return SCM_I_INUM(obj) % n; /* SCM_INUMP(obj) */ - case scm_tc3_imm24: - if (SCM_CHARP(obj)) - return (unsigned)(scm_c_downcase(SCM_CHAR(obj))) % n; - switch (SCM_UNPACK (obj)) { - case SCM_EOL_BITS: - d = 256; - break; - case SCM_BOOL_T_BITS: - d = 257; - break; - case SCM_BOOL_F_BITS: - d = 258; - break; - case SCM_EOF_VAL_BITS: - d = 259; - break; - default: - d = 263; /* perhaps should be error */ + if (sizeof (key) < 8) + { + key = (key ^ 61) ^ (key >> 16); + key = key + (key << 3); + key = key ^ (key >> 4); + key = key * 0x27d4eb2d; + key = key ^ (key >> 15); } - return d % n; - default: - return 263 % n; /* perhaps should be error */ - case scm_tc3_cons: - switch SCM_TYP7(obj) { - default: - return 263 % n; + else + { + key = (~key) + (key << 21); // key = (key << 21) - key - 1; + key = key ^ (key >> 24); + key = (key + (key << 3)) + (key << 8); // key * 265 + key = key ^ (key >> 14); + key = (key + (key << 2)) + (key << 4); // key * 21 + key = key ^ (key >> 28); + key = key + (key << 31); + } + key >>= 2; /* Ensure that it fits in a fixnum. */ + return key; +} + +/* `depth' is used to limit recursion. */ +static unsigned long +scm_raw_ihash (SCM obj, size_t depth) +{ + if (SCM_IMP (obj)) + return scm_raw_ihashq (SCM_UNPACK (obj)); + + switch (SCM_TYP7(obj)) + { + /* FIXME: do better for structs, variables, ... Also the hashes + are currently associative, which ain't the right thing. */ case scm_tc7_smob: - return 263 % n; + return scm_raw_ihashq (SCM_TYP16 (obj)); case scm_tc7_number: - switch SCM_TYP16 (obj) { - case scm_tc16_big: - return scm_to_ulong (scm_modulo (obj, scm_from_ulong (n))); - case scm_tc16_real: - { - double r = SCM_REAL_VALUE (obj); - if (floor (r) == r && !isinf (r) && !isnan (r)) - { - obj = scm_inexact_to_exact (obj); - return scm_to_ulong (scm_modulo (obj, scm_from_ulong (n))); - } - } - /* Fall through */ - case scm_tc16_complex: - case scm_tc16_fraction: - obj = scm_number_to_string (obj, scm_from_int (10)); - /* Fall through */ - } - /* Fall through */ + if (scm_is_integer (obj)) + { + SCM n = SCM_I_MAKINUM (SCM_MOST_POSITIVE_FIXNUM); + if (scm_is_inexact (obj)) + obj = scm_inexact_to_exact (obj); + return scm_raw_ihashq (scm_to_ulong (scm_modulo (obj, n))); + } + else + return scm_i_string_hash (scm_number_to_string (obj, scm_from_int (10))); case scm_tc7_string: - { - unsigned long hash = - scm_i_string_hash (obj) % n; - return hash; - } + return scm_i_string_hash (obj); case scm_tc7_symbol: - return scm_i_symbol_hash (obj) % n; + return scm_i_symbol_hash (obj); case scm_tc7_pointer: - { - /* Pointer objects are typically used to store addresses of heap - objects. On most platforms, these are at least 3-byte - aligned (on x86_64-*-gnu, `malloc' returns 4-byte aligned - addresses), so get rid of the least significant bits. */ - scm_t_uintptr significant_bits; - - significant_bits = (scm_t_uintptr) SCM_POINTER_VALUE (obj) >> 4UL; - return (size_t) significant_bits % n; - } - case scm_tcs_struct: - return scm_i_struct_hash (obj, n, d); + return scm_raw_ihashq ((scm_t_uintptr) SCM_POINTER_VALUE (obj)); case scm_tc7_wvect: case scm_tc7_vector: { size_t len = SCM_SIMPLE_VECTOR_LENGTH (obj); - if (len > 5) - { - size_t i = d/2; - unsigned long h = 1; - while (i--) - { - SCM elt = SCM_SIMPLE_VECTOR_REF (obj, h % len); - h = ((h << 8) + (scm_hasher (elt, n, 2))) % n; - } - return h; - } - else - { - size_t i = len; - unsigned long h = (n)-1; - while (i--) - { - SCM elt = SCM_SIMPLE_VECTOR_REF (obj, h % len); - h = ((h << 8) + (scm_hasher (elt, n, d/len))) % n; - } - return h; - } + size_t i = depth / 2; + unsigned long h = scm_raw_ihashq (SCM_CELL_WORD_0 (obj)); + if (len) + while (i--) + h ^= scm_raw_ihash (scm_c_vector_ref (obj, h % len), i); + return h; } case scm_tcs_cons_imcar: case scm_tcs_cons_nimcar: - if (d) return (scm_hasher (SCM_CAR (obj), n, d/2) - + scm_hasher (SCM_CDR (obj), n, d/2)) % n; - else return 1; - case scm_tc7_port: - return ((SCM_RDNG & SCM_CELL_WORD_0 (obj)) ? 260 : 261) % n; - case scm_tc7_program: - return 262 % n; + if (depth) + return (scm_raw_ihash (SCM_CAR (obj), depth / 2) + ^ scm_raw_ihash (SCM_CDR (obj), depth / 2)); + else + return scm_raw_ihashq (scm_tc3_cons); + case scm_tcs_struct: + return scm_i_struct_hash (obj, depth); + default: + return scm_raw_ihashq (SCM_CELL_WORD_0 (obj)); } - } } - unsigned long scm_ihashq (SCM obj, unsigned long n) { - return (SCM_UNPACK (obj) >> 1) % n; + return scm_raw_ihashq (SCM_UNPACK (obj)) % n; } @@ -303,13 +389,10 @@ SCM_DEFINE (scm_hashq, "hashq", 2, 0, 0, unsigned long scm_ihashv (SCM obj, unsigned long n) { - if (SCM_CHARP(obj)) - return ((unsigned long) (scm_c_downcase (SCM_CHAR (obj)))) % n; /* downcase!?!! */ - if (SCM_NUMP(obj)) - return (unsigned long) scm_hasher(obj, n, 10); + return scm_raw_ihash (obj, 10) % n; else - return SCM_UNPACK (obj) % n; + return scm_raw_ihashq (SCM_UNPACK (obj)) % n; } @@ -339,7 +422,7 @@ SCM_DEFINE (scm_hashv, "hashv", 2, 0, 0, unsigned long scm_ihash (SCM obj, unsigned long n) { - return (unsigned long) scm_hasher (obj, n, 10); + return (unsigned long) scm_raw_ihash (obj, 10) % n; } SCM_DEFINE (scm_hash, "hash", 2, 0, 0, diff --git a/libguile/hash.h b/libguile/hash.h index 307748617..d3e42f1c1 100644 --- a/libguile/hash.h +++ b/libguile/hash.h @@ -36,7 +36,6 @@ SCM_INTERNAL unsigned long scm_i_utf8_string_hash (const char *str, size_t len); SCM_INTERNAL unsigned long scm_i_string_hash (SCM str); -SCM_API unsigned long scm_hasher (SCM obj, unsigned long n, size_t d); SCM_API unsigned long scm_ihashq (SCM obj, unsigned long n); SCM_API SCM scm_hashq (SCM obj, SCM n); SCM_API unsigned long scm_ihashv (SCM obj, unsigned long n); diff --git a/libguile/hashtab.c b/libguile/hashtab.c index 88cb199c5..fff48b857 100644 --- a/libguile/hashtab.c +++ b/libguile/hashtab.c @@ -54,9 +54,6 @@ * The implementation stores the upper and lower number of items which * trigger a resize in the hashtable object. * - * Weak hash tables use weak pairs in the bucket lists rather than - * normal pairs. - * * Possible hash table sizes (primes) are stored in the array * hashtable_size. */ @@ -76,201 +73,8 @@ static unsigned long hashtable_size[] = { static char *s_hashtable = "hashtable"; - - -/* Helper functions and macros to deal with weak pairs. - - Weak pairs need to be accessed very carefully since their components can - be nullified by the GC when the object they refer to becomes unreachable. - Hence the macros and functions below that detect such weak pairs within - buckets and remove them. */ - - -/* Remove nullified weak pairs from ALIST such that the result contains only - valid pairs. Set REMOVED_ITEMS to the number of pairs that have been - deleted. */ static SCM -scm_fixup_weak_alist (SCM alist, size_t *removed_items) -{ - SCM result; - SCM prev = SCM_EOL; - - *removed_items = 0; - for (result = alist; - scm_is_pair (alist); - alist = SCM_CDR (alist)) - { - SCM pair = SCM_CAR (alist); - - if (SCM_WEAK_PAIR_DELETED_P (pair)) - { - /* Remove from ALIST weak pair PAIR whose car/cdr has been - nullified by the GC. */ - if (scm_is_null (prev)) - result = SCM_CDR (alist); - else - SCM_SETCDR (prev, SCM_CDR (alist)); - - (*removed_items)++; - - /* Leave PREV unchanged. */ - } - else - prev = alist; - } - - return result; -} - -static void -vacuum_weak_hash_table (SCM table) -{ - SCM buckets = SCM_HASHTABLE_VECTOR (table); - unsigned long k = SCM_SIMPLE_VECTOR_LENGTH (buckets); - size_t len = SCM_HASHTABLE_N_ITEMS (table); - - while (k--) - { - size_t removed; - SCM alist = SCM_SIMPLE_VECTOR_REF (buckets, k); - alist = scm_fixup_weak_alist (alist, &removed); - assert (removed <= len); - len -= removed; - SCM_SIMPLE_VECTOR_SET (buckets, k, alist); - } - - SCM_SET_HASHTABLE_N_ITEMS (table, len); -} - - -/* Packed arguments for `do_weak_bucket_fixup'. */ -struct t_fixup_args -{ - SCM bucket; - SCM *bucket_copy; - size_t removed_items; -}; - -static void * -do_weak_bucket_fixup (void *data) -{ - struct t_fixup_args *args; - SCM pair, *copy; - - args = (struct t_fixup_args *) data; - - args->bucket = scm_fixup_weak_alist (args->bucket, &args->removed_items); - - for (pair = args->bucket, copy = args->bucket_copy; - scm_is_pair (pair); - pair = SCM_CDR (pair), copy += 2) - { - /* At this point, all weak pairs have been removed. */ - assert (!SCM_WEAK_PAIR_DELETED_P (SCM_CAR (pair))); - - /* Copy the key and value. */ - copy[0] = SCM_CAAR (pair); - copy[1] = SCM_CDAR (pair); - } - - return args; -} - -/* Lookup OBJECT in weak hash table TABLE using ASSOC. OBJECT is searched - for in the alist that is the BUCKET_INDEXth element of BUCKETS. - Optionally update TABLE and rehash it. */ -static SCM -weak_bucket_assoc (SCM table, SCM buckets, size_t bucket_index, - scm_t_hash_fn hash_fn, - scm_t_assoc_fn assoc, SCM object, void *closure) -{ - SCM result; - SCM bucket, *strong_refs; - struct t_fixup_args args; - - bucket = SCM_SIMPLE_VECTOR_REF (buckets, bucket_index); - - /* Prepare STRONG_REFS as an array large enough to hold all the keys - and values in BUCKET. */ - strong_refs = alloca (scm_ilength (bucket) * 2 * sizeof (SCM)); - - args.bucket = bucket; - args.bucket_copy = strong_refs; - - /* Fixup BUCKET. Do that with the allocation lock held to avoid - seeing disappearing links pointing to objects that have already - been reclaimed (this happens when the disappearing links that point - to it haven't yet been cleared.) - - The `do_weak_bucket_fixup' call populates STRONG_REFS with a copy - of BUCKET's entries after it's been fixed up. Thus, all the - entries kept in BUCKET are still reachable when ASSOC sees - them. */ - GC_call_with_alloc_lock (do_weak_bucket_fixup, &args); - - bucket = args.bucket; - SCM_SIMPLE_VECTOR_SET (buckets, bucket_index, bucket); - - result = assoc (object, bucket, closure); - - /* If we got a result, it should not have NULL fields. */ - if (scm_is_pair (result) && SCM_WEAK_PAIR_DELETED_P (result)) - abort (); - - scm_remember_upto_here_1 (strong_refs); - - if (args.removed_items > 0) - { - /* Update TABLE's item count and optionally trigger a rehash. */ - size_t remaining; - - assert (SCM_HASHTABLE_N_ITEMS (table) >= args.removed_items); - - remaining = SCM_HASHTABLE_N_ITEMS (table) - args.removed_items; - SCM_SET_HASHTABLE_N_ITEMS (table, remaining); - - if (remaining < SCM_HASHTABLE_LOWER (table)) - scm_i_rehash (table, hash_fn, closure, "weak_bucket_assoc"); - } - - return result; -} - - -/* Packed arguments for `weak_bucket_assoc_by_hash'. */ -struct assoc_by_hash_data -{ - SCM alist; - SCM ret; - scm_t_hash_predicate_fn predicate; - void *closure; -}; - -/* See scm_hash_fn_get_handle_by_hash below. */ -static void* -weak_bucket_assoc_by_hash (void *args) -{ - struct assoc_by_hash_data *data = args; - SCM alist = data->alist; - - for (; scm_is_pair (alist); alist = SCM_CDR (alist)) - { - SCM pair = SCM_CAR (alist); - - if (!SCM_WEAK_PAIR_DELETED_P (pair) - && data->predicate (SCM_CAR (pair), data->closure)) - { - data->ret = pair; - break; - } - } - return args; -} - - - -static SCM -make_hash_table (int flags, unsigned long k, const char *func_name) +make_hash_table (unsigned long k, const char *func_name) { SCM vector; scm_t_hashtable *t; @@ -279,9 +83,6 @@ make_hash_table (int flags, unsigned long k, const char *func_name) ++i; n = hashtable_size[i]; - /* In both cases, i.e., regardless of whether we are creating a weak hash - table, we return a non-weak vector. This is because the vector itself - is not weak in the case of a weak hash table: the alist pairs are. */ vector = scm_c_make_vector (n, SCM_EOL); t = scm_gc_malloc_pointerless (sizeof (*t), s_hashtable); @@ -289,8 +90,6 @@ make_hash_table (int flags, unsigned long k, const char *func_name) t->n_items = 0; t->lower = 0; t->upper = 9 * n / 10; - t->flags = flags; - t->hash_fn = NULL; /* FIXME: we just need two words of storage, not three */ return scm_double_cell (scm_tc7_hashtable, SCM_UNPACK (vector), @@ -323,13 +122,6 @@ scm_i_rehash (SCM table, if (i >= HASHTABLE_SIZE_N) /* don't rehash */ return; - - /* Remember HASH_FN for rehash_after_gc, but only when CLOSURE - is not needed since CLOSURE can not be guaranteed to be valid - after this function returns. - */ - if (closure == NULL) - SCM_HASHTABLE (table)->hash_fn = hash_fn; } SCM_HASHTABLE (table)->size_index = i; @@ -343,13 +135,6 @@ scm_i_rehash (SCM table, new_buckets = scm_c_make_vector (new_size, SCM_EOL); - /* When this is a weak hashtable, running the GC might change it. - We need to cope with this while rehashing its elements. We do - this by first installing the new, empty bucket vector. Then we - remove the elements from the old bucket vector and insert them - into the new one. - */ - SCM_SET_HASHTABLE_VECTOR (table, new_buckets); SCM_SET_HASHTABLE_N_ITEMS (table, 0); @@ -369,10 +154,6 @@ scm_i_rehash (SCM table, handle = SCM_CAR (cell); ls = SCM_CDR (ls); - if (SCM_WEAK_PAIR_DELETED_P (handle)) - /* HANDLE is a nullified weak pair: skip it. */ - continue; - h = hash_fn (SCM_CAR (handle), new_size, closure); if (h >= new_size) scm_out_of_range (func_name, scm_from_ulong (h)); @@ -387,28 +168,21 @@ scm_i_rehash (SCM table, void scm_i_hashtable_print (SCM exp, SCM port, scm_print_state *pstate) { - scm_puts ("#<", port); - if (SCM_HASHTABLE_WEAK_KEY_P (exp)) - scm_puts ("weak-key-", port); - else if (SCM_HASHTABLE_WEAK_VALUE_P (exp)) - scm_puts ("weak-value-", port); - else if (SCM_HASHTABLE_DOUBLY_WEAK_P (exp)) - scm_puts ("doubly-weak-", port); - scm_puts ("hash-table ", port); + scm_puts_unlocked ("#<hash-table ", port); scm_uintprint (SCM_UNPACK (exp), 16, port); scm_putc (' ', port); scm_uintprint (SCM_HASHTABLE_N_ITEMS (exp), 10, port); - scm_putc ('/', port); + scm_putc_unlocked ('/', port); scm_uintprint (SCM_SIMPLE_VECTOR_LENGTH (SCM_HASHTABLE_VECTOR (exp)), 10, port); - scm_puts (">", port); + scm_puts_unlocked (">", port); } SCM scm_c_make_hash_table (unsigned long k) { - return make_hash_table (0, k, "scm_c_make_hash_table"); + return make_hash_table (k, "scm_c_make_hash_table"); } SCM_DEFINE (scm_make_hash_table, "make-hash-table", 0, 1, 0, @@ -416,171 +190,18 @@ SCM_DEFINE (scm_make_hash_table, "make-hash-table", 0, 1, 0, "Make a new abstract hash table object with minimum number of buckets @var{n}\n") #define FUNC_NAME s_scm_make_hash_table { - if (SCM_UNBNDP (n)) - return make_hash_table (0, 0, FUNC_NAME); - else - return make_hash_table (0, scm_to_ulong (n), FUNC_NAME); -} -#undef FUNC_NAME - -/* The before-gc C hook only runs if GC_set_start_callback is available, - so if not, fall back on a finalizer-based implementation. */ -static int -weak_gc_callback (void **weak) -{ - void *val = weak[0]; - void (*callback) (SCM) = weak[1]; - - if (!val) - return 0; - - callback (PTR2SCM (val)); - - return 1; -} - -#ifdef HAVE_GC_SET_START_CALLBACK -static void* -weak_gc_hook (void *hook_data, void *fn_data, void *data) -{ - if (!weak_gc_callback (fn_data)) - scm_c_hook_remove (&scm_before_gc_c_hook, weak_gc_hook, fn_data); - - return NULL; -} -#else -static void -weak_gc_finalizer (void *ptr, void *data) -{ - if (weak_gc_callback (ptr)) - GC_REGISTER_FINALIZER_NO_ORDER (ptr, weak_gc_finalizer, data, NULL, NULL); -} -#endif - -static void -scm_c_register_weak_gc_callback (SCM obj, void (*callback) (SCM)) -{ - void **weak = GC_MALLOC_ATOMIC (sizeof (void*) * 2); - - weak[0] = SCM2PTR (obj); - weak[1] = (void*)callback; - GC_GENERAL_REGISTER_DISAPPEARING_LINK (weak, SCM2PTR (obj)); - -#ifdef HAVE_GC_SET_START_CALLBACK - scm_c_hook_add (&scm_before_gc_c_hook, weak_gc_hook, weak, 0); -#else - GC_REGISTER_FINALIZER_NO_ORDER (weak, weak_gc_finalizer, NULL, NULL, NULL); -#endif -} - -SCM_DEFINE (scm_make_weak_key_hash_table, "make-weak-key-hash-table", 0, 1, 0, - (SCM n), - "@deffnx {Scheme Procedure} make-weak-value-hash-table size\n" - "@deffnx {Scheme Procedure} make-doubly-weak-hash-table size\n" - "Return a weak hash table with @var{size} buckets.\n" - "\n" - "You can modify weak hash tables in exactly the same way you\n" - "would modify regular hash tables. (@pxref{Hash Tables})") -#define FUNC_NAME s_scm_make_weak_key_hash_table -{ - SCM ret; - - if (SCM_UNBNDP (n)) - ret = make_hash_table (SCM_HASHTABLEF_WEAK_CAR, 0, FUNC_NAME); - else - ret = make_hash_table (SCM_HASHTABLEF_WEAK_CAR, - scm_to_ulong (n), FUNC_NAME); - - scm_c_register_weak_gc_callback (ret, vacuum_weak_hash_table); - - return ret; -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_make_weak_value_hash_table, "make-weak-value-hash-table", 0, 1, 0, - (SCM n), - "Return a hash table with weak values with @var{size} buckets.\n" - "(@pxref{Hash Tables})") -#define FUNC_NAME s_scm_make_weak_value_hash_table -{ - SCM ret; - - if (SCM_UNBNDP (n)) - ret = make_hash_table (SCM_HASHTABLEF_WEAK_CDR, 0, FUNC_NAME); - else - ret = make_hash_table (SCM_HASHTABLEF_WEAK_CDR, - scm_to_ulong (n), FUNC_NAME); - - scm_c_register_weak_gc_callback (ret, vacuum_weak_hash_table); - - return ret; -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_make_doubly_weak_hash_table, "make-doubly-weak-hash-table", 1, 0, 0, - (SCM n), - "Return a hash table with weak keys and values with @var{size}\n" - "buckets. (@pxref{Hash Tables})") -#define FUNC_NAME s_scm_make_doubly_weak_hash_table -{ - SCM ret; - - if (SCM_UNBNDP (n)) - ret = make_hash_table (SCM_HASHTABLEF_WEAK_CAR | SCM_HASHTABLEF_WEAK_CDR, - 0, FUNC_NAME); - else - ret = make_hash_table (SCM_HASHTABLEF_WEAK_CAR | SCM_HASHTABLEF_WEAK_CDR, - scm_to_ulong (n), FUNC_NAME); - - scm_c_register_weak_gc_callback (ret, vacuum_weak_hash_table); - - return ret; + return make_hash_table (SCM_UNBNDP (n) ? 0 : scm_to_ulong (n), FUNC_NAME); } #undef FUNC_NAME +#define SCM_WEAK_TABLE_P(x) (scm_is_true (scm_weak_table_p (x))) SCM_DEFINE (scm_hash_table_p, "hash-table?", 1, 0, 0, (SCM obj), "Return @code{#t} if @var{obj} is an abstract hash table object.") #define FUNC_NAME s_scm_hash_table_p { - return scm_from_bool (SCM_HASHTABLE_P (obj)); -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_weak_key_hash_table_p, "weak-key-hash-table?", 1, 0, 0, - (SCM obj), - "@deffnx {Scheme Procedure} weak-value-hash-table? obj\n" - "@deffnx {Scheme Procedure} doubly-weak-hash-table? obj\n" - "Return @code{#t} if @var{obj} is the specified weak hash\n" - "table. Note that a doubly weak hash table is neither a weak key\n" - "nor a weak value hash table.") -#define FUNC_NAME s_scm_weak_key_hash_table_p -{ - return scm_from_bool (SCM_HASHTABLE_P (obj) && SCM_HASHTABLE_WEAK_KEY_P (obj)); -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_weak_value_hash_table_p, "weak-value-hash-table?", 1, 0, 0, - (SCM obj), - "Return @code{#t} if @var{obj} is a weak value hash table.") -#define FUNC_NAME s_scm_weak_value_hash_table_p -{ - return scm_from_bool (SCM_HASHTABLE_P (obj) && SCM_HASHTABLE_WEAK_VALUE_P (obj)); -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_doubly_weak_hash_table_p, "doubly-weak-hash-table?", 1, 0, 0, - (SCM obj), - "Return @code{#t} if @var{obj} is a doubly weak hash table.") -#define FUNC_NAME s_scm_doubly_weak_hash_table_p -{ - return scm_from_bool (SCM_HASHTABLE_P (obj) && SCM_HASHTABLE_DOUBLY_WEAK_P (obj)); + return scm_from_bool (SCM_HASHTABLE_P (obj) || SCM_WEAK_TABLE_P (obj)); } #undef FUNC_NAME @@ -606,69 +227,7 @@ scm_hash_fn_get_handle (SCM table, SCM obj, if (k >= SCM_SIMPLE_VECTOR_LENGTH (buckets)) scm_out_of_range (FUNC_NAME, scm_from_ulong (k)); - if (SCM_HASHTABLE_WEAK_P (table)) - h = weak_bucket_assoc (table, buckets, k, hash_fn, - assoc_fn, obj, closure); - else - h = assoc_fn (obj, SCM_SIMPLE_VECTOR_REF (buckets, k), closure); - - return h; -} -#undef FUNC_NAME - - -/* This procedure implements three optimizations, with respect to the - raw get_handle(): - - 1. For weak tables, it's assumed that calling the predicate in the - allocation lock is safe. In practice this means that the predicate - cannot call arbitrary scheme functions. - - 2. We don't check for overflow / underflow and rehash. - - 3. We don't actually have to allocate a key -- instead we get the - hash value directly. This is useful for, for example, looking up - strings in the symbol table. - */ -SCM -scm_hash_fn_get_handle_by_hash (SCM table, unsigned long raw_hash, - scm_t_hash_predicate_fn predicate_fn, - void *closure) -#define FUNC_NAME "scm_hash_fn_ref_by_hash" -{ - unsigned long k; - SCM buckets, alist, h = SCM_BOOL_F; - - SCM_VALIDATE_HASHTABLE (SCM_ARG1, table); - buckets = SCM_HASHTABLE_VECTOR (table); - - if (SCM_SIMPLE_VECTOR_LENGTH (buckets) == 0) - return SCM_BOOL_F; - - k = raw_hash % SCM_SIMPLE_VECTOR_LENGTH (buckets); - alist = SCM_SIMPLE_VECTOR_REF (buckets, k); - - if (SCM_HASHTABLE_WEAK_P (table)) - { - struct assoc_by_hash_data args; - - args.alist = alist; - args.ret = SCM_BOOL_F; - args.predicate = predicate_fn; - args.closure = closure; - GC_call_with_alloc_lock (weak_bucket_assoc_by_hash, &args); - h = args.ret; - } - else - for (; scm_is_pair (alist); alist = SCM_CDR (alist)) - { - SCM pair = SCM_CAR (alist); - if (predicate_fn (SCM_CAR (pair), closure)) - { - h = pair; - break; - } - } + h = assoc_fn (obj, SCM_SIMPLE_VECTOR_REF (buckets, k), closure); return h; } @@ -694,11 +253,7 @@ scm_hash_fn_create_handle_x (SCM table, SCM obj, SCM init, if (k >= SCM_SIMPLE_VECTOR_LENGTH (buckets)) scm_out_of_range ("hash_fn_create_handle_x", scm_from_ulong (k)); - if (SCM_HASHTABLE_WEAK_P (table)) - it = weak_bucket_assoc (table, buckets, k, hash_fn, - assoc_fn, obj, closure); - else - it = assoc_fn (obj, SCM_SIMPLE_VECTOR_REF (buckets, k), closure); + it = assoc_fn (obj, SCM_SIMPLE_VECTOR_REF (buckets, k), closure); if (scm_is_pair (it)) return it; @@ -706,29 +261,9 @@ scm_hash_fn_create_handle_x (SCM table, SCM obj, SCM init, scm_wrong_type_arg_msg (NULL, 0, it, "a pair"); else { - /* When this is a weak hashtable, running the GC can change it. - Thus, we must allocate the new cells first and can only then - access BUCKETS. Also, we need to fetch the bucket vector - again since the hashtable might have been rehashed. This - necessitates a new hash value as well. - */ SCM handle, new_bucket; - if (SCM_HASHTABLE_WEAK_P (table)) - { - /* FIXME: We don't support weak alist vectors. */ - /* Use a weak cell. */ - if (SCM_HASHTABLE_DOUBLY_WEAK_P (table)) - handle = scm_doubly_weak_pair (obj, init); - else if (SCM_HASHTABLE_WEAK_KEY_P (table)) - handle = scm_weak_car_pair (obj, init); - else - handle = scm_weak_cdr_pair (obj, init); - } - else - /* Use a regular, non-weak cell. */ - handle = scm_cons (obj, init); - + handle = scm_cons (obj, init); new_bucket = scm_cons (handle, SCM_EOL); if (!scm_is_eq (SCM_HASHTABLE_VECTOR (table), buckets)) @@ -764,36 +299,6 @@ scm_hash_fn_ref (SCM table, SCM obj, SCM dflt, return dflt; } -struct weak_cdr_data -{ - SCM pair; - SCM cdr; -}; - -static void* -get_weak_cdr (void *data) -{ - struct weak_cdr_data *d = data; - - if (SCM_WEAK_PAIR_CDR_DELETED_P (d->pair)) - d->cdr = SCM_BOOL_F; - else - d->cdr = SCM_CDR (d->pair); - - return NULL; -} - -static SCM -weak_pair_cdr (SCM x) -{ - struct weak_cdr_data data; - - data.pair = x; - GC_call_with_alloc_lock (get_weak_cdr, &data); - - return data.cdr; -} - SCM scm_hash_fn_set_x (SCM table, SCM obj, SCM val, scm_t_hash_fn hash_fn, scm_t_assoc_fn assoc_fn, @@ -805,24 +310,7 @@ scm_hash_fn_set_x (SCM table, SCM obj, SCM val, hash_fn, assoc_fn, closure); if (!scm_is_eq (SCM_CDR (pair), val)) - { - if (SCM_UNLIKELY (SCM_HASHTABLE_WEAK_VALUE_P (table))) - { - /* If the former value was on the heap, we need to unregister - the weak link. */ - SCM prev = weak_pair_cdr (pair); - - SCM_SETCDR (pair, val); - - if (SCM_NIMP (prev) && !SCM_NIMP (val)) - GC_unregister_disappearing_link ((void **) SCM_CDRLOC (pair)); - else - SCM_I_REGISTER_DISAPPEARING_LINK ((void **) SCM_CDRLOC (pair), - SCM2PTR (val)); - } - else - SCM_SETCDR (pair, val); - } + SCM_SETCDR (pair, val); return val; } @@ -849,11 +337,7 @@ scm_hash_fn_remove_x (SCM table, SCM obj, if (k >= SCM_SIMPLE_VECTOR_LENGTH (buckets)) scm_out_of_range (FUNC_NAME, scm_from_ulong (k)); - if (SCM_HASHTABLE_WEAK_P (table)) - h = weak_bucket_assoc (table, buckets, k, hash_fn, - assoc_fn, obj, closure); - else - h = assoc_fn (obj, SCM_SIMPLE_VECTOR_REF (buckets, k), closure); + h = assoc_fn (obj, SCM_SIMPLE_VECTOR_REF (buckets, k), closure); if (scm_is_true (h)) { @@ -872,6 +356,12 @@ SCM_DEFINE (scm_hash_clear_x, "hash-clear!", 1, 0, 0, "Remove all items from @var{table} (without triggering a resize).") #define FUNC_NAME s_scm_hash_clear_x { + if (SCM_WEAK_TABLE_P (table)) + { + scm_weak_table_clear_x (table); + return SCM_UNSPECIFIED; + } + SCM_VALIDATE_HASHTABLE (SCM_ARG1, table); scm_vector_fill_x (SCM_HASHTABLE_VECTOR (table), SCM_EOL); @@ -891,9 +381,6 @@ SCM_DEFINE (scm_hashq_get_handle, "hashq-get-handle", 2, 0, 0, "Uses @code{eq?} for equality testing.") #define FUNC_NAME s_scm_hashq_get_handle { - if (SCM_UNLIKELY (SCM_HASHTABLE_P (table) && SCM_HASHTABLE_WEAK_P (table))) - SCM_MISC_ERROR ("Handle access not permitted on weak table", SCM_EOL); - return scm_hash_fn_get_handle (table, key, (scm_t_hash_fn) scm_ihashq, (scm_t_assoc_fn) scm_sloppy_assq, @@ -909,9 +396,6 @@ SCM_DEFINE (scm_hashq_create_handle_x, "hashq-create-handle!", 3, 0, 0, "associates @var{key} with @var{init}.") #define FUNC_NAME s_scm_hashq_create_handle_x { - if (SCM_UNLIKELY (SCM_HASHTABLE_P (table) && SCM_HASHTABLE_WEAK_P (table))) - SCM_MISC_ERROR ("Handle access not permitted on weak table", SCM_EOL); - return scm_hash_fn_create_handle_x (table, key, init, (scm_t_hash_fn) scm_ihashq, (scm_t_assoc_fn) scm_sloppy_assq, @@ -930,6 +414,10 @@ SCM_DEFINE (scm_hashq_ref, "hashq-ref", 2, 1, 0, { if (SCM_UNBNDP (dflt)) dflt = SCM_BOOL_F; + + if (SCM_WEAK_TABLE_P (table)) + return scm_weak_table_refq (table, key, dflt); + return scm_hash_fn_ref (table, key, dflt, (scm_t_hash_fn) scm_ihashq, (scm_t_assoc_fn) scm_sloppy_assq, @@ -945,6 +433,12 @@ SCM_DEFINE (scm_hashq_set_x, "hashq-set!", 3, 0, 0, "store @var{val} there. Uses @code{eq?} for equality testing.") #define FUNC_NAME s_scm_hashq_set_x { + if (SCM_WEAK_TABLE_P (table)) + { + scm_weak_table_putq_x (table, key, val); + return val; + } + return scm_hash_fn_set_x (table, key, val, (scm_t_hash_fn) scm_ihashq, (scm_t_assoc_fn) scm_sloppy_assq, @@ -960,6 +454,16 @@ SCM_DEFINE (scm_hashq_remove_x, "hashq-remove!", 2, 0, 0, "@var{table}. Uses @code{eq?} for equality tests.") #define FUNC_NAME s_scm_hashq_remove_x { + if (SCM_WEAK_TABLE_P (table)) + { + scm_weak_table_remq_x (table, key); + /* This return value is for historical compatibility with + hash-remove!, which returns either the "handle" corresponding + to the entry, or #f. Since weak tables don't have handles, we + have to return #f. */ + return SCM_BOOL_F; + } + return scm_hash_fn_remove_x (table, key, (scm_t_hash_fn) scm_ihashq, (scm_t_assoc_fn) scm_sloppy_assq, @@ -978,9 +482,6 @@ SCM_DEFINE (scm_hashv_get_handle, "hashv-get-handle", 2, 0, 0, "Uses @code{eqv?} for equality testing.") #define FUNC_NAME s_scm_hashv_get_handle { - if (SCM_UNLIKELY (SCM_HASHTABLE_P (table) && SCM_HASHTABLE_WEAK_P (table))) - SCM_MISC_ERROR ("Handle access not permitted on weak table", SCM_EOL); - return scm_hash_fn_get_handle (table, key, (scm_t_hash_fn) scm_ihashv, (scm_t_assoc_fn) scm_sloppy_assv, @@ -996,9 +497,6 @@ SCM_DEFINE (scm_hashv_create_handle_x, "hashv-create-handle!", 3, 0, 0, "associates @var{key} with @var{init}.") #define FUNC_NAME s_scm_hashv_create_handle_x { - if (SCM_UNLIKELY (SCM_HASHTABLE_P (table) && SCM_HASHTABLE_WEAK_P (table))) - SCM_MISC_ERROR ("Handle access not permitted on weak table", SCM_EOL); - return scm_hash_fn_create_handle_x (table, key, init, (scm_t_hash_fn) scm_ihashv, (scm_t_assoc_fn) scm_sloppy_assv, @@ -1007,6 +505,12 @@ SCM_DEFINE (scm_hashv_create_handle_x, "hashv-create-handle!", 3, 0, 0, #undef FUNC_NAME +static int +assv_predicate (SCM k, SCM v, void *closure) +{ + return scm_is_true (scm_eqv_p (k, SCM_PACK_POINTER (closure))); +} + SCM_DEFINE (scm_hashv_ref, "hashv-ref", 2, 1, 0, (SCM table, SCM key, SCM dflt), "Look up @var{key} in the hash table @var{table}, and return the\n" @@ -1017,6 +521,11 @@ SCM_DEFINE (scm_hashv_ref, "hashv-ref", 2, 1, 0, { if (SCM_UNBNDP (dflt)) dflt = SCM_BOOL_F; + + if (SCM_WEAK_TABLE_P (table)) + return scm_c_weak_table_ref (table, scm_ihashv (key, -1), + assv_predicate, SCM_PACK (key), dflt); + return scm_hash_fn_ref (table, key, dflt, (scm_t_hash_fn) scm_ihashv, (scm_t_assoc_fn) scm_sloppy_assv, @@ -1032,6 +541,14 @@ SCM_DEFINE (scm_hashv_set_x, "hashv-set!", 3, 0, 0, "store @var{value} there. Uses @code{eqv?} for equality testing.") #define FUNC_NAME s_scm_hashv_set_x { + if (SCM_WEAK_TABLE_P (table)) + { + scm_c_weak_table_put_x (table, scm_ihashv (key, -1), + assv_predicate, SCM_PACK (key), + key, val); + return val; + } + return scm_hash_fn_set_x (table, key, val, (scm_t_hash_fn) scm_ihashv, (scm_t_assoc_fn) scm_sloppy_assv, @@ -1046,6 +563,14 @@ SCM_DEFINE (scm_hashv_remove_x, "hashv-remove!", 2, 0, 0, "@var{table}. Uses @code{eqv?} for equality tests.") #define FUNC_NAME s_scm_hashv_remove_x { + if (SCM_WEAK_TABLE_P (table)) + { + scm_c_weak_table_remove_x (table, scm_ihashv (key, -1), + assv_predicate, SCM_PACK (key)); + /* See note in hashq-remove!. */ + return SCM_BOOL_F; + } + return scm_hash_fn_remove_x (table, key, (scm_t_hash_fn) scm_ihashv, (scm_t_assoc_fn) scm_sloppy_assv, @@ -1063,9 +588,6 @@ SCM_DEFINE (scm_hash_get_handle, "hash-get-handle", 2, 0, 0, "Uses @code{equal?} for equality testing.") #define FUNC_NAME s_scm_hash_get_handle { - if (SCM_UNLIKELY (SCM_HASHTABLE_P (table) && SCM_HASHTABLE_WEAK_P (table))) - SCM_MISC_ERROR ("Handle access not permitted on weak table", SCM_EOL); - return scm_hash_fn_get_handle (table, key, (scm_t_hash_fn) scm_ihash, (scm_t_assoc_fn) scm_sloppy_assoc, @@ -1081,9 +603,6 @@ SCM_DEFINE (scm_hash_create_handle_x, "hash-create-handle!", 3, 0, 0, "associates @var{key} with @var{init}.") #define FUNC_NAME s_scm_hash_create_handle_x { - if (SCM_UNLIKELY (SCM_HASHTABLE_P (table) && SCM_HASHTABLE_WEAK_P (table))) - SCM_MISC_ERROR ("Handle access not permitted on weak table", SCM_EOL); - return scm_hash_fn_create_handle_x (table, key, init, (scm_t_hash_fn) scm_ihash, (scm_t_assoc_fn) scm_sloppy_assoc, @@ -1092,6 +611,12 @@ SCM_DEFINE (scm_hash_create_handle_x, "hash-create-handle!", 3, 0, 0, #undef FUNC_NAME +static int +assoc_predicate (SCM k, SCM v, void *closure) +{ + return scm_is_true (scm_equal_p (k, SCM_PACK_POINTER (closure))); +} + SCM_DEFINE (scm_hash_ref, "hash-ref", 2, 1, 0, (SCM table, SCM key, SCM dflt), "Look up @var{key} in the hash table @var{table}, and return the\n" @@ -1102,6 +627,11 @@ SCM_DEFINE (scm_hash_ref, "hash-ref", 2, 1, 0, { if (SCM_UNBNDP (dflt)) dflt = SCM_BOOL_F; + + if (SCM_WEAK_TABLE_P (table)) + return scm_c_weak_table_ref (table, scm_ihash (key, -1), + assoc_predicate, SCM_PACK (key), dflt); + return scm_hash_fn_ref (table, key, dflt, (scm_t_hash_fn) scm_ihash, (scm_t_assoc_fn) scm_sloppy_assoc, @@ -1118,6 +648,14 @@ SCM_DEFINE (scm_hash_set_x, "hash-set!", 3, 0, 0, "testing.") #define FUNC_NAME s_scm_hash_set_x { + if (SCM_WEAK_TABLE_P (table)) + { + scm_c_weak_table_put_x (table, scm_ihash (key, -1), + assoc_predicate, SCM_PACK (key), + key, val); + return val; + } + return scm_hash_fn_set_x (table, key, val, (scm_t_hash_fn) scm_ihash, (scm_t_assoc_fn) scm_sloppy_assoc, @@ -1133,6 +671,14 @@ SCM_DEFINE (scm_hash_remove_x, "hash-remove!", 2, 0, 0, "@var{table}. Uses @code{equal?} for equality tests.") #define FUNC_NAME s_scm_hash_remove_x { + if (SCM_WEAK_TABLE_P (table)) + { + scm_c_weak_table_remove_x (table, scm_ihash (key, -1), + assoc_predicate, SCM_PACK (key)); + /* See note in hashq-remove!. */ + return SCM_BOOL_F; + } + return scm_hash_fn_remove_x (table, key, (scm_t_hash_fn) scm_ihash, (scm_t_assoc_fn) scm_sloppy_assoc, @@ -1147,10 +693,9 @@ typedef struct scm_t_ihashx_closure { SCM hash; SCM assoc; + SCM key; } scm_t_ihashx_closure; - - static unsigned long scm_ihashx (SCM obj, unsigned long n, void *arg) { @@ -1160,8 +705,6 @@ scm_ihashx (SCM obj, unsigned long n, void *arg) return scm_to_ulong (answer); } - - static SCM scm_sloppy_assx (SCM obj, SCM alist, void *arg) { @@ -1169,6 +712,20 @@ scm_sloppy_assx (SCM obj, SCM alist, void *arg) return scm_call_2 (closure->assoc, obj, alist); } +static int +assx_predicate (SCM k, SCM v, void *closure) +{ + scm_t_ihashx_closure *c = (scm_t_ihashx_closure *) closure; + + /* FIXME: The hashx interface is crazy. Hash tables have nothing to + do with alists in principle. Instead of getting an assoc proc, + hashx functions should use an equality predicate. Perhaps we can + change this before 2.2, but until then, add a terrible, terrible + hack. */ + + return scm_is_true (scm_call_2 (c->assoc, c->key, scm_acons (k, v, SCM_EOL))); +} + SCM_DEFINE (scm_hashx_get_handle, "hashx-get-handle", 4, 0, 0, (SCM hash, SCM assoc, SCM table, SCM key), @@ -1183,9 +740,7 @@ SCM_DEFINE (scm_hashx_get_handle, "hashx-get-handle", 4, 0, 0, scm_t_ihashx_closure closure; closure.hash = hash; closure.assoc = assoc; - - if (SCM_UNLIKELY (SCM_HASHTABLE_P (table) && SCM_HASHTABLE_WEAK_P (table))) - SCM_MISC_ERROR ("Handle access not permitted on weak table", SCM_EOL); + closure.key = key; return scm_hash_fn_get_handle (table, key, scm_ihashx, scm_sloppy_assx, (void *) &closure); @@ -1206,9 +761,7 @@ SCM_DEFINE (scm_hashx_create_handle_x, "hashx-create-handle!", 5, 0, 0, scm_t_ihashx_closure closure; closure.hash = hash; closure.assoc = assoc; - - if (SCM_UNLIKELY (SCM_HASHTABLE_P (table) && SCM_HASHTABLE_WEAK_P (table))) - SCM_MISC_ERROR ("Handle access not permitted on weak table", SCM_EOL); + closure.key = key; return scm_hash_fn_create_handle_x (table, key, init, scm_ihashx, scm_sloppy_assx, (void *)&closure); @@ -1235,6 +788,15 @@ SCM_DEFINE (scm_hashx_ref, "hashx-ref", 4, 1, 0, dflt = SCM_BOOL_F; closure.hash = hash; closure.assoc = assoc; + closure.key = key; + + if (SCM_WEAK_TABLE_P (table)) + { + unsigned long h = scm_to_ulong (scm_call_2 (hash, key, + scm_from_ulong (-1))); + return scm_c_weak_table_ref (table, h, assx_predicate, &closure, dflt); + } + return scm_hash_fn_ref (table, key, dflt, scm_ihashx, scm_sloppy_assx, (void *)&closure); } @@ -1259,6 +821,16 @@ SCM_DEFINE (scm_hashx_set_x, "hashx-set!", 5, 0, 0, scm_t_ihashx_closure closure; closure.hash = hash; closure.assoc = assoc; + closure.key = key; + + if (SCM_WEAK_TABLE_P (table)) + { + unsigned long h = scm_to_ulong (scm_call_2 (hash, key, + scm_from_ulong (-1))); + scm_c_weak_table_put_x (table, h, assx_predicate, &closure, key, val); + return val; + } + return scm_hash_fn_set_x (table, key, val, scm_ihashx, scm_sloppy_assx, (void *)&closure); } @@ -1280,6 +852,17 @@ SCM_DEFINE (scm_hashx_remove_x, "hashx-remove!", 4, 0, 0, scm_t_ihashx_closure closure; closure.hash = hash; closure.assoc = assoc; + closure.key = obj; + + if (SCM_WEAK_TABLE_P (table)) + { + unsigned long h = scm_to_ulong (scm_call_2 (hash, obj, + scm_from_ulong (-1))); + scm_c_weak_table_remove_x (table, h, assx_predicate, &closure); + /* See note in hashq-remove!. */ + return SCM_BOOL_F; + } + return scm_hash_fn_remove_x (table, obj, scm_ihashx, scm_sloppy_assx, (void *) &closure); } @@ -1300,6 +883,10 @@ SCM_DEFINE (scm_hash_fold, "hash-fold", 3, 0, 0, #define FUNC_NAME s_scm_hash_fold { SCM_VALIDATE_PROC (1, proc); + + if (SCM_WEAK_TABLE_P (table)) + return scm_weak_table_fold (proc, init, table); + SCM_VALIDATE_HASHTABLE (3, table); return scm_internal_hash_fold ((scm_t_hash_fold_fn) scm_call_3, (void *) SCM_UNPACK (proc), init, table); @@ -1321,6 +908,13 @@ SCM_DEFINE (scm_hash_for_each, "hash-for-each", 2, 0, 0, #define FUNC_NAME s_scm_hash_for_each { SCM_VALIDATE_PROC (1, proc); + + if (SCM_WEAK_TABLE_P (table)) + { + scm_weak_table_for_each (proc, table); + return SCM_UNSPECIFIED; + } + SCM_VALIDATE_HASHTABLE (2, table); scm_internal_hash_for_each_handle (for_each_proc, @@ -1339,9 +933,6 @@ SCM_DEFINE (scm_hash_for_each_handle, "hash-for-each-handle", 2, 0, 0, SCM_ASSERT (scm_is_true (scm_procedure_p (proc)), proc, 1, FUNC_NAME); SCM_VALIDATE_HASHTABLE (2, table); - if (SCM_UNLIKELY (SCM_HASHTABLE_WEAK_P (table))) - SCM_MISC_ERROR ("Handle access not permitted on weak table", SCM_EOL); - scm_internal_hash_for_each_handle ((scm_t_hash_handle_fn) scm_call_1, (void *) SCM_UNPACK (proc), table); @@ -1364,6 +955,10 @@ SCM_DEFINE (scm_hash_map_to_list, "hash-map->list", 2, 0, 0, #define FUNC_NAME s_scm_hash_map_to_list { SCM_VALIDATE_PROC (1, proc); + + if (SCM_WEAK_TABLE_P (table)) + return scm_weak_table_map_to_list (proc, table); + SCM_VALIDATE_HASHTABLE (2, table); return scm_internal_hash_fold (map_proc, (void *) SCM_UNPACK (proc), @@ -1409,6 +1004,9 @@ scm_internal_hash_fold (scm_t_hash_fold_fn fn, void *closure, long i, n; SCM buckets, result = init; + if (SCM_WEAK_TABLE_P (table)) + return scm_c_weak_table_fold (fn, closure, init, table); + SCM_VALIDATE_HASHTABLE (0, table); buckets = SCM_HASHTABLE_VECTOR (table); @@ -1421,14 +1019,7 @@ scm_internal_hash_fold (scm_t_hash_fold_fn fn, void *closure, ls = SCM_CDR (ls)) { handle = SCM_CAR (ls); - - if (SCM_HASHTABLE_WEAK_P (table) && SCM_WEAK_PAIR_DELETED_P (handle)) - /* Don't try to unlink this weak pair, as we're not within - the allocation lock. Instead rely on - vacuum_weak_hash_table to do its job. */ - continue; - else - result = fn (closure, SCM_CAR (handle), SCM_CDR (handle), result); + result = fn (closure, SCM_CAR (handle), SCM_CDR (handle), result); } } diff --git a/libguile/hashtab.h b/libguile/hashtab.h index dcebcb81e..82ed22e66 100644 --- a/libguile/hashtab.h +++ b/libguile/hashtab.h @@ -3,7 +3,7 @@ #ifndef SCM_HASHTAB_H #define SCM_HASHTAB_H -/* Copyright (C) 1995,1996,1999,2000,2001, 2003, 2004, 2006, 2008, 2009 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1999,2000,2001, 2003, 2004, 2006, 2008, 2009, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -25,29 +25,14 @@ #include "libguile/__scm.h" -#include "weaks.h" - -#define SCM_HASHTABLEF_WEAK_CAR SCM_WVECTF_WEAK_KEY -#define SCM_HASHTABLEF_WEAK_CDR SCM_WVECTF_WEAK_VALUE - -#define SCM_HASHTABLE_P(x) (!SCM_IMP (x) && SCM_TYP7(x) == scm_tc7_hashtable) +#define SCM_HASHTABLE_P(x) (SCM_HAS_TYP7 (x, scm_tc7_hashtable)) #define SCM_VALIDATE_HASHTABLE(pos, arg) \ SCM_MAKE_VALIDATE_MSG (pos, arg, HASHTABLE_P, "hash-table") #define SCM_HASHTABLE_VECTOR(h) SCM_CELL_OBJECT_1 (h) #define SCM_SET_HASHTABLE_VECTOR(x, v) SCM_SET_CELL_OBJECT_1 ((x), (v)) #define SCM_HASHTABLE(x) ((scm_t_hashtable *) SCM_CELL_WORD_2 (x)) -#define SCM_HASHTABLE_FLAGS(x) (SCM_HASHTABLE (x)->flags) -#define SCM_HASHTABLE_WEAK_KEY_P(x) \ - (SCM_HASHTABLE_FLAGS (x) & SCM_HASHTABLEF_WEAK_CAR) -#define SCM_HASHTABLE_WEAK_VALUE_P(x) \ - (SCM_HASHTABLE_FLAGS (x) & SCM_HASHTABLEF_WEAK_CDR) -#define SCM_HASHTABLE_DOUBLY_WEAK_P(x) \ - ((SCM_HASHTABLE_FLAGS (x) \ - & (SCM_HASHTABLEF_WEAK_CAR | SCM_HASHTABLEF_WEAK_CDR)) \ - == (SCM_HASHTABLEF_WEAK_CAR | SCM_HASHTABLEF_WEAK_CDR)) -#define SCM_HASHTABLE_WEAK_P(x) SCM_HASHTABLE_FLAGS (x) #define SCM_HASHTABLE_N_ITEMS(x) (SCM_HASHTABLE (x)->n_items) #define SCM_SET_HASHTABLE_N_ITEMS(x, n) (SCM_HASHTABLE (x)->n_items = n) #define SCM_HASHTABLE_INCREMENT(x) (SCM_HASHTABLE_N_ITEMS(x)++) @@ -70,10 +55,6 @@ typedef unsigned long (*scm_t_hash_fn) (SCM obj, unsigned long max, some equality predicate. */ typedef SCM (*scm_t_assoc_fn) (SCM obj, SCM alist, void *closure); -/* Function that returns true if the given object is the one we are - looking for, for scm_hash_fn_ref_by_hash. */ -typedef int (*scm_t_hash_predicate_fn) (SCM obj, void *closure); - /* Function to fold over the entries of a hash table. */ typedef SCM (*scm_t_hash_fold_fn) (void *closure, SCM key, SCM value, SCM result); @@ -83,7 +64,6 @@ typedef SCM (*scm_t_hash_fold_fn) (void *closure, SCM key, SCM value, typedef SCM (*scm_t_hash_handle_fn) (void *closure, SCM handle); typedef struct scm_t_hashtable { - int flags; /* properties of table */ unsigned long n_items; /* number of items in table */ unsigned long lower; /* when to shrink */ unsigned long upper; /* when to grow */ @@ -97,14 +77,8 @@ typedef struct scm_t_hashtable { SCM_API SCM scm_vector_to_hash_table (SCM vector); SCM_API SCM scm_c_make_hash_table (unsigned long k); SCM_API SCM scm_make_hash_table (SCM n); -SCM_API SCM scm_make_weak_key_hash_table (SCM k); -SCM_API SCM scm_make_weak_value_hash_table (SCM k); -SCM_API SCM scm_make_doubly_weak_hash_table (SCM k); SCM_API SCM scm_hash_table_p (SCM h); -SCM_API SCM scm_weak_key_hash_table_p (SCM h); -SCM_API SCM scm_weak_value_hash_table_p (SCM h); -SCM_API SCM scm_doubly_weak_hash_table_p (SCM h); SCM_INTERNAL void scm_i_rehash (SCM table, scm_t_hash_fn hash_fn, void *closure, const char *func_name); @@ -114,10 +88,6 @@ SCM_API SCM scm_hash_fn_get_handle (SCM table, SCM obj, scm_t_hash_fn hash_fn, scm_t_assoc_fn assoc_fn, void *closure); -SCM_INTERNAL -SCM scm_hash_fn_get_handle_by_hash (SCM table, unsigned long raw_hash, - scm_t_hash_predicate_fn predicate_fn, - void *closure); SCM_API SCM scm_hash_fn_create_handle_x (SCM table, SCM obj, SCM init, scm_t_hash_fn hash_fn, scm_t_assoc_fn assoc_fn, diff --git a/libguile/hooks.c b/libguile/hooks.c index abba606f7..782636e4e 100644 --- a/libguile/hooks.c +++ b/libguile/hooks.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995,1996,1998,1999,2000,2001, 2003, 2006, 2008, 2009 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1998,1999,2000,2001, 2003, 2006, 2008, 2009, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -134,22 +134,22 @@ static int hook_print (SCM hook, SCM port, scm_print_state *pstate) { SCM ls, name; - scm_puts ("#<hook ", port); + scm_puts_unlocked ("#<hook ", port); scm_intprint (SCM_HOOK_ARITY (hook), 10, port); - scm_putc (' ', port); + scm_putc_unlocked (' ', port); scm_uintprint (SCM_UNPACK (hook), 16, port); ls = SCM_HOOK_PROCEDURES (hook); - while (SCM_NIMP (ls)) + while (scm_is_pair (ls)) { - scm_putc (' ', port); + scm_putc_unlocked (' ', port); name = scm_procedure_name (SCM_CAR (ls)); if (scm_is_true (name)) scm_iprin1 (name, port, pstate); else - scm_putc ('?', port); + scm_putc_unlocked ('?', port); ls = SCM_CDR (ls); } - scm_putc ('>', port); + scm_putc_unlocked ('>', port); return 1; } @@ -269,7 +269,7 @@ void scm_c_run_hook (SCM hook, SCM args) { SCM procs = SCM_HOOK_PROCEDURES (hook); - while (SCM_NIMP (procs)) + while (scm_is_pair (procs)) { scm_apply_0 (SCM_CAR (procs), args); procs = SCM_CDR (procs); @@ -280,7 +280,7 @@ void scm_c_run_hookn (SCM hook, SCM *argv, size_t nargs) { SCM procs = SCM_HOOK_PROCEDURES (hook); - while (SCM_NIMP (procs)) + while (scm_is_pair (procs)) { scm_call_n (SCM_CAR (procs), argv, nargs); procs = SCM_CDR (procs); diff --git a/libguile/init.c b/libguile/init.c index 17791e2c7..684f6eb02 100644 --- a/libguile/init.c +++ b/libguile/init.c @@ -135,7 +135,6 @@ #include "libguile/version.h" #include "libguile/vm.h" #include "libguile/vports.h" -#include "libguile/weaks.h" #include "libguile/guardians.h" #include "libguile/extensions.h" #include "libguile/uniform.h" @@ -167,8 +166,7 @@ stream_body (void *data) { stream_body_data *body_data = (stream_body_data *) data; SCM port = scm_fdes_to_port (body_data->fdes, body_data->mode, SCM_BOOL_F); - - SCM_REVEALED (port) = 1; + scm_set_port_revealed_x (port, SCM_INUM1); return port; } @@ -385,11 +383,11 @@ scm_i_init_guile (void *base) scm_storage_prehistory (); scm_threads_prehistory (base); /* requires storage_prehistory */ - scm_weaks_prehistory (); /* requires storage_prehistory */ + scm_weak_table_prehistory (); /* requires storage_prehistory */ #ifdef GUILE_DEBUG_MALLOC scm_debug_malloc_prehistory (); #endif - scm_symbols_prehistory (); /* requires weaks_prehistory */ + scm_symbols_prehistory (); /* requires weak_table_prehistory */ scm_modules_prehistory (); scm_init_array_handle (); scm_bootstrap_bytevectors (); /* Requires array-handle */ @@ -492,7 +490,9 @@ scm_i_init_guile (void *base) scm_init_throw (); /* Requires smob_prehistory */ scm_init_trees (); scm_init_version (); - scm_init_weaks (); + scm_init_weak_set (); + scm_init_weak_table (); + scm_init_weak_vectors (); scm_init_guardians (); /* requires smob_prehistory */ scm_init_vports (); scm_init_standard_ports (); /* Requires fports */ @@ -518,9 +518,7 @@ scm_i_init_guile (void *base) scm_initialized_p = 1; -#ifdef STACK_CHECKING scm_stack_checking_enabled_p = SCM_STACK_CHECKING_P; -#endif scm_init_rdelim (); scm_init_rw (); @@ -533,6 +531,9 @@ scm_i_init_guile (void *base) /* Capture the dynamic state after loading boot-9, so that new threads end up in the guile-user module. */ scm_init_threads_default_dynamic_state (); + + /* Finally, cause finalizers to run in a separate thread. */ + scm_init_finalizer_thread (); } /* diff --git a/libguile/inline.c b/libguile/inline.c index 591679413..6e7688c37 100644 --- a/libguile/inline.c +++ b/libguile/inline.c @@ -1,4 +1,4 @@ -/* Copyright (C) 2001, 2006, 2008, 2011, 2013 Free Software Foundation, Inc. +/* Copyright (C) 2001, 2006, 2008, 2011, 2012, 2013 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -26,3 +26,5 @@ #include "libguile/array-handle.h" #include "libguile/gc.h" #include "libguile/smob.h" +#include "libguile/pairs.h" +#include "libguile/ports.h" diff --git a/libguile/inline.h b/libguile/inline.h index 88ba7f747..3c9b09b6a 100644 --- a/libguile/inline.h +++ b/libguile/inline.h @@ -4,7 +4,7 @@ #define SCM_INLINE_H /* Copyright (C) 2001, 2002, 2003, 2004, 2006, 2008, 2009, 2010, - * 2011, 2013 Free Software Foundation, Inc. + * 2011, 2012, 2013 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -27,12 +27,8 @@ platforms that do support inline functions, the definitions are still compiled into the library, once, in inline.c. */ -#include <stdio.h> -#include <string.h> - #include "libguile/__scm.h" -#include "libguile/pairs.h" #include "libguile/gc.h" #include "libguile/threads.h" #include "libguile/array-handle.h" @@ -41,121 +37,21 @@ #include "libguile/error.h" -SCM_INLINE int scm_is_pair (SCM x); SCM_INLINE int scm_is_string (SCM x); -SCM_INLINE int scm_get_byte_or_eof (SCM port); -SCM_INLINE int scm_peek_byte_or_eof (SCM port); -SCM_INLINE void scm_putc (char c, SCM port); -SCM_INLINE void scm_puts (const char *str_data, SCM port); - - SCM_INLINE SCM scm_cell (scm_t_bits car, scm_t_bits cdr); SCM_INLINE SCM scm_double_cell (scm_t_bits car, scm_t_bits cbr, scm_t_bits ccr, scm_t_bits cdr); -SCM_INLINE SCM scm_words (scm_t_bits car, scm_t_uint16 n_words); +SCM_INLINE SCM scm_words (scm_t_bits car, scm_t_uint32 n_words); #if SCM_CAN_INLINE || defined SCM_INLINE_C_IMPLEMENTING_INLINES /* Either inlining, or being included from inline.c. */ SCM_INLINE_IMPLEMENTATION int -scm_is_pair (SCM x) -{ - /* The following "workaround_for_gcc_295" avoids bad code generated by - i386 gcc 2.95.4 (the Debian packaged 2.95.4-24 at least). - - Under the default -O2 the inlined SCM_I_CONSP test gets "optimized" so - the fetch of the tag word from x is done before confirming it's a - non-immediate (SCM_NIMP). Needless to say that bombs badly if x is a - immediate. This was seen to afflict scm_srfi1_split_at and something - deep in the bowels of ceval(). In both cases segvs resulted from - deferencing a random immediate value. srfi-1.test exposes the problem - through a short list, the immediate being SCM_EOL in that case. - Something in syntax.test exposed the ceval() problem. - - Just "volatile SCM workaround_for_gcc_295 = lst" is enough to avoid the - problem, without even using that variable. The "w=w" is just to - prevent a warning about it being unused. - */ -#if defined (__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 95 - volatile SCM workaround_for_gcc_295 = x; - workaround_for_gcc_295 = workaround_for_gcc_295; -#endif - - return SCM_I_CONSP (x); -} - -SCM_INLINE_IMPLEMENTATION int scm_is_string (SCM x) { - return SCM_NIMP (x) && (SCM_TYP7 (x) == scm_tc7_string); + return SCM_HAS_TYP7 (x, scm_tc7_string); } -/* Port I/O. */ - -SCM_INLINE_IMPLEMENTATION int -scm_get_byte_or_eof (SCM port) -{ - int c; - scm_t_port *pt = SCM_PTAB_ENTRY (port); - - if (pt->rw_active == SCM_PORT_WRITE) - /* may be marginally faster than calling scm_flush. */ - scm_ptobs[SCM_PTOBNUM (port)].flush (port); - - if (pt->rw_random) - pt->rw_active = SCM_PORT_READ; - - if (pt->read_pos >= pt->read_end) - { - if (SCM_UNLIKELY (scm_fill_input (port) == EOF)) - return EOF; - } - - c = *(pt->read_pos++); - - return c; -} - -/* Like `scm_get_byte_or_eof' but does not change PORT's `read_pos'. */ -SCM_INLINE_IMPLEMENTATION int -scm_peek_byte_or_eof (SCM port) -{ - int c; - scm_t_port *pt = SCM_PTAB_ENTRY (port); - - if (pt->rw_active == SCM_PORT_WRITE) - /* may be marginally faster than calling scm_flush. */ - scm_ptobs[SCM_PTOBNUM (port)].flush (port); - - if (pt->rw_random) - pt->rw_active = SCM_PORT_READ; - - if (pt->read_pos >= pt->read_end) - { - if (SCM_UNLIKELY (scm_fill_input (port) == EOF)) - return EOF; - } - - c = *pt->read_pos; - - return c; -} - -SCM_INLINE_IMPLEMENTATION void -scm_putc (char c, SCM port) -{ - SCM_ASSERT_TYPE (SCM_OPOUTPORTP (port), port, 0, NULL, "output port"); - scm_lfwrite (&c, 1, port); -} - -SCM_INLINE_IMPLEMENTATION void -scm_puts (const char *s, SCM port) -{ - SCM_ASSERT_TYPE (SCM_OPOUTPORTP (port), port, 0, NULL, "output port"); - scm_lfwrite (s, strlen (s), port); -} - - #endif #endif diff --git a/libguile/instructions.c b/libguile/instructions.c index ef4a9ce17..f3b8963d2 100644 --- a/libguile/instructions.c +++ b/libguile/instructions.c @@ -72,7 +72,7 @@ fetch_instruction_table () { table[i].opcode = i; if (table[i].name) - table[i].symname = scm_from_locale_symbol (table[i].name); + table[i].symname = scm_from_utf8_symbol (table[i].name); else table[i].symname = SCM_BOOL_F; } diff --git a/libguile/ioext.c b/libguile/ioext.c index 089ef1a01..94b0f4f0f 100644 --- a/libguile/ioext.c +++ b/libguile/ioext.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2006 Free Software Foundation, Inc. +/* Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2006, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -89,13 +89,13 @@ SCM_DEFINE (scm_redirect_port, "redirect-port", 2, 0, 0, { scm_t_port *pt = SCM_PTAB_ENTRY (new); scm_t_port *old_pt = SCM_PTAB_ENTRY (old); - scm_t_ptob_descriptor *ptob = &scm_ptobs[SCM_PTOBNUM (new)]; + scm_t_ptob_descriptor *ptob = SCM_PORT_DESCRIPTOR (new); /* must flush to old fdes. */ if (pt->rw_active == SCM_PORT_WRITE) ptob->flush (new); else if (pt->rw_active == SCM_PORT_READ) - scm_end_input (new); + scm_end_input_unlocked (new); ans = dup2 (oldfd, newfd); if (ans == -1) SCM_SYSERROR; @@ -269,7 +269,7 @@ SCM_DEFINE (scm_primitive_move_to_fdes, "primitive-move->fdes", 2, 0, 0, #undef FUNC_NAME static SCM -get_matching_port (void *closure, SCM port, SCM val, SCM result) +get_matching_port (void *closure, SCM port, SCM result) { int fd = * (int *) closure; scm_t_port *entry = SCM_PTAB_ENTRY (port); @@ -292,11 +292,9 @@ SCM_DEFINE (scm_fdes_to_ports, "fdes->ports", 1, 0, 0, SCM result = SCM_EOL; int int_fd = scm_to_int (fd); - scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex); - result = scm_internal_hash_fold (get_matching_port, - (void*) &int_fd, result, - scm_i_port_weak_hash); - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); + result = scm_c_weak_set_fold (get_matching_port, + (void*) &int_fd, result, + scm_i_port_weak_set); return result; } #undef FUNC_NAME diff --git a/libguile/keywords.c b/libguile/keywords.c index 3b9a9228c..e4a79ac4d 100644 --- a/libguile/keywords.c +++ b/libguile/keywords.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001, 2003, 2004, 2006, 2008, 2009 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001, 2003, 2004, 2006, 2008, 2009, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -47,7 +47,7 @@ scm_t_bits scm_tc16_keyword; static int keyword_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED) { - scm_puts ("#:", port); + scm_puts_unlocked ("#:", port); scm_display (KEYWORDSYM (exp), port); return 1; } diff --git a/libguile/list.c b/libguile/list.c index 6c8f8bef2..627640334 100644 --- a/libguile/list.c +++ b/libguile/list.c @@ -90,7 +90,7 @@ scm_list_n (SCM elt, ...) while (! SCM_UNBNDP (elt)) { #if (SCM_DEBUG_CELL_ACCESSES == 1) - if (SCM_NIMP (elt)) + if (SCM_HEAP_OBJECT_P (elt)) SCM_VALIDATE_CELL(elt, 0); #endif *pos = scm_cons (elt, SCM_EOL); diff --git a/libguile/load.c b/libguile/load.c index 84b670549..081c364e6 100644 --- a/libguile/load.c +++ b/libguile/load.c @@ -696,11 +696,11 @@ compiled_is_fresh (SCM full_filename, SCM compiled_filename, else { compiled_is_newer = 0; - scm_puts (";;; note: source file ", scm_current_error_port ()); + scm_puts_unlocked (";;; note: source file ", scm_current_error_port ()); scm_display (full_filename, scm_current_error_port ()); - scm_puts ("\n;;; newer than compiled ", scm_current_error_port ()); + scm_puts_unlocked ("\n;;; newer than compiled ", scm_current_error_port ()); scm_display (compiled_filename, scm_current_error_port ()); - scm_puts ("\n", scm_current_error_port ()); + scm_puts_unlocked ("\n", scm_current_error_port ()); } return compiled_is_newer; @@ -715,10 +715,10 @@ SCM_SYMBOL (sym_auto_compilation_options, "%auto-compilation-options"); static SCM do_try_auto_compile (void *data) { - SCM source = PTR2SCM (data); + SCM source = SCM_PACK_POINTER (data); SCM comp_mod, compile_file; - scm_puts (";;; compiling ", scm_current_error_port ()); + scm_puts_unlocked (";;; compiling ", scm_current_error_port ()); scm_display (source, scm_current_error_port ()); scm_newline (scm_current_error_port ()); @@ -747,16 +747,16 @@ do_try_auto_compile (void *data) /* Assume `*current-warning-prefix*' has an appropriate value. */ res = scm_call_n (scm_variable_ref (compile_file), args, 5); - scm_puts (";;; compiled ", scm_current_error_port ()); + scm_puts_unlocked (";;; compiled ", scm_current_error_port ()); scm_display (res, scm_current_error_port ()); scm_newline (scm_current_error_port ()); return res; } else { - scm_puts (";;; it seems ", scm_current_error_port ()); + scm_puts_unlocked (";;; it seems ", scm_current_error_port ()); scm_display (source, scm_current_error_port ()); - scm_puts ("\n;;; is part of the compiler; skipping auto-compilation\n", + scm_puts_unlocked ("\n;;; is part of the compiler; skipping auto-compilation\n", scm_current_error_port ()); return SCM_BOOL_F; } @@ -765,22 +765,22 @@ do_try_auto_compile (void *data) static SCM auto_compile_catch_handler (void *data, SCM tag, SCM throw_args) { - SCM source = PTR2SCM (data); + SCM source = SCM_PACK_POINTER (data); SCM oport, lines; oport = scm_open_output_string (); scm_print_exception (oport, SCM_BOOL_F, tag, throw_args); - scm_puts (";;; WARNING: compilation of ", scm_current_warning_port ()); + scm_puts_unlocked (";;; WARNING: compilation of ", scm_current_warning_port ()); scm_display (source, scm_current_warning_port ()); - scm_puts (" failed:\n", scm_current_warning_port ()); + scm_puts_unlocked (" failed:\n", scm_current_warning_port ()); lines = scm_string_split (scm_get_output_string (oport), SCM_MAKE_CHAR ('\n')); for (; scm_is_pair (lines); lines = scm_cdr (lines)) if (scm_c_string_length (scm_car (lines))) { - scm_puts (";;; ", scm_current_warning_port ()); + scm_puts_unlocked (";;; ", scm_current_warning_port ()); scm_display (scm_car (lines), scm_current_warning_port ()); scm_newline (scm_current_warning_port ()); } @@ -798,7 +798,7 @@ SCM_DEFINE (scm_sys_warn_auto_compilation_enabled, "%warn-auto-compilation-enabl if (!message_shown) { - scm_puts (";;; note: auto-compilation is enabled, set GUILE_AUTO_COMPILE=0\n" + scm_puts_unlocked (";;; note: auto-compilation is enabled, set GUILE_AUTO_COMPILE=0\n" ";;; or pass the --no-auto-compile argument to disable.\n", scm_current_warning_port ()); message_shown = 1; @@ -817,9 +817,9 @@ scm_try_auto_compile (SCM source) scm_sys_warn_auto_compilation_enabled (); return scm_c_catch (SCM_BOOL_T, do_try_auto_compile, - SCM2PTR (source), + SCM_UNPACK_POINTER (source), auto_compile_catch_handler, - SCM2PTR (source), + SCM_UNPACK_POINTER (source), NULL, NULL); } @@ -970,7 +970,7 @@ SCM_DEFINE (scm_primitive_load_path, "primitive-load-path", 0, 0, 1, if (stat_ret == 0 && compiled_is_fresh (full_filename, fallback, &stat_source, &stat_compiled)) { - scm_puts (";;; found fresh local cache at ", scm_current_warning_port ()); + scm_puts_unlocked (";;; found fresh local cache at ", scm_current_warning_port ()); scm_display (fallback, scm_current_warning_port ()); scm_newline (scm_current_warning_port ()); return scm_load_compiled_with_vm (fallback); @@ -1035,7 +1035,7 @@ init_build_info () for (i = 0; i < (sizeof (info) / sizeof (info[0])); i++) { - SCM key = scm_from_locale_symbol (info[i].name); + SCM key = scm_from_utf8_symbol (info[i].name); SCM val = scm_from_locale_string (info[i].value); *loc = scm_acons (key, val, *loc); } diff --git a/libguile/macros.c b/libguile/macros.c index fe33e7e48..47b252d85 100644 --- a/libguile/macros.c +++ b/libguile/macros.c @@ -49,11 +49,11 @@ static int macro_print (SCM macro, SCM port, scm_print_state *pstate) { if (scm_is_false (SCM_MACRO_TYPE (macro))) - scm_puts ("#<primitive-syntax-transformer ", port); + scm_puts_unlocked ("#<primitive-syntax-transformer ", port); else - scm_puts ("#<syntax-transformer ", port); + scm_puts_unlocked ("#<syntax-transformer ", port); scm_iprin1 (scm_macro_name (macro), port, pstate); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); return 1; } @@ -64,7 +64,7 @@ scm_i_make_primitive_macro (const char *name, scm_t_macro_primitive fn) { SCM z = scm_words (scm_tc16_macro, 5); SCM_SET_SMOB_DATA_N (z, 1, (scm_t_bits)fn); - SCM_SET_SMOB_OBJECT_N (z, 2, scm_from_locale_symbol (name)); + SCM_SET_SMOB_OBJECT_N (z, 2, scm_from_utf8_symbol (name)); SCM_SET_SMOB_OBJECT_N (z, 3, SCM_BOOL_F); SCM_SET_SMOB_OBJECT_N (z, 4, SCM_BOOL_F); return z; diff --git a/libguile/mallocs.c b/libguile/mallocs.c index 05c6a8529..b4499bc6d 100644 --- a/libguile/mallocs.c +++ b/libguile/mallocs.c @@ -1,5 +1,5 @@ /* classes: src_files - * Copyright (C) 1995,1997,1998,2000,2001, 2006 Free Software Foundation, Inc. + * Copyright (C) 1995,1997,1998,2000,2001, 2006, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -45,9 +45,9 @@ scm_t_bits scm_tc16_malloc; static int malloc_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED) { - scm_puts("#<malloc ", port); + scm_puts_unlocked("#<malloc ", port); scm_uintprint (SCM_SMOB_DATA (exp), 16, port); - scm_putc('>', port); + scm_putc_unlocked('>', port); return 1; } diff --git a/libguile/memoize.c b/libguile/memoize.c index 584096fbd..7431d3c0e 100644 --- a/libguile/memoize.c +++ b/libguile/memoize.c @@ -68,8 +68,8 @@ scm_t_bits scm_tc16_memoized; #define MAKMEMO(n, args) \ (scm_cell (scm_tc16_memoized | ((n) << 16), SCM_UNPACK (args))) -#define MAKMEMO_BEGIN(exps) \ - MAKMEMO (SCM_M_BEGIN, exps) +#define MAKMEMO_SEQ(head,tail) \ + MAKMEMO (SCM_M_SEQ, scm_cons (head, tail)) #define MAKMEMO_IF(test, then, else_) \ MAKMEMO (SCM_M_IF, scm_cons (test, scm_cons (then, else_))) #define FIXED_ARITY(nreq) \ @@ -126,7 +126,7 @@ scm_t_bits scm_tc16_memoizer; /* This table must agree with the list of M_ constants in memoize.h */ static const char *const memoized_tags[] = { - "begin", + "seq", "if", "lambda", "let", @@ -150,9 +150,9 @@ static const char *const memoized_tags[] = static int scm_print_memoized (SCM memoized, SCM port, scm_print_state *pstate) { - scm_puts ("#<memoized ", port); + scm_puts_unlocked ("#<memoized ", port); scm_write (scm_unmemoize_expression (memoized), port); - scm_puts (">", port); + scm_puts_unlocked (">", port); return 1; } @@ -243,12 +243,12 @@ memoize (SCM exp, SCM env) memoize (REF (exp, CONDITIONAL, CONSEQUENT), env), memoize (REF (exp, CONDITIONAL, ALTERNATE), env)); - case SCM_EXPANDED_APPLICATION: + case SCM_EXPANDED_CALL: { SCM proc, args; - proc = REF (exp, APPLICATION, PROC); - args = memoize_exps (REF (exp, APPLICATION, ARGS), env); + proc = REF (exp, CALL, PROC); + args = memoize_exps (REF (exp, CALL, ARGS), env); if (SCM_EXPANDED_TYPE (proc) == SCM_EXPANDED_TOPLEVEL_REF) { @@ -265,8 +265,23 @@ memoize (SCM exp, SCM env) return MAKMEMO_CALL (memoize (proc, env), scm_ilength (args), args); } - case SCM_EXPANDED_SEQUENCE: - return MAKMEMO_BEGIN (memoize_exps (REF (exp, SEQUENCE, EXPS), env)); + case SCM_EXPANDED_PRIMCALL: + { + SCM proc, args; + + if (scm_is_eq (scm_current_module (), scm_the_root_module ())) + proc = MAKMEMO_TOP_REF (REF (exp, PRIMCALL, NAME)); + else + proc = MAKMEMO_MOD_REF (list_of_guile, REF (exp, PRIMCALL, NAME), + SCM_BOOL_F); + args = memoize_exps (REF (exp, PRIMCALL, ARGS), env); + + return MAKMEMO_CALL (proc, scm_ilength (args), args); + } + + case SCM_EXPANDED_SEQ: + return MAKMEMO_SEQ (memoize (REF (exp, SEQ, HEAD), env), + memoize (REF (exp, SEQ, TAIL), env)); case SCM_EXPANDED_LAMBDA: /* The body will be a lambda-case. */ @@ -411,18 +426,21 @@ memoize (SCM exp, SCM env) if (in_order_p) { - SCM body_exps = SCM_EOL; + SCM body_exps = SCM_EOL, seq; for (; scm_is_pair (exps); exps = CDR (exps), i--) body_exps = scm_cons (MAKMEMO_LEX_SET (i-1, memoize (CAR (exps), new_env)), body_exps); - body_exps = scm_cons (memoize (body, new_env), body_exps); - body_exps = scm_reverse_x (body_exps, SCM_UNDEFINED); - return MAKMEMO_LET (undefs, MAKMEMO_BEGIN (body_exps)); + + seq = memoize (body, new_env); + for (; scm_is_pair (body_exps); body_exps = CDR (body_exps)) + seq = MAKMEMO_SEQ (CAR (body_exps), seq); + + return MAKMEMO_LET (undefs, seq); } else { - SCM sets = SCM_EOL, inits = SCM_EOL; + SCM sets = SCM_EOL, inits = SCM_EOL, set_seq; for (; scm_is_pair (exps); exps = CDR (exps), i--) { sets = scm_cons (MAKMEMO_LEX_SET ((i-1) + nvars, @@ -431,10 +449,18 @@ memoize (SCM exp, SCM env) inits = scm_cons (memoize (CAR (exps), new_env), inits); } inits = scm_reverse_x (inits, SCM_UNDEFINED); - return MAKMEMO_LET - (undefs, - MAKMEMO_BEGIN (scm_list_2 (MAKMEMO_LET (inits, MAKMEMO_BEGIN (sets)), - memoize (body, new_env)))); + + sets = scm_reverse_x (sets, SCM_UNDEFINED); + if (scm_is_null (sets)) + return memoize (body, env); + + for (set_seq = CAR (sets), sets = CDR (sets); scm_is_pair (sets); + sets = CDR (sets)) + set_seq = MAKMEMO_SEQ (CAR (sets), set_seq); + + return MAKMEMO_LET (undefs, + MAKMEMO_SEQ (MAKMEMO_LET (inits, set_seq), + memoize (body, new_env))); } } @@ -609,7 +635,7 @@ unmemoize_lexical (SCM n) char buf[16]; buf[15] = 0; snprintf (buf, 15, "<%u>", scm_to_uint32 (n)); - return scm_from_locale_symbol (buf); + return scm_from_utf8_symbol (buf); } static SCM @@ -625,8 +651,9 @@ unmemoize (const SCM expr) { case SCM_M_APPLY: return scm_cons (scm_sym_atapply, unmemoize_exprs (args)); - case SCM_M_BEGIN: - return scm_cons (scm_sym_begin, unmemoize_exprs (args)); + case SCM_M_SEQ: + return scm_list_3 (scm_sym_begin, unmemoize (CAR (args)), + unmemoize (CDR (args))); case SCM_M_CALL: return scm_cons (unmemoize (CAR (args)), unmemoize_exprs (CDDR (args))); case SCM_M_CONT: diff --git a/libguile/memoize.h b/libguile/memoize.h index 26bd5b1c1..da78b06fa 100644 --- a/libguile/memoize.h +++ b/libguile/memoize.h @@ -3,7 +3,7 @@ #ifndef SCM_MEMOIZE_H #define SCM_MEMOIZE_H -/* Copyright (C) 1995,1996,1998,1999,2000,2001,2002,2004,2008,2009,2010 +/* Copyright (C) 1995,1996,1998,1999,2000,2001,2002,2004,2008,2009,2010,2011 * Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or @@ -72,7 +72,7 @@ SCM_INTERNAL scm_t_bits scm_tc16_memoized; enum { - SCM_M_BEGIN, + SCM_M_SEQ, SCM_M_IF, SCM_M_LAMBDA, SCM_M_LET, diff --git a/libguile/modules.c b/libguile/modules.c index 7b42a3d43..d87ec7a64 100644 --- a/libguile/modules.c +++ b/libguile/modules.c @@ -154,7 +154,7 @@ convert_module_name (const char *name) ptr++; if (ptr > name) { - SCM sym = scm_from_locale_symboln (name, ptr-name); + SCM sym = scm_from_utf8_symboln (name, ptr-name); *tail = scm_cons (sym, SCM_EOL); tail = SCM_CDRLOC (*tail); } @@ -219,7 +219,7 @@ scm_c_export (const char *name, ...) if (name) { va_list ap; - SCM names = scm_cons (scm_from_locale_symbol (name), SCM_EOL); + SCM names = scm_cons (scm_from_utf8_symbol (name), SCM_EOL); SCM *tail = SCM_CDRLOC (names); va_start (ap, name); while (1) @@ -227,7 +227,7 @@ scm_c_export (const char *name, ...) const char *n = va_arg (ap, const char *); if (n == NULL) break; - *tail = scm_cons (scm_from_locale_symbol (n), SCM_EOL); + *tail = scm_cons (scm_from_utf8_symbol (n), SCM_EOL); tail = SCM_CDRLOC (*tail); } va_end (ap); @@ -601,7 +601,7 @@ scm_module_public_interface (SCM module) SCM scm_c_module_lookup (SCM module, const char *name) { - return scm_module_lookup (module, scm_from_locale_symbol (name)); + return scm_module_lookup (module, scm_from_utf8_symbol (name)); } SCM @@ -619,7 +619,7 @@ scm_module_lookup (SCM module, SCM sym) SCM scm_c_lookup (const char *name) { - return scm_lookup (scm_from_locale_symbol (name)); + return scm_lookup (scm_from_utf8_symbol (name)); } SCM @@ -668,14 +668,14 @@ SCM scm_c_public_variable (const char *module_name, const char *name) { return scm_public_variable (convert_module_name (module_name), - scm_from_locale_symbol (name)); + scm_from_utf8_symbol (name)); } SCM scm_c_private_variable (const char *module_name, const char *name) { return scm_private_variable (convert_module_name (module_name), - scm_from_locale_symbol (name)); + scm_from_utf8_symbol (name)); } SCM @@ -710,14 +710,14 @@ SCM scm_c_public_lookup (const char *module_name, const char *name) { return scm_public_lookup (convert_module_name (module_name), - scm_from_locale_symbol (name)); + scm_from_utf8_symbol (name)); } SCM scm_c_private_lookup (const char *module_name, const char *name) { return scm_private_lookup (convert_module_name (module_name), - scm_from_locale_symbol (name)); + scm_from_utf8_symbol (name)); } SCM @@ -736,20 +736,20 @@ SCM scm_c_public_ref (const char *module_name, const char *name) { return scm_public_ref (convert_module_name (module_name), - scm_from_locale_symbol (name)); + scm_from_utf8_symbol (name)); } SCM scm_c_private_ref (const char *module_name, const char *name) { return scm_private_ref (convert_module_name (module_name), - scm_from_locale_symbol (name)); + scm_from_utf8_symbol (name)); } SCM scm_c_module_define (SCM module, const char *name, SCM value) { - return scm_module_define (module, scm_from_locale_symbol (name), value); + return scm_module_define (module, scm_from_utf8_symbol (name), value); } SCM @@ -768,7 +768,7 @@ scm_module_define (SCM module, SCM sym, SCM value) SCM scm_c_define (const char *name, SCM value) { - return scm_define (scm_from_locale_symbol (name), value); + return scm_define (scm_from_utf8_symbol (name), value); } SCM_DEFINE (scm_define, "define!", 2, 0, 0, @@ -819,16 +819,8 @@ SCM_DEFINE (scm_module_reverse_lookup, "module-reverse-lookup", 2, 0, 0, { handle = SCM_CAR (ls); - if (SCM_UNPACK (SCM_CAR (handle)) == 0) - { - /* FIXME: We hit a weak pair whose car has become unreachable. - We should remove the pair in question or something. */ - } - else - { - if (scm_is_eq (SCM_CDR (handle), variable)) - return SCM_CAR (handle); - } + if (scm_is_eq (SCM_CDR (handle), variable)) + return SCM_CAR (handle); ls = SCM_CDR (ls); } @@ -867,7 +859,7 @@ SCM_SYMBOL (scm_sym_system_module, "system-module"); void scm_modules_prehistory () { - scm_pre_modules_obarray = scm_c_make_hash_table (1533); + scm_pre_modules_obarray = scm_c_make_hash_table (1790); } void diff --git a/libguile/numbers.c b/libguile/numbers.c index 66c95db90..01f8e05ac 100644 --- a/libguile/numbers.c +++ b/libguile/numbers.c @@ -183,7 +183,7 @@ finalize_bignum (void *ptr, void *data) { SCM bignum; - bignum = PTR2SCM (ptr); + bignum = SCM_PACK_POINTER (ptr); mpz_clear (SCM_I_BIG_MPZ (bignum)); } @@ -558,7 +558,7 @@ SCM_PRIMITIVE_GENERIC (scm_exact_p, "exact?", 1, 0, 0, else if (SCM_NUMBERP (x)) return SCM_BOOL_T; else - SCM_WTA_DISPATCH_1 (g_scm_exact_p, x, 1, s_scm_exact_p); + return scm_wta_dispatch_1 (g_scm_exact_p, x, 1, s_scm_exact_p); } #undef FUNC_NAME @@ -579,7 +579,7 @@ SCM_PRIMITIVE_GENERIC (scm_inexact_p, "inexact?", 1, 0, 0, else if (SCM_NUMBERP (x)) return SCM_BOOL_F; else - SCM_WTA_DISPATCH_1 (g_scm_inexact_p, x, 1, s_scm_inexact_p); + return scm_wta_dispatch_1 (g_scm_inexact_p, x, 1, s_scm_inexact_p); } #undef FUNC_NAME @@ -618,7 +618,7 @@ SCM_PRIMITIVE_GENERIC (scm_odd_p, "odd?", 1, 0, 0, return SCM_BOOL_F; } } - SCM_WTA_DISPATCH_1 (g_scm_odd_p, n, 1, s_scm_odd_p); + return scm_wta_dispatch_1 (g_scm_odd_p, n, 1, s_scm_odd_p); } #undef FUNC_NAME @@ -652,7 +652,7 @@ SCM_PRIMITIVE_GENERIC (scm_even_p, "even?", 1, 0, 0, return SCM_BOOL_T; } } - SCM_WTA_DISPATCH_1 (g_scm_even_p, n, 1, s_scm_even_p); + return scm_wta_dispatch_1 (g_scm_even_p, n, 1, s_scm_even_p); } #undef FUNC_NAME @@ -667,7 +667,7 @@ SCM_PRIMITIVE_GENERIC (scm_finite_p, "finite?", 1, 0, 0, else if (scm_is_real (x)) return SCM_BOOL_T; else - SCM_WTA_DISPATCH_1 (g_scm_finite_p, x, 1, s_scm_finite_p); + return scm_wta_dispatch_1 (g_scm_finite_p, x, 1, s_scm_finite_p); } #undef FUNC_NAME @@ -682,7 +682,7 @@ SCM_PRIMITIVE_GENERIC (scm_inf_p, "inf?", 1, 0, 0, else if (scm_is_real (x)) return SCM_BOOL_F; else - SCM_WTA_DISPATCH_1 (g_scm_inf_p, x, 1, s_scm_inf_p); + return scm_wta_dispatch_1 (g_scm_inf_p, x, 1, s_scm_inf_p); } #undef FUNC_NAME @@ -697,7 +697,7 @@ SCM_PRIMITIVE_GENERIC (scm_nan_p, "nan?", 1, 0, 0, else if (scm_is_real (x)) return SCM_BOOL_F; else - SCM_WTA_DISPATCH_1 (g_scm_nan_p, x, 1, s_scm_nan_p); + return scm_wta_dispatch_1 (g_scm_nan_p, x, 1, s_scm_nan_p); } #undef FUNC_NAME @@ -824,7 +824,7 @@ SCM_PRIMITIVE_GENERIC (scm_abs, "abs", 1, 0, 0, SCM_FRACTION_DENOMINATOR (x)); } else - SCM_WTA_DISPATCH_1 (g_scm_abs, x, 1, s_scm_abs); + return scm_wta_dispatch_1 (g_scm_abs, x, 1, s_scm_abs); } #undef FUNC_NAME @@ -839,10 +839,10 @@ SCM_PRIMITIVE_GENERIC (scm_quotient, "quotient", 2, 0, 0, if (SCM_LIKELY (scm_is_integer (y))) return scm_truncate_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_quotient, x, y, SCM_ARG2, s_scm_quotient); + return scm_wta_dispatch_2 (g_scm_quotient, x, y, SCM_ARG2, s_scm_quotient); } else - SCM_WTA_DISPATCH_2 (g_scm_quotient, x, y, SCM_ARG1, s_scm_quotient); + return scm_wta_dispatch_2 (g_scm_quotient, x, y, SCM_ARG1, s_scm_quotient); } #undef FUNC_NAME @@ -860,10 +860,10 @@ SCM_PRIMITIVE_GENERIC (scm_remainder, "remainder", 2, 0, 0, if (SCM_LIKELY (scm_is_integer (y))) return scm_truncate_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_remainder, x, y, SCM_ARG2, s_scm_remainder); + return scm_wta_dispatch_2 (g_scm_remainder, x, y, SCM_ARG2, s_scm_remainder); } else - SCM_WTA_DISPATCH_2 (g_scm_remainder, x, y, SCM_ARG1, s_scm_remainder); + return scm_wta_dispatch_2 (g_scm_remainder, x, y, SCM_ARG1, s_scm_remainder); } #undef FUNC_NAME @@ -882,10 +882,10 @@ SCM_PRIMITIVE_GENERIC (scm_modulo, "modulo", 2, 0, 0, if (SCM_LIKELY (scm_is_integer (y))) return scm_floor_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_modulo, x, y, SCM_ARG2, s_scm_modulo); + return scm_wta_dispatch_2 (g_scm_modulo, x, y, SCM_ARG2, s_scm_modulo); } else - SCM_WTA_DISPATCH_2 (g_scm_modulo, x, y, SCM_ARG1, s_scm_modulo); + return scm_wta_dispatch_2 (g_scm_modulo, x, y, SCM_ARG1, s_scm_modulo); } #undef FUNC_NAME @@ -906,10 +906,9 @@ static void two_valued_wta_dispatch_2 (SCM gf, SCM a1, SCM a2, int pos, const char *subr, SCM *rp1, SCM *rp2) { - if (SCM_UNPACK (gf)) - scm_i_extract_values_2 (scm_call_generic_2 (gf, a1, a2), rp1, rp2); - else - scm_wrong_type_arg (subr, pos, (pos == SCM_ARG1) ? a1 : a2); + SCM vals = scm_wta_dispatch_2 (gf, a1, a2, pos, subr); + + scm_i_extract_values_2 (vals, rp1, rp2); } SCM_DEFINE (scm_euclidean_quotient, "euclidean-quotient", 2, 0, 0, @@ -1041,8 +1040,8 @@ SCM_PRIMITIVE_GENERIC (scm_floor_quotient, "floor-quotient", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_floor_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_floor_quotient, x, y, SCM_ARG2, - s_scm_floor_quotient); + return scm_wta_dispatch_2 (g_scm_floor_quotient, x, y, SCM_ARG2, + s_scm_floor_quotient); } else if (SCM_BIGP (x)) { @@ -1082,8 +1081,8 @@ SCM_PRIMITIVE_GENERIC (scm_floor_quotient, "floor-quotient", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_floor_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_floor_quotient, x, y, SCM_ARG2, - s_scm_floor_quotient); + return scm_wta_dispatch_2 (g_scm_floor_quotient, x, y, SCM_ARG2, + s_scm_floor_quotient); } else if (SCM_REALP (x)) { @@ -1092,8 +1091,8 @@ SCM_PRIMITIVE_GENERIC (scm_floor_quotient, "floor-quotient", 2, 0, 0, return scm_i_inexact_floor_quotient (SCM_REAL_VALUE (x), scm_to_double (y)); else - SCM_WTA_DISPATCH_2 (g_scm_floor_quotient, x, y, SCM_ARG2, - s_scm_floor_quotient); + return scm_wta_dispatch_2 (g_scm_floor_quotient, x, y, SCM_ARG2, + s_scm_floor_quotient); } else if (SCM_FRACTIONP (x)) { @@ -1103,12 +1102,12 @@ SCM_PRIMITIVE_GENERIC (scm_floor_quotient, "floor-quotient", 2, 0, 0, else if (SCM_I_INUMP (y) || SCM_BIGP (y) || SCM_FRACTIONP (y)) return scm_i_exact_rational_floor_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_floor_quotient, x, y, SCM_ARG2, - s_scm_floor_quotient); + return scm_wta_dispatch_2 (g_scm_floor_quotient, x, y, SCM_ARG2, + s_scm_floor_quotient); } else - SCM_WTA_DISPATCH_2 (g_scm_floor_quotient, x, y, SCM_ARG1, - s_scm_floor_quotient); + return scm_wta_dispatch_2 (g_scm_floor_quotient, x, y, SCM_ARG1, + s_scm_floor_quotient); } #undef FUNC_NAME @@ -1201,8 +1200,8 @@ SCM_PRIMITIVE_GENERIC (scm_floor_remainder, "floor-remainder", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_floor_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_floor_remainder, x, y, SCM_ARG2, - s_scm_floor_remainder); + return scm_wta_dispatch_2 (g_scm_floor_remainder, x, y, SCM_ARG2, + s_scm_floor_remainder); } else if (SCM_BIGP (x)) { @@ -1237,8 +1236,8 @@ SCM_PRIMITIVE_GENERIC (scm_floor_remainder, "floor-remainder", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_floor_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_floor_remainder, x, y, SCM_ARG2, - s_scm_floor_remainder); + return scm_wta_dispatch_2 (g_scm_floor_remainder, x, y, SCM_ARG2, + s_scm_floor_remainder); } else if (SCM_REALP (x)) { @@ -1247,8 +1246,8 @@ SCM_PRIMITIVE_GENERIC (scm_floor_remainder, "floor-remainder", 2, 0, 0, return scm_i_inexact_floor_remainder (SCM_REAL_VALUE (x), scm_to_double (y)); else - SCM_WTA_DISPATCH_2 (g_scm_floor_remainder, x, y, SCM_ARG2, - s_scm_floor_remainder); + return scm_wta_dispatch_2 (g_scm_floor_remainder, x, y, SCM_ARG2, + s_scm_floor_remainder); } else if (SCM_FRACTIONP (x)) { @@ -1258,12 +1257,12 @@ SCM_PRIMITIVE_GENERIC (scm_floor_remainder, "floor-remainder", 2, 0, 0, else if (SCM_I_INUMP (y) || SCM_BIGP (y) || SCM_FRACTIONP (y)) return scm_i_exact_rational_floor_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_floor_remainder, x, y, SCM_ARG2, - s_scm_floor_remainder); + return scm_wta_dispatch_2 (g_scm_floor_remainder, x, y, SCM_ARG2, + s_scm_floor_remainder); } else - SCM_WTA_DISPATCH_2 (g_scm_floor_remainder, x, y, SCM_ARG1, - s_scm_floor_remainder); + return scm_wta_dispatch_2 (g_scm_floor_remainder, x, y, SCM_ARG1, + s_scm_floor_remainder); } #undef FUNC_NAME @@ -1574,8 +1573,8 @@ SCM_PRIMITIVE_GENERIC (scm_ceiling_quotient, "ceiling-quotient", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_ceiling_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_ceiling_quotient, x, y, SCM_ARG2, - s_scm_ceiling_quotient); + return scm_wta_dispatch_2 (g_scm_ceiling_quotient, x, y, SCM_ARG2, + s_scm_ceiling_quotient); } else if (SCM_BIGP (x)) { @@ -1615,8 +1614,8 @@ SCM_PRIMITIVE_GENERIC (scm_ceiling_quotient, "ceiling-quotient", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_ceiling_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_ceiling_quotient, x, y, SCM_ARG2, - s_scm_ceiling_quotient); + return scm_wta_dispatch_2 (g_scm_ceiling_quotient, x, y, SCM_ARG2, + s_scm_ceiling_quotient); } else if (SCM_REALP (x)) { @@ -1625,8 +1624,8 @@ SCM_PRIMITIVE_GENERIC (scm_ceiling_quotient, "ceiling-quotient", 2, 0, 0, return scm_i_inexact_ceiling_quotient (SCM_REAL_VALUE (x), scm_to_double (y)); else - SCM_WTA_DISPATCH_2 (g_scm_ceiling_quotient, x, y, SCM_ARG2, - s_scm_ceiling_quotient); + return scm_wta_dispatch_2 (g_scm_ceiling_quotient, x, y, SCM_ARG2, + s_scm_ceiling_quotient); } else if (SCM_FRACTIONP (x)) { @@ -1636,12 +1635,12 @@ SCM_PRIMITIVE_GENERIC (scm_ceiling_quotient, "ceiling-quotient", 2, 0, 0, else if (SCM_I_INUMP (y) || SCM_BIGP (y) || SCM_FRACTIONP (y)) return scm_i_exact_rational_ceiling_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_ceiling_quotient, x, y, SCM_ARG2, - s_scm_ceiling_quotient); + return scm_wta_dispatch_2 (g_scm_ceiling_quotient, x, y, SCM_ARG2, + s_scm_ceiling_quotient); } else - SCM_WTA_DISPATCH_2 (g_scm_ceiling_quotient, x, y, SCM_ARG1, - s_scm_ceiling_quotient); + return scm_wta_dispatch_2 (g_scm_ceiling_quotient, x, y, SCM_ARG1, + s_scm_ceiling_quotient); } #undef FUNC_NAME @@ -1744,8 +1743,8 @@ SCM_PRIMITIVE_GENERIC (scm_ceiling_remainder, "ceiling-remainder", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_ceiling_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_ceiling_remainder, x, y, SCM_ARG2, - s_scm_ceiling_remainder); + return scm_wta_dispatch_2 (g_scm_ceiling_remainder, x, y, SCM_ARG2, + s_scm_ceiling_remainder); } else if (SCM_BIGP (x)) { @@ -1780,8 +1779,8 @@ SCM_PRIMITIVE_GENERIC (scm_ceiling_remainder, "ceiling-remainder", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_ceiling_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_ceiling_remainder, x, y, SCM_ARG2, - s_scm_ceiling_remainder); + return scm_wta_dispatch_2 (g_scm_ceiling_remainder, x, y, SCM_ARG2, + s_scm_ceiling_remainder); } else if (SCM_REALP (x)) { @@ -1790,8 +1789,8 @@ SCM_PRIMITIVE_GENERIC (scm_ceiling_remainder, "ceiling-remainder", 2, 0, 0, return scm_i_inexact_ceiling_remainder (SCM_REAL_VALUE (x), scm_to_double (y)); else - SCM_WTA_DISPATCH_2 (g_scm_ceiling_remainder, x, y, SCM_ARG2, - s_scm_ceiling_remainder); + return scm_wta_dispatch_2 (g_scm_ceiling_remainder, x, y, SCM_ARG2, + s_scm_ceiling_remainder); } else if (SCM_FRACTIONP (x)) { @@ -1801,12 +1800,12 @@ SCM_PRIMITIVE_GENERIC (scm_ceiling_remainder, "ceiling-remainder", 2, 0, 0, else if (SCM_I_INUMP (y) || SCM_BIGP (y) || SCM_FRACTIONP (y)) return scm_i_exact_rational_ceiling_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_ceiling_remainder, x, y, SCM_ARG2, - s_scm_ceiling_remainder); + return scm_wta_dispatch_2 (g_scm_ceiling_remainder, x, y, SCM_ARG2, + s_scm_ceiling_remainder); } else - SCM_WTA_DISPATCH_2 (g_scm_ceiling_remainder, x, y, SCM_ARG1, - s_scm_ceiling_remainder); + return scm_wta_dispatch_2 (g_scm_ceiling_remainder, x, y, SCM_ARG1, + s_scm_ceiling_remainder); } #undef FUNC_NAME @@ -2106,8 +2105,8 @@ SCM_PRIMITIVE_GENERIC (scm_truncate_quotient, "truncate-quotient", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_truncate_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_truncate_quotient, x, y, SCM_ARG2, - s_scm_truncate_quotient); + return scm_wta_dispatch_2 (g_scm_truncate_quotient, x, y, SCM_ARG2, + s_scm_truncate_quotient); } else if (SCM_BIGP (x)) { @@ -2147,8 +2146,8 @@ SCM_PRIMITIVE_GENERIC (scm_truncate_quotient, "truncate-quotient", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_truncate_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_truncate_quotient, x, y, SCM_ARG2, - s_scm_truncate_quotient); + return scm_wta_dispatch_2 (g_scm_truncate_quotient, x, y, SCM_ARG2, + s_scm_truncate_quotient); } else if (SCM_REALP (x)) { @@ -2157,8 +2156,8 @@ SCM_PRIMITIVE_GENERIC (scm_truncate_quotient, "truncate-quotient", 2, 0, 0, return scm_i_inexact_truncate_quotient (SCM_REAL_VALUE (x), scm_to_double (y)); else - SCM_WTA_DISPATCH_2 (g_scm_truncate_quotient, x, y, SCM_ARG2, - s_scm_truncate_quotient); + return scm_wta_dispatch_2 (g_scm_truncate_quotient, x, y, SCM_ARG2, + s_scm_truncate_quotient); } else if (SCM_FRACTIONP (x)) { @@ -2168,12 +2167,12 @@ SCM_PRIMITIVE_GENERIC (scm_truncate_quotient, "truncate-quotient", 2, 0, 0, else if (SCM_I_INUMP (y) || SCM_BIGP (y) || SCM_FRACTIONP (y)) return scm_i_exact_rational_truncate_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_truncate_quotient, x, y, SCM_ARG2, - s_scm_truncate_quotient); + return scm_wta_dispatch_2 (g_scm_truncate_quotient, x, y, SCM_ARG2, + s_scm_truncate_quotient); } else - SCM_WTA_DISPATCH_2 (g_scm_truncate_quotient, x, y, SCM_ARG1, - s_scm_truncate_quotient); + return scm_wta_dispatch_2 (g_scm_truncate_quotient, x, y, SCM_ARG1, + s_scm_truncate_quotient); } #undef FUNC_NAME @@ -2241,8 +2240,8 @@ SCM_PRIMITIVE_GENERIC (scm_truncate_remainder, "truncate-remainder", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_truncate_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_truncate_remainder, x, y, SCM_ARG2, - s_scm_truncate_remainder); + return scm_wta_dispatch_2 (g_scm_truncate_remainder, x, y, SCM_ARG2, + s_scm_truncate_remainder); } else if (SCM_BIGP (x)) { @@ -2275,8 +2274,8 @@ SCM_PRIMITIVE_GENERIC (scm_truncate_remainder, "truncate-remainder", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_truncate_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_truncate_remainder, x, y, SCM_ARG2, - s_scm_truncate_remainder); + return scm_wta_dispatch_2 (g_scm_truncate_remainder, x, y, SCM_ARG2, + s_scm_truncate_remainder); } else if (SCM_REALP (x)) { @@ -2285,8 +2284,8 @@ SCM_PRIMITIVE_GENERIC (scm_truncate_remainder, "truncate-remainder", 2, 0, 0, return scm_i_inexact_truncate_remainder (SCM_REAL_VALUE (x), scm_to_double (y)); else - SCM_WTA_DISPATCH_2 (g_scm_truncate_remainder, x, y, SCM_ARG2, - s_scm_truncate_remainder); + return scm_wta_dispatch_2 (g_scm_truncate_remainder, x, y, SCM_ARG2, + s_scm_truncate_remainder); } else if (SCM_FRACTIONP (x)) { @@ -2296,12 +2295,12 @@ SCM_PRIMITIVE_GENERIC (scm_truncate_remainder, "truncate-remainder", 2, 0, 0, else if (SCM_I_INUMP (y) || SCM_BIGP (y) || SCM_FRACTIONP (y)) return scm_i_exact_rational_truncate_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_truncate_remainder, x, y, SCM_ARG2, - s_scm_truncate_remainder); + return scm_wta_dispatch_2 (g_scm_truncate_remainder, x, y, SCM_ARG2, + s_scm_truncate_remainder); } else - SCM_WTA_DISPATCH_2 (g_scm_truncate_remainder, x, y, SCM_ARG1, - s_scm_truncate_remainder); + return scm_wta_dispatch_2 (g_scm_truncate_remainder, x, y, SCM_ARG1, + s_scm_truncate_remainder); } #undef FUNC_NAME @@ -2588,8 +2587,8 @@ SCM_PRIMITIVE_GENERIC (scm_centered_quotient, "centered-quotient", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_centered_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_centered_quotient, x, y, SCM_ARG2, - s_scm_centered_quotient); + return scm_wta_dispatch_2 (g_scm_centered_quotient, x, y, SCM_ARG2, + s_scm_centered_quotient); } else if (SCM_BIGP (x)) { @@ -2637,8 +2636,8 @@ SCM_PRIMITIVE_GENERIC (scm_centered_quotient, "centered-quotient", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_centered_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_centered_quotient, x, y, SCM_ARG2, - s_scm_centered_quotient); + return scm_wta_dispatch_2 (g_scm_centered_quotient, x, y, SCM_ARG2, + s_scm_centered_quotient); } else if (SCM_REALP (x)) { @@ -2647,8 +2646,8 @@ SCM_PRIMITIVE_GENERIC (scm_centered_quotient, "centered-quotient", 2, 0, 0, return scm_i_inexact_centered_quotient (SCM_REAL_VALUE (x), scm_to_double (y)); else - SCM_WTA_DISPATCH_2 (g_scm_centered_quotient, x, y, SCM_ARG2, - s_scm_centered_quotient); + return scm_wta_dispatch_2 (g_scm_centered_quotient, x, y, SCM_ARG2, + s_scm_centered_quotient); } else if (SCM_FRACTIONP (x)) { @@ -2658,12 +2657,12 @@ SCM_PRIMITIVE_GENERIC (scm_centered_quotient, "centered-quotient", 2, 0, 0, else if (SCM_I_INUMP (y) || SCM_BIGP (y) || SCM_FRACTIONP (y)) return scm_i_exact_rational_centered_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_centered_quotient, x, y, SCM_ARG2, - s_scm_centered_quotient); + return scm_wta_dispatch_2 (g_scm_centered_quotient, x, y, SCM_ARG2, + s_scm_centered_quotient); } else - SCM_WTA_DISPATCH_2 (g_scm_centered_quotient, x, y, SCM_ARG1, - s_scm_centered_quotient); + return scm_wta_dispatch_2 (g_scm_centered_quotient, x, y, SCM_ARG1, + s_scm_centered_quotient); } #undef FUNC_NAME @@ -2802,8 +2801,8 @@ SCM_PRIMITIVE_GENERIC (scm_centered_remainder, "centered-remainder", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_centered_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_centered_remainder, x, y, SCM_ARG2, - s_scm_centered_remainder); + return scm_wta_dispatch_2 (g_scm_centered_remainder, x, y, SCM_ARG2, + s_scm_centered_remainder); } else if (SCM_BIGP (x)) { @@ -2843,8 +2842,8 @@ SCM_PRIMITIVE_GENERIC (scm_centered_remainder, "centered-remainder", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_centered_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_centered_remainder, x, y, SCM_ARG2, - s_scm_centered_remainder); + return scm_wta_dispatch_2 (g_scm_centered_remainder, x, y, SCM_ARG2, + s_scm_centered_remainder); } else if (SCM_REALP (x)) { @@ -2853,8 +2852,8 @@ SCM_PRIMITIVE_GENERIC (scm_centered_remainder, "centered-remainder", 2, 0, 0, return scm_i_inexact_centered_remainder (SCM_REAL_VALUE (x), scm_to_double (y)); else - SCM_WTA_DISPATCH_2 (g_scm_centered_remainder, x, y, SCM_ARG2, - s_scm_centered_remainder); + return scm_wta_dispatch_2 (g_scm_centered_remainder, x, y, SCM_ARG2, + s_scm_centered_remainder); } else if (SCM_FRACTIONP (x)) { @@ -2864,12 +2863,12 @@ SCM_PRIMITIVE_GENERIC (scm_centered_remainder, "centered-remainder", 2, 0, 0, else if (SCM_I_INUMP (y) || SCM_BIGP (y) || SCM_FRACTIONP (y)) return scm_i_exact_rational_centered_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_centered_remainder, x, y, SCM_ARG2, - s_scm_centered_remainder); + return scm_wta_dispatch_2 (g_scm_centered_remainder, x, y, SCM_ARG2, + s_scm_centered_remainder); } else - SCM_WTA_DISPATCH_2 (g_scm_centered_remainder, x, y, SCM_ARG1, - s_scm_centered_remainder); + return scm_wta_dispatch_2 (g_scm_centered_remainder, x, y, SCM_ARG1, + s_scm_centered_remainder); } #undef FUNC_NAME @@ -3284,8 +3283,8 @@ SCM_PRIMITIVE_GENERIC (scm_round_quotient, "round-quotient", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_round_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_round_quotient, x, y, SCM_ARG2, - s_scm_round_quotient); + return scm_wta_dispatch_2 (g_scm_round_quotient, x, y, SCM_ARG2, + s_scm_round_quotient); } else if (SCM_BIGP (x)) { @@ -3335,8 +3334,8 @@ SCM_PRIMITIVE_GENERIC (scm_round_quotient, "round-quotient", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_round_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_round_quotient, x, y, SCM_ARG2, - s_scm_round_quotient); + return scm_wta_dispatch_2 (g_scm_round_quotient, x, y, SCM_ARG2, + s_scm_round_quotient); } else if (SCM_REALP (x)) { @@ -3345,8 +3344,8 @@ SCM_PRIMITIVE_GENERIC (scm_round_quotient, "round-quotient", 2, 0, 0, return scm_i_inexact_round_quotient (SCM_REAL_VALUE (x), scm_to_double (y)); else - SCM_WTA_DISPATCH_2 (g_scm_round_quotient, x, y, SCM_ARG2, - s_scm_round_quotient); + return scm_wta_dispatch_2 (g_scm_round_quotient, x, y, SCM_ARG2, + s_scm_round_quotient); } else if (SCM_FRACTIONP (x)) { @@ -3356,12 +3355,12 @@ SCM_PRIMITIVE_GENERIC (scm_round_quotient, "round-quotient", 2, 0, 0, else if (SCM_I_INUMP (y) || SCM_BIGP (y) || SCM_FRACTIONP (y)) return scm_i_exact_rational_round_quotient (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_round_quotient, x, y, SCM_ARG2, - s_scm_round_quotient); + return scm_wta_dispatch_2 (g_scm_round_quotient, x, y, SCM_ARG2, + s_scm_round_quotient); } else - SCM_WTA_DISPATCH_2 (g_scm_round_quotient, x, y, SCM_ARG1, - s_scm_round_quotient); + return scm_wta_dispatch_2 (g_scm_round_quotient, x, y, SCM_ARG1, + s_scm_round_quotient); } #undef FUNC_NAME @@ -3488,8 +3487,8 @@ SCM_PRIMITIVE_GENERIC (scm_round_remainder, "round-remainder", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_round_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_round_remainder, x, y, SCM_ARG2, - s_scm_round_remainder); + return scm_wta_dispatch_2 (g_scm_round_remainder, x, y, SCM_ARG2, + s_scm_round_remainder); } else if (SCM_BIGP (x)) { @@ -3536,8 +3535,8 @@ SCM_PRIMITIVE_GENERIC (scm_round_remainder, "round-remainder", 2, 0, 0, else if (SCM_FRACTIONP (y)) return scm_i_exact_rational_round_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_round_remainder, x, y, SCM_ARG2, - s_scm_round_remainder); + return scm_wta_dispatch_2 (g_scm_round_remainder, x, y, SCM_ARG2, + s_scm_round_remainder); } else if (SCM_REALP (x)) { @@ -3546,8 +3545,8 @@ SCM_PRIMITIVE_GENERIC (scm_round_remainder, "round-remainder", 2, 0, 0, return scm_i_inexact_round_remainder (SCM_REAL_VALUE (x), scm_to_double (y)); else - SCM_WTA_DISPATCH_2 (g_scm_round_remainder, x, y, SCM_ARG2, - s_scm_round_remainder); + return scm_wta_dispatch_2 (g_scm_round_remainder, x, y, SCM_ARG2, + s_scm_round_remainder); } else if (SCM_FRACTIONP (x)) { @@ -3557,12 +3556,12 @@ SCM_PRIMITIVE_GENERIC (scm_round_remainder, "round-remainder", 2, 0, 0, else if (SCM_I_INUMP (y) || SCM_BIGP (y) || SCM_FRACTIONP (y)) return scm_i_exact_rational_round_remainder (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_round_remainder, x, y, SCM_ARG2, - s_scm_round_remainder); + return scm_wta_dispatch_2 (g_scm_round_remainder, x, y, SCM_ARG2, + s_scm_round_remainder); } else - SCM_WTA_DISPATCH_2 (g_scm_round_remainder, x, y, SCM_ARG1, - s_scm_round_remainder); + return scm_wta_dispatch_2 (g_scm_round_remainder, x, y, SCM_ARG1, + s_scm_round_remainder); } #undef FUNC_NAME @@ -3946,7 +3945,7 @@ scm_gcd (SCM x, SCM y) goto big_inum; } else - SCM_WTA_DISPATCH_2 (g_gcd, x, y, SCM_ARG2, s_gcd); + return scm_wta_dispatch_2 (g_gcd, x, y, SCM_ARG2, s_gcd); } else if (SCM_BIGP (x)) { @@ -3976,10 +3975,10 @@ scm_gcd (SCM x, SCM y) return scm_i_normbig (result); } else - SCM_WTA_DISPATCH_2 (g_gcd, x, y, SCM_ARG2, s_gcd); + return scm_wta_dispatch_2 (g_gcd, x, y, SCM_ARG2, s_gcd); } else - SCM_WTA_DISPATCH_2 (g_gcd, x, y, SCM_ARG1, s_gcd); + return scm_wta_dispatch_2 (g_gcd, x, y, SCM_ARG1, s_gcd); } SCM_PRIMITIVE_GENERIC (scm_i_lcm, "lcm", 0, 2, 1, @@ -4010,10 +4009,11 @@ scm_lcm (SCM n1, SCM n2) n2 = SCM_I_MAKINUM (1L); } - SCM_GASSERT2 (SCM_I_INUMP (n1) || SCM_BIGP (n1), - g_lcm, n1, n2, SCM_ARG1, s_lcm); - SCM_GASSERT2 (SCM_I_INUMP (n2) || SCM_BIGP (n2), - g_lcm, n1, n2, SCM_ARGn, s_lcm); + if (SCM_UNLIKELY (!(SCM_I_INUMP (n1) || SCM_BIGP (n1)))) + return scm_wta_dispatch_2 (g_lcm, n1, n2, SCM_ARG1, s_lcm); + + if (SCM_UNLIKELY (!(SCM_I_INUMP (n2) || SCM_BIGP (n2)))) + return scm_wta_dispatch_2 (g_lcm, n1, n2, SCM_ARG2, s_lcm); if (SCM_I_INUMP (n1)) { @@ -5143,12 +5143,6 @@ idbl2str (double f, char *a, int radix) exp++; } zero: -#ifdef ENGNOT - /* adding 9999 makes this equivalent to abs(x) % 3 */ - dpt = (exp + 9999) % 3; - exp -= dpt++; - efmt = 1; -#else efmt = (exp < -3) || (exp > wp + 2); if (!efmt) { @@ -5165,7 +5159,6 @@ idbl2str (double f, char *a, int radix) } else dpt = 1; -#endif do { @@ -5187,7 +5180,6 @@ idbl2str (double f, char *a, int radix) if (dpt > 0) { -#ifndef ENGNOT if ((dpt > 4) && (exp > 6)) { d = (a[0] == '-' ? 2 : 1); @@ -5197,7 +5189,6 @@ idbl2str (double f, char *a, int radix) efmt = 1; } else -#endif { while (--dpt) a[ch++] = '0'; @@ -5359,7 +5350,7 @@ int scm_print_real (SCM sexp, SCM port, scm_print_state *pstate SCM_UNUSED) { char num_buf[FLOBUFLEN]; - scm_lfwrite (num_buf, iflo2str (sexp, num_buf, 10), port); + scm_lfwrite_unlocked (num_buf, iflo2str (sexp, num_buf, 10), port); return !0; } @@ -5367,7 +5358,7 @@ void scm_i_print_double (double val, SCM port) { char num_buf[FLOBUFLEN]; - scm_lfwrite (num_buf, idbl2str (val, num_buf, 10), port); + scm_lfwrite_unlocked (num_buf, idbl2str (val, num_buf, 10), port); } int @@ -5375,7 +5366,7 @@ scm_print_complex (SCM sexp, SCM port, scm_print_state *pstate SCM_UNUSED) { char num_buf[FLOBUFLEN]; - scm_lfwrite (num_buf, iflo2str (sexp, num_buf, 10), port); + scm_lfwrite_unlocked (num_buf, iflo2str (sexp, num_buf, 10), port); return !0; } @@ -5383,7 +5374,7 @@ void scm_i_print_complex (double real, double imag, SCM port) { char num_buf[FLOBUFLEN]; - scm_lfwrite (num_buf, icmplx2str (real, imag, num_buf, 10), port); + scm_lfwrite_unlocked (num_buf, icmplx2str (real, imag, num_buf, 10), port); } int @@ -5404,7 +5395,7 @@ scm_bigprint (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED) void (*freefunc) (void *, size_t); mp_get_memory_functions (NULL, NULL, &freefunc); scm_remember_upto_here_1 (exp); - scm_lfwrite (str, len, port); + scm_lfwrite_unlocked (str, len, port); freefunc (str, len + 1); return !0; } @@ -6241,7 +6232,8 @@ scm_num_eq_p (SCM x, SCM y) else if (SCM_FRACTIONP (y)) return SCM_BOOL_F; else - SCM_WTA_DISPATCH_2 (g_scm_i_num_eq_p, x, y, SCM_ARGn, s_scm_i_num_eq_p); + return scm_wta_dispatch_2 (g_scm_i_num_eq_p, x, y, SCM_ARGn, + s_scm_i_num_eq_p); } else if (SCM_BIGP (x)) { @@ -6276,7 +6268,8 @@ scm_num_eq_p (SCM x, SCM y) else if (SCM_FRACTIONP (y)) return SCM_BOOL_F; else - SCM_WTA_DISPATCH_2 (g_scm_i_num_eq_p, x, y, SCM_ARGn, s_scm_i_num_eq_p); + return scm_wta_dispatch_2 (g_scm_i_num_eq_p, x, y, SCM_ARGn, + s_scm_i_num_eq_p); } else if (SCM_REALP (x)) { @@ -6314,7 +6307,8 @@ scm_num_eq_p (SCM x, SCM y) goto again; } else - SCM_WTA_DISPATCH_2 (g_scm_i_num_eq_p, x, y, SCM_ARGn, s_scm_i_num_eq_p); + return scm_wta_dispatch_2 (g_scm_i_num_eq_p, x, y, SCM_ARGn, + s_scm_i_num_eq_p); } else if (SCM_COMPLEXP (x)) { @@ -6352,7 +6346,8 @@ scm_num_eq_p (SCM x, SCM y) goto again; } else - SCM_WTA_DISPATCH_2 (g_scm_i_num_eq_p, x, y, SCM_ARGn, s_scm_i_num_eq_p); + return scm_wta_dispatch_2 (g_scm_i_num_eq_p, x, y, SCM_ARGn, + s_scm_i_num_eq_p); } else if (SCM_FRACTIONP (x)) { @@ -6386,10 +6381,12 @@ scm_num_eq_p (SCM x, SCM y) else if (SCM_FRACTIONP (y)) return scm_i_fraction_equalp (x, y); else - SCM_WTA_DISPATCH_2 (g_scm_i_num_eq_p, x, y, SCM_ARGn, s_scm_i_num_eq_p); + return scm_wta_dispatch_2 (g_scm_i_num_eq_p, x, y, SCM_ARGn, + s_scm_i_num_eq_p); } else - SCM_WTA_DISPATCH_2 (g_scm_i_num_eq_p, x, y, SCM_ARG1, s_scm_i_num_eq_p); + return scm_wta_dispatch_2 (g_scm_i_num_eq_p, x, y, SCM_ARG1, + s_scm_i_num_eq_p); } @@ -6448,7 +6445,8 @@ scm_less_p (SCM x, SCM y) goto again; } else - SCM_WTA_DISPATCH_2 (g_scm_i_num_less_p, x, y, SCM_ARGn, s_scm_i_num_less_p); + return scm_wta_dispatch_2 (g_scm_i_num_less_p, x, y, SCM_ARGn, + s_scm_i_num_less_p); } else if (SCM_BIGP (x)) { @@ -6476,7 +6474,8 @@ scm_less_p (SCM x, SCM y) else if (SCM_FRACTIONP (y)) goto int_frac; else - SCM_WTA_DISPATCH_2 (g_scm_i_num_less_p, x, y, SCM_ARGn, s_scm_i_num_less_p); + return scm_wta_dispatch_2 (g_scm_i_num_less_p, x, y, SCM_ARGn, + s_scm_i_num_less_p); } else if (SCM_REALP (x)) { @@ -6504,7 +6503,8 @@ scm_less_p (SCM x, SCM y) goto again; } else - SCM_WTA_DISPATCH_2 (g_scm_i_num_less_p, x, y, SCM_ARGn, s_scm_i_num_less_p); + return scm_wta_dispatch_2 (g_scm_i_num_less_p, x, y, SCM_ARGn, + s_scm_i_num_less_p); } else if (SCM_FRACTIONP (x)) { @@ -6537,10 +6537,12 @@ scm_less_p (SCM x, SCM y) goto again; } else - SCM_WTA_DISPATCH_2 (g_scm_i_num_less_p, x, y, SCM_ARGn, s_scm_i_num_less_p); + return scm_wta_dispatch_2 (g_scm_i_num_less_p, x, y, SCM_ARGn, + s_scm_i_num_less_p); } else - SCM_WTA_DISPATCH_2 (g_scm_i_num_less_p, x, y, SCM_ARG1, s_scm_i_num_less_p); + return scm_wta_dispatch_2 (g_scm_i_num_less_p, x, y, SCM_ARG1, + s_scm_i_num_less_p); } @@ -6569,9 +6571,9 @@ SCM scm_gr_p (SCM x, SCM y) { if (!SCM_NUMBERP (x)) - SCM_WTA_DISPATCH_2 (g_scm_i_num_gr_p, x, y, SCM_ARG1, FUNC_NAME); + return scm_wta_dispatch_2 (g_scm_i_num_gr_p, x, y, SCM_ARG1, FUNC_NAME); else if (!SCM_NUMBERP (y)) - SCM_WTA_DISPATCH_2 (g_scm_i_num_gr_p, x, y, SCM_ARG2, FUNC_NAME); + return scm_wta_dispatch_2 (g_scm_i_num_gr_p, x, y, SCM_ARG2, FUNC_NAME); else return scm_less_p (y, x); } @@ -6603,9 +6605,9 @@ SCM scm_leq_p (SCM x, SCM y) { if (!SCM_NUMBERP (x)) - SCM_WTA_DISPATCH_2 (g_scm_i_num_leq_p, x, y, SCM_ARG1, FUNC_NAME); + return scm_wta_dispatch_2 (g_scm_i_num_leq_p, x, y, SCM_ARG1, FUNC_NAME); else if (!SCM_NUMBERP (y)) - SCM_WTA_DISPATCH_2 (g_scm_i_num_leq_p, x, y, SCM_ARG2, FUNC_NAME); + return scm_wta_dispatch_2 (g_scm_i_num_leq_p, x, y, SCM_ARG2, FUNC_NAME); else if (scm_is_true (scm_nan_p (x)) || scm_is_true (scm_nan_p (y))) return SCM_BOOL_F; else @@ -6639,9 +6641,9 @@ SCM scm_geq_p (SCM x, SCM y) { if (!SCM_NUMBERP (x)) - SCM_WTA_DISPATCH_2 (g_scm_i_num_geq_p, x, y, SCM_ARG1, FUNC_NAME); + return scm_wta_dispatch_2 (g_scm_i_num_geq_p, x, y, SCM_ARG1, FUNC_NAME); else if (!SCM_NUMBERP (y)) - SCM_WTA_DISPATCH_2 (g_scm_i_num_geq_p, x, y, SCM_ARG2, FUNC_NAME); + return scm_wta_dispatch_2 (g_scm_i_num_geq_p, x, y, SCM_ARG2, FUNC_NAME); else if (scm_is_true (scm_nan_p (x)) || scm_is_true (scm_nan_p (y))) return SCM_BOOL_F; else @@ -6668,7 +6670,7 @@ SCM_PRIMITIVE_GENERIC (scm_zero_p, "zero?", 1, 0, 0, else if (SCM_FRACTIONP (z)) return SCM_BOOL_F; else - SCM_WTA_DISPATCH_1 (g_scm_zero_p, z, SCM_ARG1, s_scm_zero_p); + return scm_wta_dispatch_1 (g_scm_zero_p, z, SCM_ARG1, s_scm_zero_p); } #undef FUNC_NAME @@ -6692,7 +6694,7 @@ SCM_PRIMITIVE_GENERIC (scm_positive_p, "positive?", 1, 0, 0, else if (SCM_FRACTIONP (x)) return scm_positive_p (SCM_FRACTION_NUMERATOR (x)); else - SCM_WTA_DISPATCH_1 (g_scm_positive_p, x, SCM_ARG1, s_scm_positive_p); + return scm_wta_dispatch_1 (g_scm_positive_p, x, SCM_ARG1, s_scm_positive_p); } #undef FUNC_NAME @@ -6716,7 +6718,7 @@ SCM_PRIMITIVE_GENERIC (scm_negative_p, "negative?", 1, 0, 0, else if (SCM_FRACTIONP (x)) return scm_negative_p (SCM_FRACTION_NUMERATOR (x)); else - SCM_WTA_DISPATCH_1 (g_scm_negative_p, x, SCM_ARG1, s_scm_negative_p); + return scm_wta_dispatch_1 (g_scm_negative_p, x, SCM_ARG1, s_scm_negative_p); } #undef FUNC_NAME @@ -6750,11 +6752,11 @@ scm_max (SCM x, SCM y) if (SCM_UNBNDP (y)) { if (SCM_UNBNDP (x)) - SCM_WTA_DISPATCH_0 (g_max, s_max); + return scm_wta_dispatch_0 (g_max, s_max); else if (SCM_I_INUMP(x) || SCM_BIGP(x) || SCM_REALP(x) || SCM_FRACTIONP(x)) return x; else - SCM_WTA_DISPATCH_1 (g_max, x, SCM_ARG1, s_max); + return scm_wta_dispatch_1 (g_max, x, SCM_ARG1, s_max); } if (SCM_I_INUMP (x)) @@ -6793,7 +6795,7 @@ scm_max (SCM x, SCM y) return (scm_is_false (scm_less_p (x, y)) ? x : y); } else - SCM_WTA_DISPATCH_2 (g_max, x, y, SCM_ARGn, s_max); + return scm_wta_dispatch_2 (g_max, x, y, SCM_ARGn, s_max); } else if (SCM_BIGP (x)) { @@ -6823,7 +6825,7 @@ scm_max (SCM x, SCM y) goto use_less; } else - SCM_WTA_DISPATCH_2 (g_max, x, y, SCM_ARGn, s_max); + return scm_wta_dispatch_2 (g_max, x, y, SCM_ARGn, s_max); } else if (SCM_REALP (x)) { @@ -6878,7 +6880,7 @@ scm_max (SCM x, SCM y) return (xx < yy) ? scm_from_double (yy) : x; } else - SCM_WTA_DISPATCH_2 (g_max, x, y, SCM_ARGn, s_max); + return scm_wta_dispatch_2 (g_max, x, y, SCM_ARGn, s_max); } else if (SCM_FRACTIONP (x)) { @@ -6901,10 +6903,10 @@ scm_max (SCM x, SCM y) goto use_less; } else - SCM_WTA_DISPATCH_2 (g_max, x, y, SCM_ARGn, s_max); + return scm_wta_dispatch_2 (g_max, x, y, SCM_ARGn, s_max); } else - SCM_WTA_DISPATCH_2 (g_max, x, y, SCM_ARG1, s_max); + return scm_wta_dispatch_2 (g_max, x, y, SCM_ARG1, s_max); } @@ -6931,11 +6933,11 @@ scm_min (SCM x, SCM y) if (SCM_UNBNDP (y)) { if (SCM_UNBNDP (x)) - SCM_WTA_DISPATCH_0 (g_min, s_min); + return scm_wta_dispatch_0 (g_min, s_min); else if (SCM_I_INUMP(x) || SCM_BIGP(x) || SCM_REALP(x) || SCM_FRACTIONP(x)) return x; else - SCM_WTA_DISPATCH_1 (g_min, x, SCM_ARG1, s_min); + return scm_wta_dispatch_1 (g_min, x, SCM_ARG1, s_min); } if (SCM_I_INUMP (x)) @@ -6964,7 +6966,7 @@ scm_min (SCM x, SCM y) return (scm_is_false (scm_less_p (x, y)) ? y : x); } else - SCM_WTA_DISPATCH_2 (g_min, x, y, SCM_ARGn, s_min); + return scm_wta_dispatch_2 (g_min, x, y, SCM_ARGn, s_min); } else if (SCM_BIGP (x)) { @@ -6994,7 +6996,7 @@ scm_min (SCM x, SCM y) goto use_less; } else - SCM_WTA_DISPATCH_2 (g_min, x, y, SCM_ARGn, s_min); + return scm_wta_dispatch_2 (g_min, x, y, SCM_ARGn, s_min); } else if (SCM_REALP (x)) { @@ -7038,7 +7040,7 @@ scm_min (SCM x, SCM y) return (yy < xx) ? scm_from_double (yy) : x; } else - SCM_WTA_DISPATCH_2 (g_min, x, y, SCM_ARGn, s_min); + return scm_wta_dispatch_2 (g_min, x, y, SCM_ARGn, s_min); } else if (SCM_FRACTIONP (x)) { @@ -7061,10 +7063,10 @@ scm_min (SCM x, SCM y) goto use_less; } else - SCM_WTA_DISPATCH_2 (g_min, x, y, SCM_ARGn, s_min); + return scm_wta_dispatch_2 (g_min, x, y, SCM_ARGn, s_min); } else - SCM_WTA_DISPATCH_2 (g_min, x, y, SCM_ARG1, s_min); + return scm_wta_dispatch_2 (g_min, x, y, SCM_ARG1, s_min); } @@ -7093,7 +7095,7 @@ scm_sum (SCM x, SCM y) { if (SCM_NUMBERP (x)) return x; if (SCM_UNBNDP (x)) return SCM_INUM0; - SCM_WTA_DISPATCH_1 (g_sum, x, SCM_ARG1, s_sum); + return scm_wta_dispatch_1 (g_sum, x, SCM_ARG1, s_sum); } if (SCM_LIKELY (SCM_I_INUMP (x))) @@ -7126,7 +7128,7 @@ scm_sum (SCM x, SCM y) scm_product (x, SCM_FRACTION_DENOMINATOR (y))), SCM_FRACTION_DENOMINATOR (y)); else - SCM_WTA_DISPATCH_2 (g_sum, x, y, SCM_ARGn, s_sum); + return scm_wta_dispatch_2 (g_sum, x, y, SCM_ARGn, s_sum); } else if (SCM_BIGP (x)) { if (SCM_I_INUMP (y)) @@ -7191,7 +7193,7 @@ scm_sum (SCM x, SCM y) scm_product (x, SCM_FRACTION_DENOMINATOR (y))), SCM_FRACTION_DENOMINATOR (y)); else - SCM_WTA_DISPATCH_2 (g_sum, x, y, SCM_ARGn, s_sum); + return scm_wta_dispatch_2 (g_sum, x, y, SCM_ARGn, s_sum); } else if (SCM_REALP (x)) { @@ -7211,7 +7213,7 @@ scm_sum (SCM x, SCM y) else if (SCM_FRACTIONP (y)) return scm_from_double (SCM_REAL_VALUE (x) + scm_i_fraction2double (y)); else - SCM_WTA_DISPATCH_2 (g_sum, x, y, SCM_ARGn, s_sum); + return scm_wta_dispatch_2 (g_sum, x, y, SCM_ARGn, s_sum); } else if (SCM_COMPLEXP (x)) { @@ -7235,7 +7237,7 @@ scm_sum (SCM x, SCM y) return scm_c_make_rectangular (SCM_COMPLEX_REAL (x) + scm_i_fraction2double (y), SCM_COMPLEX_IMAG (x)); else - SCM_WTA_DISPATCH_2 (g_sum, x, y, SCM_ARGn, s_sum); + return scm_wta_dispatch_2 (g_sum, x, y, SCM_ARGn, s_sum); } else if (SCM_FRACTIONP (x)) { @@ -7258,10 +7260,10 @@ scm_sum (SCM x, SCM y) scm_product (SCM_FRACTION_NUMERATOR (y), SCM_FRACTION_DENOMINATOR (x))), scm_product (SCM_FRACTION_DENOMINATOR (x), SCM_FRACTION_DENOMINATOR (y))); else - SCM_WTA_DISPATCH_2 (g_sum, x, y, SCM_ARGn, s_sum); + return scm_wta_dispatch_2 (g_sum, x, y, SCM_ARGn, s_sum); } else - SCM_WTA_DISPATCH_2 (g_sum, x, y, SCM_ARG1, s_sum); + return scm_wta_dispatch_2 (g_sum, x, y, SCM_ARG1, s_sum); } @@ -7301,7 +7303,7 @@ scm_difference (SCM x, SCM y) if (SCM_UNLIKELY (SCM_UNBNDP (y))) { if (SCM_UNBNDP (x)) - SCM_WTA_DISPATCH_0 (g_difference, s_difference); + return scm_wta_dispatch_0 (g_difference, s_difference); else if (SCM_I_INUMP (x)) { @@ -7324,7 +7326,7 @@ scm_difference (SCM x, SCM y) return scm_i_make_ratio (scm_difference (SCM_FRACTION_NUMERATOR (x), SCM_UNDEFINED), SCM_FRACTION_DENOMINATOR (x)); else - SCM_WTA_DISPATCH_1 (g_difference, x, SCM_ARG1, s_difference); + return scm_wta_dispatch_1 (g_difference, x, SCM_ARG1, s_difference); } if (SCM_LIKELY (SCM_I_INUMP (x))) @@ -7411,7 +7413,7 @@ scm_difference (SCM x, SCM y) SCM_FRACTION_NUMERATOR (y)), SCM_FRACTION_DENOMINATOR (y)); else - SCM_WTA_DISPATCH_2 (g_difference, x, y, SCM_ARGn, s_difference); + return scm_wta_dispatch_2 (g_difference, x, y, SCM_ARGn, s_difference); } else if (SCM_BIGP (x)) { @@ -7475,7 +7477,8 @@ scm_difference (SCM x, SCM y) return scm_i_make_ratio (scm_difference (scm_product (x, SCM_FRACTION_DENOMINATOR (y)), SCM_FRACTION_NUMERATOR (y)), SCM_FRACTION_DENOMINATOR (y)); - else SCM_WTA_DISPATCH_2 (g_difference, x, y, SCM_ARGn, s_difference); + else + return scm_wta_dispatch_2 (g_difference, x, y, SCM_ARGn, s_difference); } else if (SCM_REALP (x)) { @@ -7495,7 +7498,7 @@ scm_difference (SCM x, SCM y) else if (SCM_FRACTIONP (y)) return scm_from_double (SCM_REAL_VALUE (x) - scm_i_fraction2double (y)); else - SCM_WTA_DISPATCH_2 (g_difference, x, y, SCM_ARGn, s_difference); + return scm_wta_dispatch_2 (g_difference, x, y, SCM_ARGn, s_difference); } else if (SCM_COMPLEXP (x)) { @@ -7519,7 +7522,7 @@ scm_difference (SCM x, SCM y) return scm_c_make_rectangular (SCM_COMPLEX_REAL (x) - scm_i_fraction2double (y), SCM_COMPLEX_IMAG (x)); else - SCM_WTA_DISPATCH_2 (g_difference, x, y, SCM_ARGn, s_difference); + return scm_wta_dispatch_2 (g_difference, x, y, SCM_ARGn, s_difference); } else if (SCM_FRACTIONP (x)) { @@ -7543,10 +7546,10 @@ scm_difference (SCM x, SCM y) scm_product (SCM_FRACTION_NUMERATOR (y), SCM_FRACTION_DENOMINATOR (x))), scm_product (SCM_FRACTION_DENOMINATOR (x), SCM_FRACTION_DENOMINATOR (y))); else - SCM_WTA_DISPATCH_2 (g_difference, x, y, SCM_ARGn, s_difference); + return scm_wta_dispatch_2 (g_difference, x, y, SCM_ARGn, s_difference); } else - SCM_WTA_DISPATCH_2 (g_difference, x, y, SCM_ARG1, s_difference); + return scm_wta_dispatch_2 (g_difference, x, y, SCM_ARG1, s_difference); } #undef FUNC_NAME @@ -7589,7 +7592,7 @@ scm_product (SCM x, SCM y) else if (SCM_NUMBERP (x)) return x; else - SCM_WTA_DISPATCH_1 (g_product, x, SCM_ARG1, s_product); + return scm_wta_dispatch_1 (g_product, x, SCM_ARG1, s_product); } if (SCM_LIKELY (SCM_I_INUMP (x))) @@ -7622,7 +7625,7 @@ scm_product (SCM x, SCM y) else if (SCM_NUMP (y)) return SCM_INUM0; else - SCM_WTA_DISPATCH_2 (g_product, x, y, SCM_ARGn, s_product); + return scm_wta_dispatch_2 (g_product, x, y, SCM_ARGn, s_product); break; case -1: /* @@ -7673,7 +7676,7 @@ scm_product (SCM x, SCM y) return scm_i_make_ratio (scm_product (x, SCM_FRACTION_NUMERATOR (y)), SCM_FRACTION_DENOMINATOR (y)); else - SCM_WTA_DISPATCH_2 (g_product, x, y, SCM_ARGn, s_product); + return scm_wta_dispatch_2 (g_product, x, y, SCM_ARGn, s_product); } else if (SCM_BIGP (x)) { @@ -7708,7 +7711,7 @@ scm_product (SCM x, SCM y) return scm_i_make_ratio (scm_product (x, SCM_FRACTION_NUMERATOR (y)), SCM_FRACTION_DENOMINATOR (y)); else - SCM_WTA_DISPATCH_2 (g_product, x, y, SCM_ARGn, s_product); + return scm_wta_dispatch_2 (g_product, x, y, SCM_ARGn, s_product); } else if (SCM_REALP (x)) { @@ -7731,7 +7734,7 @@ scm_product (SCM x, SCM y) else if (SCM_FRACTIONP (y)) return scm_from_double (SCM_REAL_VALUE (x) * scm_i_fraction2double (y)); else - SCM_WTA_DISPATCH_2 (g_product, x, y, SCM_ARGn, s_product); + return scm_wta_dispatch_2 (g_product, x, y, SCM_ARGn, s_product); } else if (SCM_COMPLEXP (x)) { @@ -7764,7 +7767,7 @@ scm_product (SCM x, SCM y) yy * SCM_COMPLEX_IMAG (x)); } else - SCM_WTA_DISPATCH_2 (g_product, x, y, SCM_ARGn, s_product); + return scm_wta_dispatch_2 (g_product, x, y, SCM_ARGn, s_product); } else if (SCM_FRACTIONP (x)) { @@ -7789,10 +7792,10 @@ scm_product (SCM x, SCM y) scm_product (SCM_FRACTION_DENOMINATOR (x), SCM_FRACTION_DENOMINATOR (y))); else - SCM_WTA_DISPATCH_2 (g_product, x, y, SCM_ARGn, s_product); + return scm_wta_dispatch_2 (g_product, x, y, SCM_ARGn, s_product); } else - SCM_WTA_DISPATCH_2 (g_product, x, y, SCM_ARG1, s_product); + return scm_wta_dispatch_2 (g_product, x, y, SCM_ARG1, s_product); } #if ((defined (HAVE_ISINF) && defined (HAVE_ISNAN)) \ @@ -7856,7 +7859,7 @@ do_divide (SCM x, SCM y, int inexact) if (SCM_UNLIKELY (SCM_UNBNDP (y))) { if (SCM_UNBNDP (x)) - SCM_WTA_DISPATCH_0 (g_divide, s_divide); + return scm_wta_dispatch_0 (g_divide, s_divide); else if (SCM_I_INUMP (x)) { scm_t_inum xx = SCM_I_INUM (x); @@ -7910,7 +7913,7 @@ do_divide (SCM x, SCM y, int inexact) return scm_i_make_ratio (SCM_FRACTION_DENOMINATOR (x), SCM_FRACTION_NUMERATOR (x)); else - SCM_WTA_DISPATCH_1 (g_divide, x, SCM_ARG1, s_divide); + return scm_wta_dispatch_1 (g_divide, x, SCM_ARG1, s_divide); } if (SCM_LIKELY (SCM_I_INUMP (x))) @@ -7984,7 +7987,7 @@ do_divide (SCM x, SCM y, int inexact) return scm_i_make_ratio (scm_product (x, SCM_FRACTION_DENOMINATOR (y)), SCM_FRACTION_NUMERATOR (y)); else - SCM_WTA_DISPATCH_2 (g_divide, x, y, SCM_ARGn, s_divide); + return scm_wta_dispatch_2 (g_divide, x, y, SCM_ARGn, s_divide); } else if (SCM_BIGP (x)) { @@ -8083,7 +8086,7 @@ do_divide (SCM x, SCM y, int inexact) return scm_i_make_ratio (scm_product (x, SCM_FRACTION_DENOMINATOR (y)), SCM_FRACTION_NUMERATOR (y)); else - SCM_WTA_DISPATCH_2 (g_divide, x, y, SCM_ARGn, s_divide); + return scm_wta_dispatch_2 (g_divide, x, y, SCM_ARGn, s_divide); } else if (SCM_REALP (x)) { @@ -8122,7 +8125,7 @@ do_divide (SCM x, SCM y, int inexact) else if (SCM_FRACTIONP (y)) return scm_from_double (rx / scm_i_fraction2double (y)); else - SCM_WTA_DISPATCH_2 (g_divide, x, y, SCM_ARGn, s_divide); + return scm_wta_dispatch_2 (g_divide, x, y, SCM_ARGn, s_divide); } else if (SCM_COMPLEXP (x)) { @@ -8180,7 +8183,7 @@ do_divide (SCM x, SCM y, int inexact) return scm_c_make_rectangular (rx / yy, ix / yy); } else - SCM_WTA_DISPATCH_2 (g_divide, x, y, SCM_ARGn, s_divide); + return scm_wta_dispatch_2 (g_divide, x, y, SCM_ARGn, s_divide); } else if (SCM_FRACTIONP (x)) { @@ -8219,10 +8222,10 @@ do_divide (SCM x, SCM y, int inexact) return scm_i_make_ratio (scm_product (SCM_FRACTION_NUMERATOR (x), SCM_FRACTION_DENOMINATOR (y)), scm_product (SCM_FRACTION_NUMERATOR (y), SCM_FRACTION_DENOMINATOR (x))); else - SCM_WTA_DISPATCH_2 (g_divide, x, y, SCM_ARGn, s_divide); + return scm_wta_dispatch_2 (g_divide, x, y, SCM_ARGn, s_divide); } else - SCM_WTA_DISPATCH_2 (g_divide, x, y, SCM_ARG1, s_divide); + return scm_wta_dispatch_2 (g_divide, x, y, SCM_ARG1, s_divide); } SCM @@ -8299,7 +8302,7 @@ SCM_PRIMITIVE_GENERIC (scm_truncate_number, "truncate", 1, 0, 0, return scm_truncate_quotient (SCM_FRACTION_NUMERATOR (x), SCM_FRACTION_DENOMINATOR (x)); else - SCM_WTA_DISPATCH_1 (g_scm_truncate_number, x, SCM_ARG1, + return scm_wta_dispatch_1 (g_scm_truncate_number, x, SCM_ARG1, s_scm_truncate_number); } #undef FUNC_NAME @@ -8319,8 +8322,8 @@ SCM_PRIMITIVE_GENERIC (scm_round_number, "round", 1, 0, 0, return scm_round_quotient (SCM_FRACTION_NUMERATOR (x), SCM_FRACTION_DENOMINATOR (x)); else - SCM_WTA_DISPATCH_1 (g_scm_round_number, x, SCM_ARG1, - s_scm_round_number); + return scm_wta_dispatch_1 (g_scm_round_number, x, SCM_ARG1, + s_scm_round_number); } #undef FUNC_NAME @@ -8337,7 +8340,7 @@ SCM_PRIMITIVE_GENERIC (scm_floor, "floor", 1, 0, 0, return scm_floor_quotient (SCM_FRACTION_NUMERATOR (x), SCM_FRACTION_DENOMINATOR (x)); else - SCM_WTA_DISPATCH_1 (g_scm_floor, x, 1, s_scm_floor); + return scm_wta_dispatch_1 (g_scm_floor, x, 1, s_scm_floor); } #undef FUNC_NAME @@ -8354,7 +8357,7 @@ SCM_PRIMITIVE_GENERIC (scm_ceiling, "ceiling", 1, 0, 0, return scm_ceiling_quotient (SCM_FRACTION_NUMERATOR (x), SCM_FRACTION_DENOMINATOR (x)); else - SCM_WTA_DISPATCH_1 (g_scm_ceiling, x, 1, s_scm_ceiling); + return scm_wta_dispatch_1 (g_scm_ceiling, x, 1, s_scm_ceiling); } #undef FUNC_NAME @@ -8393,9 +8396,9 @@ SCM_PRIMITIVE_GENERIC (scm_expt, "expt", 2, 0, 0, else if (scm_is_complex (x) && scm_is_complex (y)) return scm_exp (scm_product (scm_log (x), y)); else if (scm_is_complex (x)) - SCM_WTA_DISPATCH_2 (g_scm_expt, x, y, SCM_ARG2, s_scm_expt); + return scm_wta_dispatch_2 (g_scm_expt, x, y, SCM_ARG2, s_scm_expt); else - SCM_WTA_DISPATCH_2 (g_scm_expt, x, y, SCM_ARG1, s_scm_expt); + return scm_wta_dispatch_2 (g_scm_expt, x, y, SCM_ARG1, s_scm_expt); } #undef FUNC_NAME @@ -8422,7 +8425,7 @@ SCM_PRIMITIVE_GENERIC (scm_sin, "sin", 1, 0, 0, cos (x) * sinh (y)); } else - SCM_WTA_DISPATCH_1 (g_scm_sin, z, 1, s_scm_sin); + return scm_wta_dispatch_1 (g_scm_sin, z, 1, s_scm_sin); } #undef FUNC_NAME @@ -8443,7 +8446,7 @@ SCM_PRIMITIVE_GENERIC (scm_cos, "cos", 1, 0, 0, -sin (x) * sinh (y)); } else - SCM_WTA_DISPATCH_1 (g_scm_cos, z, 1, s_scm_cos); + return scm_wta_dispatch_1 (g_scm_cos, z, 1, s_scm_cos); } #undef FUNC_NAME @@ -8468,7 +8471,7 @@ SCM_PRIMITIVE_GENERIC (scm_tan, "tan", 1, 0, 0, return scm_c_make_rectangular (sin (x) / w, sinh (y) / w); } else - SCM_WTA_DISPATCH_1 (g_scm_tan, z, 1, s_scm_tan); + return scm_wta_dispatch_1 (g_scm_tan, z, 1, s_scm_tan); } #undef FUNC_NAME @@ -8489,7 +8492,7 @@ SCM_PRIMITIVE_GENERIC (scm_sinh, "sinh", 1, 0, 0, cosh (x) * sin (y)); } else - SCM_WTA_DISPATCH_1 (g_scm_sinh, z, 1, s_scm_sinh); + return scm_wta_dispatch_1 (g_scm_sinh, z, 1, s_scm_sinh); } #undef FUNC_NAME @@ -8510,7 +8513,7 @@ SCM_PRIMITIVE_GENERIC (scm_cosh, "cosh", 1, 0, 0, sinh (x) * sin (y)); } else - SCM_WTA_DISPATCH_1 (g_scm_cosh, z, 1, s_scm_cosh); + return scm_wta_dispatch_1 (g_scm_cosh, z, 1, s_scm_cosh); } #undef FUNC_NAME @@ -8535,7 +8538,7 @@ SCM_PRIMITIVE_GENERIC (scm_tanh, "tanh", 1, 0, 0, return scm_c_make_rectangular (sinh (x) / w, sin (y) / w); } else - SCM_WTA_DISPATCH_1 (g_scm_tanh, z, 1, s_scm_tanh); + return scm_wta_dispatch_1 (g_scm_tanh, z, 1, s_scm_tanh); } #undef FUNC_NAME @@ -8563,7 +8566,7 @@ SCM_PRIMITIVE_GENERIC (scm_asin, "asin", 1, 0, 0, scm_sys_asinh (scm_c_make_rectangular (-y, x))); } else - SCM_WTA_DISPATCH_1 (g_scm_asin, z, 1, s_scm_asin); + return scm_wta_dispatch_1 (g_scm_asin, z, 1, s_scm_asin); } #undef FUNC_NAME @@ -8593,7 +8596,7 @@ SCM_PRIMITIVE_GENERIC (scm_acos, "acos", 1, 0, 0, scm_sys_asinh (scm_c_make_rectangular (-y, x)))); } else - SCM_WTA_DISPATCH_1 (g_scm_acos, z, 1, s_scm_acos); + return scm_wta_dispatch_1 (g_scm_acos, z, 1, s_scm_acos); } #undef FUNC_NAME @@ -8620,17 +8623,17 @@ SCM_PRIMITIVE_GENERIC (scm_atan, "atan", 1, 1, 0, scm_c_make_rectangular (0, 2)); } else - SCM_WTA_DISPATCH_1 (g_scm_atan, z, SCM_ARG1, s_scm_atan); + return scm_wta_dispatch_1 (g_scm_atan, z, SCM_ARG1, s_scm_atan); } else if (scm_is_real (z)) { if (scm_is_real (y)) return scm_from_double (atan2 (scm_to_double (z), scm_to_double (y))); else - SCM_WTA_DISPATCH_2 (g_scm_atan, z, y, SCM_ARG2, s_scm_atan); + return scm_wta_dispatch_2 (g_scm_atan, z, y, SCM_ARG2, s_scm_atan); } else - SCM_WTA_DISPATCH_2 (g_scm_atan, z, y, SCM_ARG1, s_scm_atan); + return scm_wta_dispatch_2 (g_scm_atan, z, y, SCM_ARG1, s_scm_atan); } #undef FUNC_NAME @@ -8648,7 +8651,7 @@ SCM_PRIMITIVE_GENERIC (scm_sys_asinh, "asinh", 1, 0, 0, scm_sqrt (scm_sum (scm_product (z, z), SCM_INUM1)))); else - SCM_WTA_DISPATCH_1 (g_scm_sys_asinh, z, 1, s_scm_sys_asinh); + return scm_wta_dispatch_1 (g_scm_sys_asinh, z, 1, s_scm_sys_asinh); } #undef FUNC_NAME @@ -8666,7 +8669,7 @@ SCM_PRIMITIVE_GENERIC (scm_sys_acosh, "acosh", 1, 0, 0, scm_sqrt (scm_difference (scm_product (z, z), SCM_INUM1)))); else - SCM_WTA_DISPATCH_1 (g_scm_sys_acosh, z, 1, s_scm_sys_acosh); + return scm_wta_dispatch_1 (g_scm_sys_acosh, z, 1, s_scm_sys_acosh); } #undef FUNC_NAME @@ -8684,7 +8687,7 @@ SCM_PRIMITIVE_GENERIC (scm_sys_atanh, "atanh", 1, 0, 0, scm_difference (SCM_INUM1, z))), SCM_I_MAKINUM (2)); else - SCM_WTA_DISPATCH_1 (g_scm_sys_atanh, z, 1, s_scm_sys_atanh); + return scm_wta_dispatch_1 (g_scm_sys_atanh, z, 1, s_scm_sys_atanh); } #undef FUNC_NAME @@ -8693,7 +8696,7 @@ scm_c_make_rectangular (double re, double im) { SCM z; - z = PTR2SCM (scm_gc_malloc_pointerless (sizeof (scm_t_complex), + z = SCM_PACK_POINTER (scm_gc_malloc_pointerless (sizeof (scm_t_complex), "complex")); SCM_SET_CELL_TYPE (z, scm_tc16_complex); SCM_COMPLEX_REAL (z) = re; @@ -8785,7 +8788,7 @@ SCM_PRIMITIVE_GENERIC (scm_real_part, "real-part", 1, 0, 0, else if (SCM_I_INUMP (z) || SCM_BIGP (z) || SCM_REALP (z) || SCM_FRACTIONP (z)) return z; else - SCM_WTA_DISPATCH_1 (g_scm_real_part, z, SCM_ARG1, s_scm_real_part); + return scm_wta_dispatch_1 (g_scm_real_part, z, SCM_ARG1, s_scm_real_part); } #undef FUNC_NAME @@ -8800,7 +8803,7 @@ SCM_PRIMITIVE_GENERIC (scm_imag_part, "imag-part", 1, 0, 0, else if (SCM_I_INUMP (z) || SCM_REALP (z) || SCM_BIGP (z) || SCM_FRACTIONP (z)) return SCM_INUM0; else - SCM_WTA_DISPATCH_1 (g_scm_imag_part, z, SCM_ARG1, s_scm_imag_part); + return scm_wta_dispatch_1 (g_scm_imag_part, z, SCM_ARG1, s_scm_imag_part); } #undef FUNC_NAME @@ -8816,7 +8819,7 @@ SCM_PRIMITIVE_GENERIC (scm_numerator, "numerator", 1, 0, 0, else if (SCM_REALP (z)) return scm_exact_to_inexact (scm_numerator (scm_inexact_to_exact (z))); else - SCM_WTA_DISPATCH_1 (g_scm_numerator, z, SCM_ARG1, s_scm_numerator); + return scm_wta_dispatch_1 (g_scm_numerator, z, SCM_ARG1, s_scm_numerator); } #undef FUNC_NAME @@ -8833,7 +8836,8 @@ SCM_PRIMITIVE_GENERIC (scm_denominator, "denominator", 1, 0, 0, else if (SCM_REALP (z)) return scm_exact_to_inexact (scm_denominator (scm_inexact_to_exact (z))); else - SCM_WTA_DISPATCH_1 (g_scm_denominator, z, SCM_ARG1, s_scm_denominator); + return scm_wta_dispatch_1 (g_scm_denominator, z, SCM_ARG1, + s_scm_denominator); } #undef FUNC_NAME @@ -8875,7 +8879,8 @@ SCM_PRIMITIVE_GENERIC (scm_magnitude, "magnitude", 1, 0, 0, SCM_FRACTION_DENOMINATOR (z)); } else - SCM_WTA_DISPATCH_1 (g_scm_magnitude, z, SCM_ARG1, s_scm_magnitude); + return scm_wta_dispatch_1 (g_scm_magnitude, z, SCM_ARG1, + s_scm_magnitude); } #undef FUNC_NAME @@ -8922,7 +8927,7 @@ SCM_PRIMITIVE_GENERIC (scm_angle, "angle", 1, 0, 0, else return scm_from_double (atan2 (0.0, -1.0)); } else - SCM_WTA_DISPATCH_1 (g_scm_angle, z, SCM_ARG1, s_scm_angle); + return scm_wta_dispatch_1 (g_scm_angle, z, SCM_ARG1, s_scm_angle); } #undef FUNC_NAME @@ -8941,7 +8946,8 @@ SCM_PRIMITIVE_GENERIC (scm_exact_to_inexact, "exact->inexact", 1, 0, 0, else if (SCM_INEXACTP (z)) return z; else - SCM_WTA_DISPATCH_1 (g_scm_exact_to_inexact, z, 1, s_scm_exact_to_inexact); + return scm_wta_dispatch_1 (g_scm_exact_to_inexact, z, 1, + s_scm_exact_to_inexact); } #undef FUNC_NAME @@ -8962,7 +8968,8 @@ SCM_PRIMITIVE_GENERIC (scm_inexact_to_exact, "inexact->exact", 1, 0, 0, else if (SCM_COMPLEXP (z) && SCM_COMPLEX_IMAG (z) == 0.0) val = SCM_COMPLEX_REAL (z); else - SCM_WTA_DISPATCH_1 (g_scm_inexact_to_exact, z, 1, s_scm_inexact_to_exact); + return scm_wta_dispatch_1 (g_scm_inexact_to_exact, z, 1, + s_scm_inexact_to_exact); if (!SCM_LIKELY (DOUBLE_IS_FINITE (val))) SCM_OUT_OF_RANGE (1, z); @@ -9342,7 +9349,7 @@ scm_from_double (double val) { SCM z; - z = PTR2SCM (scm_gc_malloc_pointerless (sizeof (scm_t_double), "real")); + z = SCM_PACK_POINTER (scm_gc_malloc_pointerless (sizeof (scm_t_double), "real")); SCM_SET_CELL_TYPE (z, scm_tc16_real); SCM_REAL_VALUE (z) = val; @@ -9350,46 +9357,6 @@ scm_from_double (double val) return z; } -#if SCM_ENABLE_DEPRECATED == 1 - -float -scm_num2float (SCM num, unsigned long pos, const char *s_caller) -{ - scm_c_issue_deprecation_warning - ("`scm_num2float' is deprecated. Use scm_to_double instead."); - - if (SCM_BIGP (num)) - { - float res = mpz_get_d (SCM_I_BIG_MPZ (num)); - if (!isinf (res)) - return res; - else - scm_out_of_range (NULL, num); - } - else - return scm_to_double (num); -} - -double -scm_num2double (SCM num, unsigned long pos, const char *s_caller) -{ - scm_c_issue_deprecation_warning - ("`scm_num2double' is deprecated. Use scm_to_double instead."); - - if (SCM_BIGP (num)) - { - double res = mpz_get_d (SCM_I_BIG_MPZ (num)); - if (!isinf (res)) - return res; - else - scm_out_of_range (NULL, num); - } - else - return scm_to_double (num); -} - -#endif - int scm_is_complex (SCM val) { @@ -9539,7 +9506,7 @@ SCM_PRIMITIVE_GENERIC (scm_log, "log", 1, 0, 0, return log_of_fraction (SCM_FRACTION_NUMERATOR (z), SCM_FRACTION_DENOMINATOR (z)); else - SCM_WTA_DISPATCH_1 (g_scm_log, z, 1, s_scm_log); + return scm_wta_dispatch_1 (g_scm_log, z, 1, s_scm_log); } #undef FUNC_NAME @@ -9586,7 +9553,7 @@ SCM_PRIMITIVE_GENERIC (scm_log10, "log10", 1, 0, 0, log_of_fraction (SCM_FRACTION_NUMERATOR (z), SCM_FRACTION_DENOMINATOR (z))); else - SCM_WTA_DISPATCH_1 (g_scm_log10, z, 1, s_scm_log10); + return scm_wta_dispatch_1 (g_scm_log10, z, 1, s_scm_log10); } #undef FUNC_NAME @@ -9614,7 +9581,7 @@ SCM_PRIMITIVE_GENERIC (scm_exp, "exp", 1, 0, 0, return scm_from_double (exp (scm_to_double (z))); } else - SCM_WTA_DISPATCH_1 (g_scm_exp, z, 1, s_scm_exp); + return scm_wta_dispatch_1 (g_scm_exp, z, 1, s_scm_exp); } #undef FUNC_NAME @@ -9719,7 +9686,7 @@ SCM_PRIMITIVE_GENERIC (scm_sqrt, "sqrt", 1, 0, 0, return scm_from_double (sqrt (xx)); } else - SCM_WTA_DISPATCH_1 (g_scm_sqrt, z, 1, s_scm_sqrt); + return scm_wta_dispatch_1 (g_scm_sqrt, z, 1, s_scm_sqrt); } #undef FUNC_NAME diff --git a/libguile/numbers.h b/libguile/numbers.h index 2c8b2602e..3c43ae421 100644 --- a/libguile/numbers.h +++ b/libguile/numbers.h @@ -126,8 +126,8 @@ typedef scm_t_int32 scm_t_wchar; #define SCM_INEXACTP(x) \ (!SCM_IMP (x) && (0xfeff & SCM_CELL_TYPE (x)) == scm_tc16_real) -#define SCM_REALP(x) (!SCM_IMP (x) && SCM_TYP16 (x) == scm_tc16_real) -#define SCM_COMPLEXP(x) (!SCM_IMP (x) && SCM_TYP16 (x) == scm_tc16_complex) +#define SCM_REALP(x) (SCM_HAS_TYP16 (x, scm_tc16_real)) +#define SCM_COMPLEXP(x) (SCM_HAS_TYP16 (x, scm_tc16_complex)) #define SCM_REAL_VALUE(x) (((scm_t_double *) SCM2PTR (x))->real) #define SCM_COMPLEX_REAL(x) (((scm_t_complex *) SCM2PTR (x))->real) @@ -135,13 +135,12 @@ typedef scm_t_int32 scm_t_wchar; /* Each bignum is just an mpz_t stored in a double cell starting at word 1. */ #define SCM_I_BIG_MPZ(x) (*((mpz_t *) (SCM_CELL_OBJECT_LOC((x),1)))) -#define SCM_BIGP(x) (!SCM_IMP (x) && SCM_TYP16 (x) == scm_tc16_big) +#define SCM_BIGP(x) (SCM_HAS_TYP16 (x, scm_tc16_big)) #define SCM_NUMBERP(x) (SCM_I_INUMP(x) || SCM_NUMP(x)) -#define SCM_NUMP(x) (!SCM_IMP(x) \ - && ((0x00ff & SCM_CELL_TYPE (x)) == scm_tc7_number)) +#define SCM_NUMP(x) (SCM_HAS_TYP7 (x, scm_tc7_number)) -#define SCM_FRACTIONP(x) (!SCM_IMP (x) && SCM_TYP16 (x) == scm_tc16_fraction) +#define SCM_FRACTIONP(x) (SCM_HAS_TYP16 (x, scm_tc16_fraction)) #define SCM_FRACTION_NUMERATOR(x) (SCM_CELL_OBJECT_1 (x)) #define SCM_FRACTION_DENOMINATOR(x) (SCM_CELL_OBJECT_2 (x)) diff --git a/libguile/objcodes.c b/libguile/objcodes.c index 004dd6118..c2932334b 100644 --- a/libguile/objcodes.c +++ b/libguile/objcodes.c @@ -1,4 +1,4 @@ -/* Copyright (C) 2001, 2009, 2010, 2011 Free Software Foundation, Inc. +/* Copyright (C) 2001, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -37,202 +37,584 @@ #include <full-read.h> #include "_scm.h" +#include "elf.h" #include "programs.h" #include "objcodes.h" -/* SCM_OBJCODE_COOKIE, defined in _scm.h, is a magic value prepended - to objcode on disk but not in memory. +/* Before, we used __BYTE_ORDER, but that is not defined on all + systems. So punt and use automake, PDP endianness be damned. */ +#define SCM_BYTE_ORDER_BE 4321 +#define SCM_BYTE_ORDER_LE 1234 - The length of the header must be a multiple of 8 bytes. */ -verify (((sizeof (SCM_OBJCODE_COOKIE) - 1) & 7) == 0); +/* Byte order of the build machine. */ +#ifdef WORDS_BIGENDIAN +#define SCM_BYTE_ORDER SCM_BYTE_ORDER_BE +#else +#define SCM_BYTE_ORDER SCM_BYTE_ORDER_LE +#endif -/* Endianness and word size of the compilation target. */ -static SCM target_endianness_var = SCM_BOOL_F; -static SCM target_word_size_var = SCM_BOOL_F; +/* This file contains the loader for Guile's on-disk format: ELF with + some custom tags in the dynamic segment. */ + +#if SIZEOF_SCM_T_BITS == 4 +#define Elf_Half Elf32_Half +#define Elf_Word Elf32_Word +#define Elf_Ehdr Elf32_Ehdr +#define ELFCLASS ELFCLASS32 +#define Elf_Phdr Elf32_Phdr +#define Elf_Dyn Elf32_Dyn +#elif SIZEOF_SCM_T_BITS == 8 +#define Elf_Half Elf64_Half +#define Elf_Word Elf64_Word +#define Elf_Ehdr Elf64_Ehdr +#define ELFCLASS ELFCLASS64 +#define Elf_Phdr Elf64_Phdr +#define Elf_Dyn Elf64_Dyn +#else +#error +#endif - -/* - * Objcode type - */ +#define DT_LOGUILE 0x37146000 /* Start of Guile-specific */ +#define DT_GUILE_GC_ROOT 0x37146000 /* Offset of GC roots */ +#define DT_GUILE_GC_ROOT_SZ 0x37146001 /* Size in machine words of GC + roots */ +#define DT_GUILE_ENTRY 0x37146002 /* Address of entry thunk */ +#define DT_GUILE_RTL_VERSION 0x37146003 /* Bytecode version */ +#define DT_HIGUILE 0x37146fff /* End of Guile-specific */ -/* Endianness of the build machine. */ #ifdef WORDS_BIGENDIAN -# define NATIVE_ENDIANNESS 'B' +#define ELFDATA ELFDATA2MSB #else -# define NATIVE_ENDIANNESS 'L' +#define ELFDATA ELFDATA2LSB #endif -/* Return the endianness of the compilation target. */ -static char -target_endianness (void) +enum bytecode_kind + { + BYTECODE_KIND_NONE, + BYTECODE_KIND_GUILE_2_0 + }; + +static SCM +pointer_to_procedure (enum bytecode_kind bytecode_kind, char *ptr) { - if (scm_is_true (target_endianness_var)) - return scm_is_eq (scm_call_0 (scm_variable_ref (target_endianness_var)), - scm_endianness_big) ? 'B' : 'L'; - else - return NATIVE_ENDIANNESS; + switch (bytecode_kind) + { + case BYTECODE_KIND_GUILE_2_0: + { + SCM objcode; + scm_t_bits tag = SCM_MAKE_OBJCODE_TAG (SCM_OBJCODE_TYPE_MMAP, 0); + + objcode = scm_double_cell (tag, (scm_t_bits) ptr, SCM_BOOL_F_BITS, 0); + return scm_make_program (objcode, SCM_BOOL_F, SCM_UNDEFINED); + } + case BYTECODE_KIND_NONE: + default: + abort (); + } } -/* Return the word size in bytes of the compilation target. */ -static size_t -target_word_size (void) +static const char* +check_elf_header (const Elf_Ehdr *header) { - if (scm_is_true (target_word_size_var)) - return scm_to_size_t (scm_call_0 - (scm_variable_ref (target_word_size_var))); - else - return sizeof (void *); + if (!(header->e_ident[EI_MAG0] == ELFMAG0 + && header->e_ident[EI_MAG1] == ELFMAG1 + && header->e_ident[EI_MAG2] == ELFMAG2 + && header->e_ident[EI_MAG3] == ELFMAG3)) + return "not an ELF file"; + + if (header->e_ident[EI_CLASS] != ELFCLASS) + return "ELF file does not have native word size"; + + if (header->e_ident[EI_DATA] != ELFDATA) + return "ELF file does not have native byte order"; + + if (header->e_ident[EI_VERSION] != EV_CURRENT) + return "bad ELF version"; + + if (header->e_ident[EI_OSABI] != ELFOSABI_STANDALONE) + return "unexpected OS ABI"; + + if (header->e_ident[EI_ABIVERSION] != 0) + return "unexpected ABI version"; + + if (header->e_type != ET_DYN) + return "unexpected ELF type"; + + if (header->e_machine != EM_NONE) + return "unexpected machine"; + + if (header->e_version != EV_CURRENT) + return "unexpected ELF version"; + + if (header->e_ehsize != sizeof *header) + return "unexpected header size"; + + if (header->e_phentsize != sizeof (Elf_Phdr)) + return "unexpected program header size"; + + return NULL; } -/* Convert X, which is in byte order ENDIANNESS, to its native - representation. */ -static inline uint32_t -to_native_order (uint32_t x, char endianness) +static int +segment_flags_to_prot (Elf_Word flags) { - if (endianness == NATIVE_ENDIANNESS) - return x; - else - return bswap_32 (x); + int prot = 0; + + if (flags & PF_X) + prot |= PROT_EXEC; + if (flags & PF_W) + prot |= PROT_WRITE; + if (flags & PF_R) + prot |= PROT_READ; + + return prot; } -static void -verify_cookie (char *cookie, struct stat *st, int map_fd, void *map_addr) -#define FUNC_NAME "make_objcode_from_file" +static int +map_segments (int fd, char **base, + const Elf_Phdr *from, const Elf_Phdr *to) { - /* The cookie ends with a version of the form M.N, where M is the - major version and N is the minor version. For this Guile to be - able to load an objcode, M must be SCM_OBJCODE_MAJOR_VERSION, and N - must be less than or equal to SCM_OBJCODE_MINOR_VERSION. Since N - is the last character, we do a strict comparison on all but the - last, then a <= on the last one. */ - if (memcmp (cookie, SCM_OBJCODE_COOKIE, strlen (SCM_OBJCODE_COOKIE) - 1)) + int prot = segment_flags_to_prot (from->p_flags); + char *ret; + + ret = mmap (*base + from->p_vaddr, + to->p_offset + to->p_filesz - from->p_offset, + prot, MAP_PRIVATE, fd, from->p_offset); + + if (ret == (char *) -1) + return 1; + + if (!*base) + *base = ret; + + return 0; +} + +static int +mprotect_segments (char *base, const Elf_Phdr *from, const Elf_Phdr *to) +{ + return mprotect (base + from->p_vaddr, + to->p_vaddr + to->p_memsz - from->p_vaddr, + segment_flags_to_prot (from->p_flags)); +} + +static char* +process_dynamic_segment (char *base, Elf_Phdr *dyn_phdr, + SCM *init_out, SCM *entry_out) +{ + char *dyn_addr = base + dyn_phdr->p_vaddr; + Elf_Dyn *dyn = (Elf_Dyn *) dyn_addr; + size_t i, dyn_size = dyn_phdr->p_memsz / sizeof (Elf_Dyn); + char *init = 0, *gc_root = 0, *entry = 0; + scm_t_ptrdiff gc_root_size = 0; + enum bytecode_kind bytecode_kind = BYTECODE_KIND_NONE; + + for (i = 0; i < dyn_size; i++) { - SCM args = scm_list_1 (scm_from_latin1_stringn - (cookie, strlen (SCM_OBJCODE_COOKIE))); - if (map_fd >= 0) + if (dyn[i].d_tag == DT_NULL) + break; + + switch (dyn[i].d_tag) { - (void) close (map_fd); -#ifdef HAVE_SYS_MMAN_H - (void) munmap (map_addr, st->st_size); -#endif + case DT_INIT: + if (init) + return "duplicate DT_INIT"; + init = base + dyn[i].d_un.d_val; + break; + case DT_GUILE_GC_ROOT: + if (gc_root) + return "duplicate DT_GUILE_GC_ROOT"; + gc_root = base + dyn[i].d_un.d_val; + break; + case DT_GUILE_GC_ROOT_SZ: + if (gc_root_size) + return "duplicate DT_GUILE_GC_ROOT_SZ"; + gc_root_size = dyn[i].d_un.d_val; + break; + case DT_GUILE_ENTRY: + if (entry) + return "duplicate DT_GUILE_ENTRY"; + entry = base + dyn[i].d_un.d_val; + break; + case DT_GUILE_RTL_VERSION: + if (bytecode_kind != BYTECODE_KIND_NONE) + return "duplicate DT_GUILE_RTL_VERSION"; + { + scm_t_uint16 major = dyn[i].d_un.d_val >> 16; + scm_t_uint16 minor = dyn[i].d_un.d_val & 0xffff; + if (major != 0x0200) + return "incompatible bytecode kind"; + if (minor > SCM_OBJCODE_MINOR_VERSION) + return "incompatible bytecode version"; + bytecode_kind = BYTECODE_KIND_GUILE_2_0; + break; + } } - scm_misc_error (FUNC_NAME, "bad header on object file: ~s", args); } - { - char minor_version = cookie[strlen (SCM_OBJCODE_COOKIE) - 1]; + if (bytecode_kind != BYTECODE_KIND_GUILE_2_0) + return "missing DT_GUILE_RTL_VERSION"; + if (init) + return "unexpected DT_INIT"; + if ((scm_t_uintptr) entry % 8) + return "unaligned DT_GUILE_ENTRY"; + if (!entry) + return "missing DT_GUILE_ENTRY"; + + if (gc_root) + GC_add_roots (gc_root, gc_root + gc_root_size); + + *init_out = SCM_BOOL_F; + *entry_out = pointer_to_procedure (bytecode_kind, entry); + return NULL; +} + +#define ABORT(msg) do { err_msg = msg; goto cleanup; } while (0) - if (minor_version > SCM_OBJCODE_MINOR_VERSION_STRING[0]) - { - if (map_fd >= 0) - { - (void) close (map_fd); #ifdef HAVE_SYS_MMAN_H - (void) munmap (map_addr, st->st_size); -#endif - } +static SCM +load_thunk_from_fd_using_mmap (int fd) +#define FUNC_NAME "load-thunk-from-disk" +{ + Elf_Ehdr header; + Elf_Phdr *ph; + const char *err_msg = 0; + char *base = 0; + size_t n; + int i; + int start_segment = -1; + int prev_segment = -1; + int dynamic_segment = -1; + SCM init = SCM_BOOL_F, entry = SCM_BOOL_F; + + if (full_read (fd, &header, sizeof header) != sizeof header) + ABORT ("object file too small"); + + if ((err_msg = check_elf_header (&header))) + goto cleanup; + + if (lseek (fd, header.e_phoff, SEEK_SET) == (off_t) -1) + goto cleanup; + + n = header.e_phnum; + ph = scm_gc_malloc_pointerless (n * sizeof (Elf_Phdr), "segment headers"); + + if (full_read (fd, ph, n * sizeof (Elf_Phdr)) != n * sizeof (Elf_Phdr)) + ABORT ("failed to read program headers"); + + for (i = 0; i < n; i++) + { + if (!ph[i].p_memsz) + continue; - scm_misc_error (FUNC_NAME, "objcode minor version too new (~a > ~a)", - scm_list_2 (scm_from_latin1_stringn (&minor_version, 1), - scm_from_latin1_string - (SCM_OBJCODE_MINOR_VERSION_STRING))); - } + if (ph[i].p_filesz != ph[i].p_memsz) + ABORT ("expected p_filesz == p_memsz"); + + if (!ph[i].p_flags) + ABORT ("expected nonzero segment flags"); + + if (ph[i].p_type == PT_DYNAMIC) + { + if (dynamic_segment >= 0) + ABORT ("expected only one PT_DYNAMIC segment"); + dynamic_segment = i; + } + + if (start_segment < 0) + { + if (!base && ph[i].p_vaddr) + ABORT ("first loadable vaddr is not 0"); + + start_segment = prev_segment = i; + continue; + } + + if (ph[i].p_flags == ph[start_segment].p_flags) + { + if (ph[i].p_vaddr - ph[prev_segment].p_vaddr + != ph[i].p_offset - ph[prev_segment].p_offset) + ABORT ("coalesced segments not contiguous"); + + prev_segment = i; + continue; + } + + /* Otherwise we have a new kind of segment. Map previous + segments. */ + if (map_segments (fd, &base, &ph[start_segment], &ph[prev_segment])) + goto cleanup; + + /* Open a new set of segments. */ + start_segment = prev_segment = i; + } + + /* Map last segments. */ + if (start_segment < 0) + ABORT ("no loadable segments"); + + if (map_segments (fd, &base, &ph[start_segment], &ph[prev_segment])) + goto cleanup; + + if (dynamic_segment < 0) + ABORT ("no PT_DYNAMIC segment"); + + if ((err_msg = process_dynamic_segment (base, &ph[dynamic_segment], + &init, &entry))) + goto cleanup; + + if (scm_is_true (init)) + scm_call_0 (init); + + /* Finally! Return the thunk. */ + return entry; + + /* FIXME: munmap on error? */ + cleanup: + { + int errno_save = errno; + (void) close (fd); + errno = errno_save; + if (errno) + SCM_SYSERROR; + scm_misc_error (FUNC_NAME, err_msg ? err_msg : "error loading ELF file", + SCM_EOL); } } #undef FUNC_NAME - -/* The words in an objcode SCM object are as follows: - - scm_tc7_objcode | type | flags - - the struct scm_objcode C object - - the parent of this objcode: either another objcode, a bytevector, - or, in the case of mmap types, #f - - "native code" -- not currently used. - */ +#endif /* HAVE_SYS_MMAN_H */ static SCM -make_objcode_from_file (int fd) -#define FUNC_NAME "make_objcode_from_file" +load_thunk_from_memory (char *data, size_t len) +#define FUNC_NAME "load-thunk-from-memory" { - int ret; - /* The SCM_OBJCODE_COOKIE is a string literal, and thus has an extra - trailing NUL, hence the - 1. */ - char cookie[sizeof (SCM_OBJCODE_COOKIE) - 1]; - struct stat st; + Elf_Ehdr header; + Elf_Phdr *ph; + const char *err_msg = 0; + char *base = 0; + size_t n, memsz = 0, alignment = 8; + int i; + int first_loadable = -1; + int start_segment = -1; + int prev_segment = -1; + int dynamic_segment = -1; + SCM init = SCM_BOOL_F, entry = SCM_BOOL_F; + + if (len < sizeof header) + ABORT ("object file too small"); + + memcpy (&header, data, sizeof header); + + if ((err_msg = check_elf_header (&header))) + goto cleanup; + + n = header.e_phnum; + if (len < header.e_phoff + n * sizeof (Elf_Phdr)) + goto cleanup; + ph = (Elf_Phdr*) (data + header.e_phoff); + + for (i = 0; i < n; i++) + { + if (!ph[i].p_memsz) + continue; - ret = fstat (fd, &st); - if (ret < 0) - SCM_SYSERROR; + if (ph[i].p_filesz != ph[i].p_memsz) + ABORT ("expected p_filesz == p_memsz"); - if (st.st_size <= sizeof (struct scm_objcode) + sizeof cookie) - scm_misc_error (FUNC_NAME, "object file too small (~a bytes)", - scm_list_1 (SCM_I_MAKINUM (st.st_size))); + if (!ph[i].p_flags) + ABORT ("expected nonzero segment flags"); -#ifdef HAVE_SYS_MMAN_H - { - char *addr; - struct scm_objcode *data; + if (ph[i].p_align < alignment) + { + if (ph[i].p_align % alignment) + ABORT ("expected new alignment to be multiple of old"); + alignment = ph[i].p_align; + } - addr = mmap (0, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); + if (ph[i].p_type == PT_DYNAMIC) + { + if (dynamic_segment >= 0) + ABORT ("expected only one PT_DYNAMIC segment"); + dynamic_segment = i; + } - if (addr == MAP_FAILED) - { - int errno_save = errno; - (void) close (fd); - errno = errno_save; - SCM_SYSERROR; - } - else - { - memcpy (cookie, addr, sizeof cookie); - data = (struct scm_objcode *) (addr + sizeof cookie); - } + if (first_loadable < 0) + { + if (ph[i].p_vaddr) + ABORT ("first loadable vaddr is not 0"); - verify_cookie (cookie, &st, fd, addr); + first_loadable = i; + } + if (ph[i].p_vaddr < memsz) + ABORT ("overlapping segments"); - if (data->len + data->metalen - != (st.st_size - sizeof (*data) - sizeof cookie)) - { - size_t total_len = sizeof (*data) + data->len + data->metalen; + if (ph[i].p_offset + ph[i].p_filesz > len) + ABORT ("segment beyond end of byte array"); - (void) close (fd); - (void) munmap (addr, st.st_size); + memsz = ph[i].p_vaddr + ph[i].p_memsz; + } - scm_misc_error (FUNC_NAME, "bad length header (~a, ~a)", - scm_list_2 (scm_from_size_t (st.st_size), - scm_from_size_t (total_len))); - } + if (first_loadable < 0) + ABORT ("no loadable segments"); - (void) close (fd); - return scm_permanent_object - (scm_double_cell (SCM_MAKE_OBJCODE_TAG (SCM_OBJCODE_TYPE_MMAP, 0), - (scm_t_bits)(addr + strlen (SCM_OBJCODE_COOKIE)), - SCM_BOOL_F_BITS, 0)); - } -#else + if (dynamic_segment < 0) + ABORT ("no PT_DYNAMIC segment"); + + /* Now copy segments. */ + + /* We leak this memory, as we leak the memory mappings in + load_thunk_from_fd_using_mmap. + + If the file is has an alignment of 8, use the standard malloc. + (FIXME to ensure alignment on non-GNU malloc.) Otherwise use + posix_memalign. We only use mprotect if the aligment is 4096. */ + if (alignment == 8) + { + base = malloc (memsz); + if (!base) + goto cleanup; + } + else + if ((errno = posix_memalign ((void **) &base, alignment, memsz))) + goto cleanup; + + memset (base, 0, memsz); + + for (i = 0; i < n; i++) + { + if (!ph[i].p_memsz) + continue; + + memcpy (base + ph[i].p_vaddr, + data + ph[i].p_offset, + ph[i].p_memsz); + + if (start_segment < 0) + { + start_segment = prev_segment = i; + continue; + } + + if (ph[i].p_flags == ph[start_segment].p_flags) + { + prev_segment = i; + continue; + } + + if (alignment == 4096) + if (mprotect_segments (base, &ph[start_segment], &ph[prev_segment])) + goto cleanup; + + /* Open a new set of segments. */ + start_segment = prev_segment = i; + } + + /* Mprotect the last segments. */ + if (alignment == 4096) + if (mprotect_segments (base, &ph[start_segment], &ph[prev_segment])) + goto cleanup; + + if ((err_msg = process_dynamic_segment (base, &ph[dynamic_segment], + &init, &entry))) + goto cleanup; + + if (scm_is_true (init)) + scm_call_0 (init); + + /* Finally! Return the thunk. */ + return entry; + + cleanup: { - SCM bv = scm_c_make_bytevector (st.st_size - sizeof cookie); + if (errno) + SCM_SYSERROR; + scm_misc_error (FUNC_NAME, err_msg ? err_msg : "error loading ELF file", + SCM_EOL); + } +} +#undef FUNC_NAME - if (full_read (fd, cookie, sizeof cookie) != sizeof cookie - || full_read (fd, SCM_BYTEVECTOR_CONTENTS (bv), - SCM_BYTEVECTOR_LENGTH (bv)) != SCM_BYTEVECTOR_LENGTH (bv)) - { - int errno_save = errno; - (void) close (fd); - errno = errno_save; +#ifndef HAVE_SYS_MMAN_H +static SCM +load_thunk_from_fd_using_read (int fd) +#define FUNC_NAME "load-thunk-from-disk" +{ + char *data; + size_t len; + struct stat st; + int ret; + + ret = fstat (fd, &st); + if (ret < 0) + SCM_SYSERROR; + len = st.st_size; + data = scm_gc_malloc_pointerless (len, "objcode"); + if (full_read (fd, data, len) != len) + { + int errno_save = errno; + (void) close (fd); + errno = errno_save; + if (errno) SCM_SYSERROR; - } + scm_misc_error (FUNC_NAME, "short read while loading objcode", + SCM_EOL); + } + (void) close (fd); + return load_thunk_from_memory (data, len); +} +#undef FUNC_NAME +#endif /* ! HAVE_SYS_MMAN_H */ - (void) close (fd); +SCM_DEFINE (scm_load_thunk_from_file, "load-thunk-from-file", 1, 0, 0, + (SCM filename), + "") +#define FUNC_NAME s_scm_load_thunk_from_file +{ + char *c_filename; + int fd; - verify_cookie (cookie, &st, -1, NULL); + SCM_VALIDATE_STRING (1, filename); - return scm_bytecode_to_native_objcode (bv); - } + c_filename = scm_to_locale_string (filename); + fd = open (c_filename, O_RDONLY | O_CLOEXEC); + free (c_filename); + if (fd < 0) SCM_SYSERROR; + +#ifdef HAVE_SYS_MMAN_H + return load_thunk_from_fd_using_mmap (fd); +#else + return load_thunk_from_fd_using_read (fd); #endif } #undef FUNC_NAME +SCM_DEFINE (scm_load_thunk_from_memory, "load-thunk-from-memory", 1, 0, 0, + (SCM bv), + "") +#define FUNC_NAME s_scm_load_thunk_from_memory +{ + SCM_VALIDATE_BYTEVECTOR (1, bv); + + return load_thunk_from_memory ((char *) SCM_BYTEVECTOR_CONTENTS (bv), + SCM_BYTEVECTOR_LENGTH (bv)); +} +#undef FUNC_NAME + + +/* + * Objcode type + */ + +/* Convert X, which is in byte order BYTE_ORDER, to its native + representation. */ +static inline uint32_t +to_native_order (uint32_t x, int byte_order) +{ + if (byte_order == SCM_BYTE_ORDER) + return x; + else + return bswap_32 (x); +} SCM scm_c_make_objcode_slice (SCM parent, const scm_t_uint8 *ptr) @@ -298,9 +680,10 @@ SCM_DEFINE (scm_objcode_meta, "objcode-meta", 1, 0, 0, } #undef FUNC_NAME -/* Turn BYTECODE into objcode encoded for ENDIANNESS and WORD_SIZE. */ +/* Wrap BYTECODE in objcode, interpreting its lengths according to + BYTE_ORDER. */ static SCM -bytecode_to_objcode (SCM bytecode, char endianness, size_t word_size) +bytecode_to_objcode (SCM bytecode, int byte_order) #define FUNC_NAME "bytecode->objcode" { size_t size, len, metalen; @@ -316,8 +699,8 @@ bytecode_to_objcode (SCM bytecode, char endianness, size_t word_size) SCM_ASSERT_RANGE (0, bytecode, size >= sizeof(struct scm_objcode)); data = (struct scm_objcode*)c_bytecode; - len = to_native_order (data->len, endianness); - metalen = to_native_order (data->metalen, endianness); + len = to_native_order (data->len, byte_order); + metalen = to_native_order (data->metalen, byte_order); if (len + metalen != (size - sizeof (*data))) scm_misc_error (FUNC_NAME, "bad bytevector size (~a != ~a)", @@ -331,111 +714,63 @@ bytecode_to_objcode (SCM bytecode, char endianness, size_t word_size) } #undef FUNC_NAME -SCM_DEFINE (scm_bytecode_to_objcode, "bytecode->objcode", 1, 0, 0, - (SCM bytecode), +SCM_DEFINE (scm_bytecode_to_objcode, "bytecode->objcode", 1, 1, 0, + (SCM bytecode, SCM endianness), "") #define FUNC_NAME s_scm_bytecode_to_objcode { - /* Assume we're called from Scheme, which known that to do with - `target-type'. */ - return bytecode_to_objcode (bytecode, target_endianness (), - target_word_size ()); -} -#undef FUNC_NAME - -/* Like `bytecode->objcode', but ignore the `target-type' fluid. This - is useful for native compilation that happens lazily---e.g., direct - calls to this function from libguile itself. */ -SCM -scm_bytecode_to_native_objcode (SCM bytecode) -{ - return bytecode_to_objcode (bytecode, NATIVE_ENDIANNESS, sizeof (void *)); -} - -SCM_DEFINE (scm_load_objcode, "load-objcode", 1, 0, 0, - (SCM file), - "") -#define FUNC_NAME s_scm_load_objcode -{ - int fd; - char *c_file; - - SCM_VALIDATE_STRING (1, file); - - c_file = scm_to_locale_string (file); - fd = open (c_file, O_RDONLY | O_CLOEXEC); - free (c_file); - if (fd < 0) SCM_SYSERROR; + int byte_order; + + if (SCM_UNBNDP (endianness)) + byte_order = SCM_BYTE_ORDER; + else if (scm_is_eq (endianness, scm_endianness_big)) + byte_order = SCM_BYTE_ORDER_BE; + else if (scm_is_eq (endianness, scm_endianness_little)) + byte_order = SCM_BYTE_ORDER_LE; + else + scm_wrong_type_arg (FUNC_NAME, 2, endianness); - return make_objcode_from_file (fd); + return bytecode_to_objcode (bytecode, byte_order); } #undef FUNC_NAME -SCM_DEFINE (scm_objcode_to_bytecode, "objcode->bytecode", 1, 0, 0, - (SCM objcode), +SCM_DEFINE (scm_objcode_to_bytecode, "objcode->bytecode", 1, 1, 0, + (SCM objcode, SCM endianness), "") #define FUNC_NAME s_scm_objcode_to_bytecode { - scm_t_int8 *s8vector; - scm_t_uint32 len; + scm_t_uint32 len, meta_len, total_len; + int byte_order; SCM_VALIDATE_OBJCODE (1, objcode); - len = sizeof (struct scm_objcode) + SCM_OBJCODE_TOTAL_LEN (objcode); - - s8vector = scm_gc_malloc_pointerless (len, FUNC_NAME); - memcpy (s8vector, SCM_OBJCODE_DATA (objcode), len); - - return scm_c_take_gc_bytevector (s8vector, len); -} -#undef FUNC_NAME - -SCM_DEFINE (scm_write_objcode, "write-objcode", 2, 0, 0, - (SCM objcode, SCM port), - "") -#define FUNC_NAME s_scm_write_objcode -{ - char cookie[sizeof (SCM_OBJCODE_COOKIE) - 1]; - char endianness, word_size; - size_t total_size; - - SCM_VALIDATE_OBJCODE (1, objcode); - SCM_VALIDATE_OUTPUT_PORT (2, port); - endianness = target_endianness (); - switch (target_word_size ()) - { - case 4: - word_size = '4'; - break; - case 8: - word_size = '8'; - break; - default: - abort (); - } - - memcpy (cookie, SCM_OBJCODE_COOKIE, strlen (SCM_OBJCODE_COOKIE)); - cookie[SCM_OBJCODE_ENDIANNESS_OFFSET] = endianness; - cookie[SCM_OBJCODE_WORD_SIZE_OFFSET] = word_size; + if (SCM_UNBNDP (endianness)) + byte_order = SCM_BYTE_ORDER; + else if (scm_is_eq (endianness, scm_endianness_big)) + byte_order = SCM_BYTE_ORDER_BE; + else if (scm_is_eq (endianness, scm_endianness_little)) + byte_order = SCM_BYTE_ORDER_LE; + else + scm_wrong_type_arg (FUNC_NAME, 2, endianness); - total_size = - to_native_order (SCM_OBJCODE_LEN (objcode), target_endianness ()) - + to_native_order (SCM_OBJCODE_META_LEN (objcode), target_endianness ()); + len = SCM_OBJCODE_LEN (objcode); + meta_len = SCM_OBJCODE_META_LEN (objcode); - scm_c_write (port, cookie, strlen (SCM_OBJCODE_COOKIE)); - scm_c_write (port, SCM_OBJCODE_DATA (objcode), - sizeof (struct scm_objcode) + total_size); + total_len = sizeof (struct scm_objcode); + total_len += to_native_order (len, byte_order); + total_len += to_native_order (meta_len, byte_order); - return SCM_UNSPECIFIED; + return scm_c_take_gc_bytevector ((scm_t_int8*)SCM_OBJCODE_DATA (objcode), + total_len, objcode); } #undef FUNC_NAME void scm_i_objcode_print (SCM objcode, SCM port, scm_print_state *pstate) { - scm_puts ("#<objcode ", port); + scm_puts_unlocked ("#<objcode ", port); scm_uintprint ((scm_t_bits)SCM_OBJCODE_BASE (objcode), 16, port); - scm_puts (">", port); + scm_puts_unlocked (">", port); } @@ -447,14 +782,6 @@ scm_bootstrap_objcodes (void) (scm_t_extension_init_func)scm_init_objcodes, NULL); } -/* Before, we used __BYTE_ORDER, but that is not defined on all - systems. So punt and use automake, PDP endianness be damned. */ -#ifdef WORDS_BIGENDIAN -#define SCM_BYTE_ORDER 4321 -#else -#define SCM_BYTE_ORDER 1234 -#endif - void scm_init_objcodes (void) { @@ -464,11 +791,6 @@ scm_init_objcodes (void) scm_c_define ("word-size", scm_from_size_t (sizeof(SCM))); scm_c_define ("byte-order", scm_from_uint16 (SCM_BYTE_ORDER)); - - target_endianness_var = scm_c_public_variable ("system base target", - "target-endianness"); - target_word_size_var = scm_c_public_variable ("system base target", - "target-word-size"); } /* diff --git a/libguile/objcodes.h b/libguile/objcodes.h index 0cfc8e027..6ac333fa4 100644 --- a/libguile/objcodes.h +++ b/libguile/objcodes.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2001, 2009, 2010, 2011 Free Software Foundation, Inc. +/* Copyright (C) 2001, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -40,7 +40,7 @@ struct scm_objcode #define SCM_OBJCODE_TYPE_SLICE (2) #define SCM_OBJCODE_TYPE_STATIC (3) -#define SCM_OBJCODE_P(x) (SCM_NIMP (x) && SCM_TYP7 (x) == scm_tc7_objcode) +#define SCM_OBJCODE_P(x) (SCM_HAS_TYP7 (x, scm_tc7_objcode)) #define SCM_OBJCODE_DATA(x) ((struct scm_objcode *) SCM_CELL_WORD_1 (x)) #define SCM_VALIDATE_OBJCODE(p,x) SCM_MAKE_VALIDATE (p, x, OBJCODE_P) @@ -60,14 +60,14 @@ struct scm_objcode #define SCM_OBJCODE_NATIVE_CODE(x) (SCM_CELL_WORD_3 (x)) #define SCM_SET_OBJCODE_NATIVE_CODE(x, code) (SCM_SET_CELL_WORD_3 (x, code)) +SCM_API SCM scm_load_thunk_from_file (SCM filename); +SCM_API SCM scm_load_thunk_from_memory (SCM bv); + SCM_API SCM scm_c_make_objcode_slice (SCM parent, const scm_t_uint8 *ptr); -SCM_API SCM scm_load_objcode (SCM file); SCM_API SCM scm_objcode_p (SCM obj); SCM_API SCM scm_objcode_meta (SCM objcode); -SCM_API SCM scm_bytecode_to_objcode (SCM bytecode); -SCM_INTERNAL SCM scm_bytecode_to_native_objcode (SCM bytecode); -SCM_API SCM scm_objcode_to_bytecode (SCM objcode); -SCM_API SCM scm_write_objcode (SCM objcode, SCM port); +SCM_API SCM scm_bytecode_to_objcode (SCM bytecode, SCM endianness); +SCM_API SCM scm_objcode_to_bytecode (SCM objcode, SCM endianness); SCM_INTERNAL void scm_i_objcode_print (SCM objcode, SCM port, scm_print_state *pstate); diff --git a/libguile/objprop.c b/libguile/objprop.c index 7b50d71d0..b45c9aa26 100644 --- a/libguile/objprop.c +++ b/libguile/objprop.c @@ -27,7 +27,6 @@ #include "libguile/hashtab.h" #include "libguile/alist.h" #include "libguile/root.h" -#include "libguile/weaks.h" #include "libguile/objprop.h" @@ -36,20 +35,13 @@ */ static SCM object_whash; -static scm_i_pthread_mutex_t whash_mutex = SCM_I_PTHREAD_MUTEX_INITIALIZER; SCM_DEFINE (scm_object_properties, "object-properties", 1, 0, 0, (SCM obj), "Return @var{obj}'s property list.") #define FUNC_NAME s_scm_object_properties { - SCM ret; - - scm_i_pthread_mutex_lock (&whash_mutex); - ret = scm_hashq_ref (object_whash, obj, SCM_EOL); - scm_i_pthread_mutex_unlock (&whash_mutex); - - return ret; + return scm_weak_table_refq (object_whash, obj, SCM_EOL); } #undef FUNC_NAME @@ -59,9 +51,7 @@ SCM_DEFINE (scm_set_object_properties_x, "set-object-properties!", 2, 0, 0, "Set @var{obj}'s property list to @var{alist}.") #define FUNC_NAME s_scm_set_object_properties_x { - scm_i_pthread_mutex_lock (&whash_mutex); - scm_hashq_set_x (object_whash, obj, alist); - scm_i_pthread_mutex_unlock (&whash_mutex); + scm_weak_table_putq_x (object_whash, obj, alist); return alist; } @@ -74,7 +64,7 @@ SCM_DEFINE (scm_object_property, "object-property", 2, 0, 0, { SCM assoc; assoc = scm_assq (key, scm_object_properties (obj)); - return (SCM_NIMP (assoc) ? SCM_CDR (assoc) : SCM_BOOL_F); + return (scm_is_pair (assoc) ? SCM_CDR (assoc) : SCM_BOOL_F); } #undef FUNC_NAME @@ -87,14 +77,14 @@ SCM_DEFINE (scm_set_object_property_x, "set-object-property!", 3, 0, 0, SCM alist; SCM assoc; - scm_i_pthread_mutex_lock (&whash_mutex); - alist = scm_hashq_ref (object_whash, obj, SCM_EOL); + scm_i_pthread_mutex_lock (&scm_i_misc_mutex); + alist = scm_weak_table_refq (object_whash, obj, SCM_EOL); assoc = scm_assq (key, alist); - if (SCM_NIMP (assoc)) + if (scm_is_pair (assoc)) SCM_SETCDR (assoc, value); else - scm_hashq_set_x (object_whash, obj, scm_acons (key, value, alist)); - scm_i_pthread_mutex_unlock (&whash_mutex); + scm_weak_table_putq_x (object_whash, obj, scm_acons (key, value, alist)); + scm_i_pthread_mutex_unlock (&scm_i_misc_mutex); return value; } @@ -104,7 +94,7 @@ SCM_DEFINE (scm_set_object_property_x, "set-object-property!", 3, 0, 0, void scm_init_objprop () { - object_whash = scm_make_weak_key_hash_table (SCM_UNDEFINED); + object_whash = scm_c_make_weak_table (0, SCM_WEAK_TABLE_KIND_KEY); #include "libguile/objprop.x" } diff --git a/libguile/options.c b/libguile/options.c index 0e083143c..2d7e18f65 100644 --- a/libguile/options.c +++ b/libguile/options.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995,1996,1998,2000,2001, 2006, 2008, 2009, 2010 Free Software Foundation +/* Copyright (C) 1995,1996,1998,2000,2001, 2006, 2008, 2009, 2010, 2011 Free Software Foundation * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -93,8 +93,6 @@ SCM_SYMBOL (scm_yes_sym, "yes"); SCM_SYMBOL (scm_no_sym, "no"); -static SCM protected_objects = SCM_EOL; - /* Return a list of the current option setting. The format of an * option setting is described in the above documentation. */ static SCM @@ -133,7 +131,7 @@ get_documented_option_setting (const scm_t_option options[]) for (i = 0; options[i].name; ++i) { - SCM ls = scm_cons (scm_from_locale_string (options[i].doc), SCM_EOL); + SCM ls = scm_cons (scm_from_utf8_string (options[i].doc), SCM_EOL); switch (options[i].type) { case SCM_OPTION_BOOLEAN: @@ -177,16 +175,17 @@ change_option_setting (SCM args, scm_t_option options[], const char *s, int dry_run) { unsigned int i; - SCM locally_protected_args = args; - SCM malloc_obj = scm_malloc_obj (options_length (options) * sizeof (scm_t_bits)); - scm_t_bits *flags = (scm_t_bits *) SCM_MALLOCDATA (malloc_obj); + scm_t_bits *new_vals; + + new_vals = scm_gc_malloc (options_length (options) * sizeof (scm_t_bits), + "new-options"); for (i = 0; options[i].name; ++i) { if (options[i].type == SCM_OPTION_BOOLEAN) - flags[i] = 0; + new_vals[i] = 0; else - flags[i] = options[i].val; + new_vals[i] = options[i].val; } while (!SCM_NULL_OR_NIL_P (args)) @@ -201,15 +200,15 @@ change_option_setting (SCM args, scm_t_option options[], const char *s, switch (options[i].type) { case SCM_OPTION_BOOLEAN: - flags[i] = 1; + new_vals[i] = 1; break; case SCM_OPTION_INTEGER: args = SCM_CDR (args); - flags[i] = scm_to_size_t (scm_car (args)); + new_vals[i] = scm_to_size_t (scm_car (args)); break; case SCM_OPTION_SCM: args = SCM_CDR (args); - flags[i] = SCM_UNPACK (scm_car (args)); + new_vals[i] = SCM_UNPACK (scm_car (args)); break; } found = 1; @@ -226,20 +225,7 @@ change_option_setting (SCM args, scm_t_option options[], const char *s, return; for (i = 0; options[i].name; ++i) - { - if (options[i].type == SCM_OPTION_SCM) - { - SCM old = SCM_PACK (options[i].val); - SCM new = SCM_PACK (flags[i]); - if (!SCM_IMP (old)) - protected_objects = scm_delq1_x (old, protected_objects); - if (!SCM_IMP (new)) - protected_objects = scm_cons (new, protected_objects); - } - options[i].val = flags[i]; - } - - scm_remember_upto_here_2 (locally_protected_args, malloc_obj); + options[i].val = new_vals[i]; } @@ -278,7 +264,7 @@ scm_init_opts (SCM (*func) (SCM), scm_t_option options[]) for (i = 0; options[i].name; ++i) { - SCM name = scm_from_locale_symbol (options[i].name); + SCM name = scm_from_utf8_symbol (options[i].name); options[i].name = (char *) SCM_UNPACK (name); } func (SCM_UNDEFINED); @@ -288,8 +274,6 @@ scm_init_opts (SCM (*func) (SCM), scm_t_option options[]) void scm_init_options () { - scm_gc_register_root (&protected_objects); - #include "libguile/options.x" } diff --git a/libguile/pairs.c b/libguile/pairs.c index 5dbbab566..1a3c5a18c 100644 --- a/libguile/pairs.c +++ b/libguile/pairs.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995,1996,2000,2001, 2004, 2005, 2006, 2008, 2009, 2011 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,2000,2001, 2004, 2005, 2006, 2008, 2009, 2011, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -67,18 +67,6 @@ void scm_error_pair_access (SCM non_pair) #endif -SCM_DEFINE (scm_cons, "cons", 2, 0, 0, - (SCM x, SCM y), - "Return a newly allocated pair whose car is @var{x} and whose\n" - "cdr is @var{y}. The pair is guaranteed to be different (in the\n" - "sense of @code{eq?}) from every previously existing object.") -#define FUNC_NAME s_scm_cons -{ - return scm_cell (SCM_UNPACK (x), SCM_UNPACK (y)); -} -#undef FUNC_NAME - - SCM scm_cons2 (SCM w, SCM x, SCM y) { @@ -143,14 +131,6 @@ SCM_DEFINE (scm_set_cdr_x, "set-cdr!", 2, 0, 0, return tree -SCM_DEFINE (scm_cdr, "cdr", 1, 0, 0, (SCM x), "") -{ - CHASE_PAIRS (x, "cdr", 0x02); /* 00000010 */ -} -SCM_DEFINE (scm_car, "car", 1, 0, 0, (SCM x), "") -{ - CHASE_PAIRS (x, "car", 0x03); /* 00000011 */ -} SCM_DEFINE (scm_cddr, "cddr", 1, 0, 0, (SCM x), "") { CHASE_PAIRS (x, "cddr", 0x0a); /* 00001010 */ @@ -270,6 +250,9 @@ void scm_init_pairs () { #include "libguile/pairs.x" + scm_c_define_gsubr ("cons", 2, 0, 0, scm_cons); + scm_c_define_gsubr ("car", 1, 0, 0, scm_car); + scm_c_define_gsubr ("cdr", 1, 0, 0, scm_cdr); } diff --git a/libguile/pairs.h b/libguile/pairs.h index 6edfc9c3e..130bf28a6 100644 --- a/libguile/pairs.h +++ b/libguile/pairs.h @@ -3,7 +3,7 @@ #ifndef SCM_PAIRS_H #define SCM_PAIRS_H -/* Copyright (C) 1995,1996,2000,2001, 2004, 2006, 2008, 2009, 2010 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,2000,2001, 2004, 2006, 2008, 2009, 2010, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -25,6 +25,8 @@ #include "libguile/__scm.h" +#include "libguile/gc.h" + #if (SCM_DEBUG_PAIR_ACCESSES == 1) @@ -115,11 +117,67 @@ SCM_API void scm_error_pair_access (SCM); #endif -SCM_API SCM scm_cons (SCM x, SCM y); +SCM_INLINE int scm_is_pair (SCM x); +SCM_INLINE SCM scm_cons (SCM x, SCM y); +SCM_INLINE SCM scm_car (SCM x); +SCM_INLINE SCM scm_cdr (SCM x); + +#if SCM_CAN_INLINE || defined SCM_INLINE_C_IMPLEMENTING_INLINES +/* Return a newly allocated pair whose car is @var{x} and whose cdr is + @var{y}. The pair is guaranteed to be different (in the sense of + @code{eq?}) from every previously existing object. */ +SCM_INLINE_IMPLEMENTATION SCM +scm_cons (SCM x, SCM y) +{ + return scm_cell (SCM_UNPACK (x), SCM_UNPACK (y)); +} + +SCM_INLINE_IMPLEMENTATION int +scm_is_pair (SCM x) +{ + /* The following "workaround_for_gcc_295" avoids bad code generated by + i386 gcc 2.95.4 (the Debian packaged 2.95.4-24 at least). + + Under the default -O2 the inlined SCM_I_CONSP test gets "optimized" so + the fetch of the tag word from x is done before confirming it's a + non-immediate (SCM_NIMP). Needless to say that bombs badly if x is a + immediate. This was seen to afflict scm_srfi1_split_at and something + deep in the bowels of ceval(). In both cases segvs resulted from + deferencing a random immediate value. srfi-1.test exposes the problem + through a short list, the immediate being SCM_EOL in that case. + Something in syntax.test exposed the ceval() problem. + + Just "volatile SCM workaround_for_gcc_295 = lst" is enough to avoid the + problem, without even using that variable. The "w=w" is just to + prevent a warning about it being unused. + */ +#if defined (__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 95 + volatile SCM workaround_for_gcc_295 = x; + workaround_for_gcc_295 = workaround_for_gcc_295; +#endif + + return SCM_I_CONSP (x); +} + +SCM_INLINE_IMPLEMENTATION SCM +scm_car (SCM x) +{ + if (SCM_UNLIKELY (!scm_is_pair (x))) + scm_wrong_type_arg_msg ("car", 0, x, "pair"); + return SCM_CAR (x); +} + +SCM_INLINE_IMPLEMENTATION SCM +scm_cdr (SCM x) +{ + if (SCM_UNLIKELY (!scm_is_pair (x))) + scm_wrong_type_arg_msg ("cdr", 0, x, "pair"); + return SCM_CDR (x); +} +#endif + SCM_API SCM scm_cons2 (SCM w, SCM x, SCM y); SCM_API SCM scm_pair_p (SCM x); -SCM_API SCM scm_car (SCM x); -SCM_API SCM scm_cdr (SCM x); SCM_API SCM scm_set_car_x (SCM pair, SCM value); SCM_API SCM scm_set_cdr_x (SCM pair, SCM value); diff --git a/libguile/ports.c b/libguile/ports.c index 55808e272..0aacacc06 100644 --- a/libguile/ports.c +++ b/libguile/ports.c @@ -1,5 +1,5 @@ /* Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, - * 2006, 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. + * 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -56,7 +56,7 @@ #include "libguile/validate.h" #include "libguile/ports.h" #include "libguile/vectors.h" -#include "libguile/weaks.h" +#include "libguile/weak-set.h" #include "libguile/fluids.h" #include "libguile/eq.h" @@ -90,6 +90,56 @@ #endif +/* Port encodings are case-insensitive ASCII strings. */ +static char +ascii_toupper (char c) +{ + return (c < 'a' || c > 'z') ? c : ('A' + (c - 'a')); +} + +/* It is only necessary to use this function on encodings that come from + the user and have not been canonicalized yet. Encodings that are set + on ports or in the default encoding fluid are in upper-case, and can + be compared with strcmp. */ +static int +encoding_matches (const char *enc, const char *upper) +{ + if (!enc) + enc = "ISO-8859-1"; + + while (*enc) + if (ascii_toupper (*enc++) != *upper++) + return 0; + + return !*upper; +} + +static char* +canonicalize_encoding (const char *enc) +{ + char *ret; + int i; + + if (!enc) + return "ISO-8859-1"; + + ret = scm_gc_strdup (enc, "port"); + + for (i = 0; ret[i]; i++) + { + if (ret[i] > 127) + /* Restrict to ASCII. */ + scm_misc_error (NULL, "invalid character encoding ~s", + scm_list_1 (scm_from_latin1_string (enc))); + else + ret[i] = ascii_toupper (ret[i]); + } + + return ret; +} + + + /* The port kind table --- a dynamically resized array of port types. */ @@ -98,19 +148,79 @@ * Indexes into this table are used when generating type * tags for smobjects (if you know a tag you can get an index and conversely). */ -scm_t_ptob_descriptor *scm_ptobs = NULL; -long scm_numptob = 0; +static scm_t_ptob_descriptor **scm_ptobs = NULL; +static long scm_numptob = 0; /* Number of port types. */ +static long scm_ptobs_size = 0; /* Number of slots in the port type + table. */ +static scm_i_pthread_mutex_t scm_ptobs_lock = SCM_I_PTHREAD_MUTEX_INITIALIZER; -/* GC marker for a port with stream of SCM type. */ -SCM -scm_markstream (SCM ptr) +long +scm_c_num_port_types (void) { - int openp; - openp = SCM_CELL_WORD_0 (ptr) & SCM_OPN; - if (openp) - return SCM_PACK (SCM_STREAM (ptr)); - else - return SCM_BOOL_F; + long ret; + + scm_i_pthread_mutex_lock (&scm_ptobs_lock); + ret = scm_numptob; + scm_i_pthread_mutex_unlock (&scm_ptobs_lock); + + return ret; +} + +scm_t_ptob_descriptor* +scm_c_port_type_ref (long ptobnum) +{ + scm_t_ptob_descriptor *ret = NULL; + + scm_i_pthread_mutex_lock (&scm_ptobs_lock); + + if (0 <= ptobnum && ptobnum < scm_numptob) + ret = scm_ptobs[ptobnum]; + + scm_i_pthread_mutex_unlock (&scm_ptobs_lock); + + if (!ret) + scm_out_of_range ("scm_c_port_type_ref", scm_from_long (ptobnum)); + + return ret; +} + +long +scm_c_port_type_add_x (scm_t_ptob_descriptor *desc) +{ + long ret = -1; + + scm_i_pthread_mutex_lock (&scm_ptobs_lock); + + if (scm_numptob + 1 < SCM_I_MAX_PORT_TYPE_COUNT) + { + if (scm_numptob == scm_ptobs_size) + { + unsigned long old_size = scm_ptobs_size; + scm_t_ptob_descriptor **old_ptobs = scm_ptobs; + + /* Currently there are only 9 predefined port types, so one + resize will cover it. */ + scm_ptobs_size = old_size + 10; + + if (scm_ptobs_size >= SCM_I_MAX_PORT_TYPE_COUNT) + scm_ptobs_size = SCM_I_MAX_PORT_TYPE_COUNT; + + scm_ptobs = scm_gc_malloc (sizeof (*scm_ptobs) * scm_ptobs_size, + "scm_ptobs"); + + memcpy (scm_ptobs, old_ptobs, sizeof (*scm_ptobs) * scm_numptob); + } + + ret = scm_numptob++; + scm_ptobs[ret] = desc; + } + + scm_i_pthread_mutex_unlock (&scm_ptobs_lock); + + if (ret < 0) + scm_out_of_range ("scm_c_port_type_add_x", scm_from_long (scm_numptob)); + + return ret; } /* @@ -134,238 +244,93 @@ scm_make_port_type (char *name, int (*fill_input) (SCM port), void (*write) (SCM port, const void *data, size_t size)) { - char *tmp; - if (SCM_I_MAX_PORT_TYPE_COUNT - 1 <= scm_numptob) - goto ptoberr; - SCM_CRITICAL_SECTION_START; - tmp = (char *) scm_gc_realloc ((char *) scm_ptobs, - scm_numptob * sizeof (scm_t_ptob_descriptor), - (1 + scm_numptob) - * sizeof (scm_t_ptob_descriptor), - "port-type"); - if (tmp) - { - scm_ptobs = (scm_t_ptob_descriptor *) tmp; - - scm_ptobs[scm_numptob].name = name; - scm_ptobs[scm_numptob].mark = 0; - scm_ptobs[scm_numptob].free = NULL; - scm_ptobs[scm_numptob].print = scm_port_print; - scm_ptobs[scm_numptob].equalp = 0; - scm_ptobs[scm_numptob].close = 0; + scm_t_ptob_descriptor *desc; + long ptobnum; - scm_ptobs[scm_numptob].write = write; - scm_ptobs[scm_numptob].flush = flush_port_default; + desc = scm_gc_malloc_pointerless (sizeof (*desc), "port-type"); + memset (desc, 0, sizeof (*desc)); - scm_ptobs[scm_numptob].end_input = end_input_default; - scm_ptobs[scm_numptob].fill_input = fill_input; - scm_ptobs[scm_numptob].input_waiting = 0; + desc->name = name; + desc->print = scm_port_print; + desc->write = write; + desc->flush = flush_port_default; + desc->end_input = end_input_default; + desc->fill_input = fill_input; - scm_ptobs[scm_numptob].seek = 0; - scm_ptobs[scm_numptob].truncate = 0; + ptobnum = scm_c_port_type_add_x (desc); - scm_numptob++; - } - SCM_CRITICAL_SECTION_END; - if (!tmp) - { - ptoberr: - scm_memory_error ("scm_make_port_type"); - } - /* Make a class object if Goops is present */ + /* Make a class object if GOOPS is present. */ if (SCM_UNPACK (scm_port_class[0]) != 0) - scm_make_port_classes (scm_numptob - 1, SCM_PTOBNAME (scm_numptob - 1)); - return scm_tc7_port + (scm_numptob - 1) * 256; + scm_make_port_classes (ptobnum, name); + + return scm_tc7_port + ptobnum * 256; } void scm_set_port_mark (scm_t_bits tc, SCM (*mark) (SCM)) { - scm_ptobs[SCM_TC2PTOBNUM (tc)].mark = mark; + scm_c_port_type_ref (SCM_TC2PTOBNUM (tc))->mark = mark; } void scm_set_port_free (scm_t_bits tc, size_t (*free) (SCM)) { - scm_ptobs[SCM_TC2PTOBNUM (tc)].free = free; + scm_c_port_type_ref (SCM_TC2PTOBNUM (tc))->free = free; } void scm_set_port_print (scm_t_bits tc, int (*print) (SCM exp, SCM port, - scm_print_state *pstate)) + scm_print_state *pstate)) { - scm_ptobs[SCM_TC2PTOBNUM (tc)].print = print; + scm_c_port_type_ref (SCM_TC2PTOBNUM (tc))->print = print; } void scm_set_port_equalp (scm_t_bits tc, SCM (*equalp) (SCM, SCM)) { - scm_ptobs[SCM_TC2PTOBNUM (tc)].equalp = equalp; + scm_c_port_type_ref (SCM_TC2PTOBNUM (tc))->equalp = equalp; } void -scm_set_port_flush (scm_t_bits tc, void (*flush) (SCM port)) +scm_set_port_close (scm_t_bits tc, int (*close) (SCM)) { - scm_ptobs[SCM_TC2PTOBNUM (tc)].flush = flush; + scm_c_port_type_ref (SCM_TC2PTOBNUM (tc))->close = close; } void -scm_set_port_end_input (scm_t_bits tc, void (*end_input) (SCM port, int offset)) +scm_set_port_flush (scm_t_bits tc, void (*flush) (SCM port)) { - scm_ptobs[SCM_TC2PTOBNUM (tc)].end_input = end_input; + scm_t_ptob_descriptor *ptob = scm_c_port_type_ref (SCM_TC2PTOBNUM (tc)); + ptob->flush = flush; + ptob->flags |= SCM_PORT_TYPE_HAS_FLUSH; } void -scm_set_port_close (scm_t_bits tc, int (*close) (SCM)) +scm_set_port_end_input (scm_t_bits tc, void (*end_input) (SCM port, int offset)) { - scm_ptobs[SCM_TC2PTOBNUM (tc)].close = close; + scm_c_port_type_ref (SCM_TC2PTOBNUM (tc))->end_input = end_input; } void -scm_set_port_seek (scm_t_bits tc, - scm_t_off (*seek) (SCM, scm_t_off, int)) +scm_set_port_seek (scm_t_bits tc, scm_t_off (*seek) (SCM, scm_t_off, int)) { - scm_ptobs[SCM_TC2PTOBNUM (tc)].seek = seek; + scm_c_port_type_ref (SCM_TC2PTOBNUM (tc))->seek = seek; } void scm_set_port_truncate (scm_t_bits tc, void (*truncate) (SCM, scm_t_off)) { - scm_ptobs[SCM_TC2PTOBNUM (tc)].truncate = truncate; + scm_c_port_type_ref (SCM_TC2PTOBNUM (tc))->truncate = truncate; } void scm_set_port_input_waiting (scm_t_bits tc, int (*input_waiting) (SCM)) { - scm_ptobs[SCM_TC2PTOBNUM (tc)].input_waiting = input_waiting; + scm_c_port_type_ref (SCM_TC2PTOBNUM (tc))->input_waiting = input_waiting; } -SCM_DEFINE (scm_char_ready_p, "char-ready?", 0, 1, 0, - (SCM port), - "Return @code{#t} if a character is ready on input @var{port}\n" - "and return @code{#f} otherwise. If @code{char-ready?} returns\n" - "@code{#t} then the next @code{read-char} operation on\n" - "@var{port} is guaranteed not to hang. If @var{port} is a file\n" - "port at end of file then @code{char-ready?} returns @code{#t}.\n" - "\n" - "@code{char-ready?} exists to make it possible for a\n" - "program to accept characters from interactive ports without\n" - "getting stuck waiting for input. Any input editors associated\n" - "with such ports must make sure that characters whose existence\n" - "has been asserted by @code{char-ready?} cannot be rubbed out.\n" - "If @code{char-ready?} were to return @code{#f} at end of file,\n" - "a port at end of file would be indistinguishable from an\n" - "interactive port that has no ready characters.") -#define FUNC_NAME s_scm_char_ready_p -{ - scm_t_port *pt; - - if (SCM_UNBNDP (port)) - port = scm_current_input_port (); - /* It's possible to close the current input port, so validate even in - this case. */ - SCM_VALIDATE_OPINPORT (1, port); - - pt = SCM_PTAB_ENTRY (port); - - /* if the current read buffer is filled, or the - last pushed-back char has been read and the saved buffer is - filled, result is true. */ - if (pt->read_pos < pt->read_end - || (pt->read_buf == pt->putback_buf - && pt->saved_read_pos < pt->saved_read_end)) - return SCM_BOOL_T; - else - { - scm_t_ptob_descriptor *ptob = &scm_ptobs[SCM_PTOBNUM (port)]; - - if (ptob->input_waiting) - return scm_from_bool(ptob->input_waiting (port)); - else - return SCM_BOOL_T; - } -} -#undef FUNC_NAME - -/* Move up to READ_LEN bytes from PORT's putback and/or read buffers - into memory starting at DEST. Return the number of bytes moved. - PORT's line/column numbers are left unchanged. */ -size_t -scm_take_from_input_buffers (SCM port, char *dest, size_t read_len) -{ - scm_t_port *pt = SCM_PTAB_ENTRY (port); - size_t bytes_read = 0; - size_t from_buf = min (pt->read_end - pt->read_pos, read_len); - - if (from_buf > 0) - { - memcpy (dest, pt->read_pos, from_buf); - pt->read_pos += from_buf; - bytes_read += from_buf; - read_len -= from_buf; - dest += from_buf; - } - - /* if putback was active, try the real input buffer too. */ - if (pt->read_buf == pt->putback_buf) - { - from_buf = min (pt->saved_read_end - pt->saved_read_pos, read_len); - if (from_buf > 0) - { - memcpy (dest, pt->saved_read_pos, from_buf); - pt->saved_read_pos += from_buf; - bytes_read += from_buf; - } - } - - return bytes_read; -} - -/* Clear a port's read buffers, returning the contents. */ -SCM_DEFINE (scm_drain_input, "drain-input", 1, 0, 0, - (SCM port), - "This procedure clears a port's input buffers, similar\n" - "to the way that force-output clears the output buffer. The\n" - "contents of the buffers are returned as a single string, e.g.,\n" - "\n" - "@lisp\n" - "(define p (open-input-file ...))\n" - "(drain-input p) => empty string, nothing buffered yet.\n" - "(unread-char (read-char p) p)\n" - "(drain-input p) => initial chars from p, up to the buffer size.\n" - "@end lisp\n\n" - "Draining the buffers may be useful for cleanly finishing\n" - "buffered I/O so that the file descriptor can be used directly\n" - "for further input.") -#define FUNC_NAME s_scm_drain_input -{ - SCM result; - char *data; - scm_t_port *pt; - long count; - - SCM_VALIDATE_OPINPORT (1, port); - pt = SCM_PTAB_ENTRY (port); - - count = pt->read_end - pt->read_pos; - if (pt->read_buf == pt->putback_buf) - count += pt->saved_read_end - pt->saved_read_pos; - - if (count) - { - result = scm_i_make_string (count, &data, 0); - scm_take_from_input_buffers (port, data, count); - } - else - result = scm_nullstr; - - return result; -} -#undef FUNC_NAME - - /* Standard ports --- current input, output, error, and more(!). */ static SCM cur_inport_fluid = SCM_BOOL_F; @@ -528,322 +493,278 @@ scm_i_dynwind_current_load_port (SCM port) scm_dynwind_fluid (cur_loadport_fluid, port); } - -/* The port table --- an array of pointers to ports. */ - -/* - We need a global registry of ports to flush them all at exit, and to - get all the ports matching a file descriptor. The associated values - are alists, where additional information can be associated with ports. - */ -SCM scm_i_port_weak_hash; - -scm_i_pthread_mutex_t scm_i_port_table_mutex = SCM_I_PTHREAD_MUTEX_INITIALIZER; -/* Port finalization. */ +/* Retrieving a port's mode. */ -static void finalize_port (void *, void *); +/* Return the flags that characterize a port based on the mode + * string used to open a file for that port. + * + * See PORT FLAGS in scm.h + */ -/* Register a finalizer for PORT. */ -static SCM_C_INLINE_KEYWORD void -register_finalizer_for_port (SCM port) +static long +scm_i_mode_bits_n (SCM modes) { - /* Register a finalizer for PORT so that its iconv CDs get freed and - optionally its type's `free' function gets called. */ - scm_i_set_finalizer (SCM2PTR (port), finalize_port, NULL); + return (SCM_OPN + | (scm_i_string_contains_char (modes, 'r') + || scm_i_string_contains_char (modes, '+') ? SCM_RDNG : 0) + | (scm_i_string_contains_char (modes, 'w') + || scm_i_string_contains_char (modes, 'a') + || scm_i_string_contains_char (modes, '+') ? SCM_WRTNG : 0) + | (scm_i_string_contains_char (modes, '0') ? SCM_BUF0 : 0) + | (scm_i_string_contains_char (modes, 'l') ? SCM_BUFLINE : 0)); } -/* Finalize the object (a port) pointed to by PTR. */ -static void -finalize_port (void *ptr, void *data) +long +scm_mode_bits (char *modes) { - long port_type; - SCM port = PTR2SCM (ptr); - - if (!SCM_PORTP (port)) - abort (); + /* Valid characters are rw+a0l. So, use latin1. */ + return scm_i_mode_bits (scm_from_latin1_string (modes)); +} - if (SCM_OPENP (port)) - { - if (SCM_REVEALED (port) > 0) - /* Keep "revealed" ports alive and re-register a finalizer. */ - register_finalizer_for_port (port); - else - { - scm_t_port *entry; +long +scm_i_mode_bits (SCM modes) +{ + long bits; - port_type = SCM_TC2PTOBNUM (SCM_CELL_TYPE (port)); - if (port_type >= scm_numptob) - abort (); + if (!scm_is_string (modes)) + scm_wrong_type_arg_msg (NULL, 0, modes, "string"); - if (scm_ptobs[port_type].free) - /* Yes, I really do mean `.free' rather than `.close'. `.close' - is for explicit `close-port' by user. */ - scm_ptobs[port_type].free (port); + bits = scm_i_mode_bits_n (modes); + scm_remember_upto_here_1 (modes); + return bits; +} - entry = SCM_PTAB_ENTRY (port); +/* Return the mode flags from an open port. + * Some modes such as "append" are only used when opening + * a file and are not returned here. */ - if (entry->input_cd != (iconv_t) -1) - iconv_close (entry->input_cd); - if (entry->output_cd != (iconv_t) -1) - iconv_close (entry->output_cd); +SCM_DEFINE (scm_port_mode, "port-mode", 1, 0, 0, + (SCM port), + "Return the port modes associated with the open port @var{port}.\n" + "These will not necessarily be identical to the modes used when\n" + "the port was opened, since modes such as \"append\" which are\n" + "used only during port creation are not retained.") +#define FUNC_NAME s_scm_port_mode +{ + char modes[4]; + modes[0] = '\0'; - SCM_SETSTREAM (port, 0); - SCM_CLR_PORT_OPEN_FLAG (port); + port = SCM_COERCE_OUTPORT (port); + SCM_VALIDATE_OPPORT (1, port); + if (SCM_CELL_WORD_0 (port) & SCM_RDNG) { + if (SCM_CELL_WORD_0 (port) & SCM_WRTNG) + strcpy (modes, "r+"); + else + strcpy (modes, "r"); + } + else if (SCM_CELL_WORD_0 (port) & SCM_WRTNG) + strcpy (modes, "w"); + if (SCM_CELL_WORD_0 (port) & SCM_BUF0) + strcat (modes, "0"); - scm_gc_ports_collected++; - } - } + return scm_from_latin1_string (modes); } - +#undef FUNC_NAME -/* This function is not and should not be thread safe. */ -SCM -scm_new_port_table_entry (scm_t_bits tag) -#define FUNC_NAME "scm_new_port_table_entry" -{ - /* - We initialize the cell to empty, this is in case scm_gc_calloc - triggers GC ; we don't want the GC to scan a half-finished Z. - */ - - SCM z = scm_cons (SCM_EOL, SCM_EOL); - scm_t_port *entry = (scm_t_port *) scm_gc_calloc (sizeof (scm_t_port), "port"); - const char *enc; +/* The port table --- a weak set of all ports. - entry->file_name = SCM_BOOL_F; - entry->rw_active = SCM_PORT_NEITHER; - entry->port = z; + We need a global registry of ports to flush them all at exit, and to + get all the ports matching a file descriptor. */ +SCM scm_i_port_weak_set; - /* Initialize this port with the thread's current default - encoding. */ - enc = scm_i_default_port_encoding (); - entry->encoding = enc ? scm_gc_strdup (enc, "port") : NULL; - /* The conversion descriptors will be opened lazily. */ - entry->input_cd = (iconv_t) -1; - entry->output_cd = (iconv_t) -1; + - entry->ilseq_handler = scm_i_default_port_conversion_handler (); +/* Port finalization. */ - SCM_SET_CELL_TYPE (z, tag); - SCM_SETPTAB_ENTRY (z, entry); +struct do_free_data +{ + scm_t_ptob_descriptor *ptob; + SCM port; +}; - scm_hashq_set_x (scm_i_port_weak_hash, z, SCM_EOL); +static SCM +do_free (void *body_data) +{ + struct do_free_data *data = body_data; - /* For each new port, register a finalizer so that it port type's free - function can be invoked eventually. */ - register_finalizer_for_port (z); + /* `close' is for explicit `close-port' by user. `free' is for this + purpose: ports collected by the GC. */ + data->ptob->free (data->port); - return z; + return SCM_BOOL_T; } -#undef FUNC_NAME -#if SCM_ENABLE_DEPRECATED==1 -scm_t_port * -scm_add_to_port_table (SCM port) +/* Finalize the object (a port) pointed to by PTR. */ +static void +finalize_port (void *ptr, void *data) { - SCM z; - scm_t_port * pt; + SCM port = SCM_PACK_POINTER (ptr); + + if (!SCM_PORTP (port)) + abort (); + + if (SCM_OPENP (port)) + { + struct do_free_data data; - scm_c_issue_deprecation_warning ("scm_add_to_port_table is deprecated."); + SCM_CLR_PORT_OPEN_FLAG (port); - scm_i_pthread_mutex_lock (&scm_i_port_table_mutex); - z = scm_new_port_table_entry (scm_tc7_port); - pt = SCM_PTAB_ENTRY(z); - pt->port = port; - SCM_SETCAR (z, SCM_EOL); - SCM_SETCDR (z, SCM_EOL); - SCM_SETPTAB_ENTRY (port, pt); - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); + data.ptob = SCM_PORT_DESCRIPTOR (port); + data.port = port; - return pt; + scm_internal_catch (SCM_BOOL_T, do_free, &data, + scm_handle_by_message_noexit, NULL); + + scm_gc_ports_collected++; + } } -#endif -/* Remove a port from the table and destroy it. */ + -static void -scm_i_remove_port (SCM port) -#define FUNC_NAME "scm_remove_port" +SCM +scm_c_make_port_with_encoding (scm_t_bits tag, unsigned long mode_bits, + const char *encoding, + scm_t_string_failed_conversion_handler handler, + scm_t_bits stream) { - scm_t_port *p; + SCM ret; + scm_t_port *entry; + scm_t_ptob_descriptor *ptob; - scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex); + entry = (scm_t_port *) scm_gc_calloc (sizeof (scm_t_port), "port"); + ptob = scm_c_port_type_ref (SCM_TC2PTOBNUM (tag)); - p = SCM_PTAB_ENTRY (port); - scm_port_non_buffer (p); - p->putback_buf = NULL; - p->putback_buf_size = 0; + ret = scm_words (tag | mode_bits, 3); + SCM_SET_CELL_WORD_1 (ret, (scm_t_bits) entry); + SCM_SET_CELL_WORD_2 (ret, (scm_t_bits) ptob); + + entry->lock = scm_gc_malloc_pointerless (sizeof (*entry->lock), "port lock"); + scm_i_pthread_mutex_init (entry->lock, scm_i_pthread_mutexattr_recursive); + + entry->file_name = SCM_BOOL_F; + entry->rw_active = SCM_PORT_NEITHER; + entry->port = ret; + entry->stream = stream; - if (p->input_cd != (iconv_t) -1) + if (encoding_matches (encoding, "UTF-8")) { - iconv_close (p->input_cd); - p->input_cd = (iconv_t) -1; + entry->encoding_mode = SCM_PORT_ENCODING_MODE_UTF8; + entry->encoding = "UTF-8"; } - - if (p->output_cd != (iconv_t) -1) + else if (encoding_matches (encoding, "ISO-8859-1")) { - iconv_close (p->output_cd); - p->output_cd = (iconv_t) -1; + entry->encoding_mode = SCM_PORT_ENCODING_MODE_LATIN1; + entry->encoding = "ISO-8859-1"; + } + else + { + entry->encoding_mode = SCM_PORT_ENCODING_MODE_ICONV; + entry->encoding = canonicalize_encoding (encoding); } - SCM_SETPTAB_ENTRY (port, 0); + entry->ilseq_handler = handler; + entry->iconv_descriptors = NULL; - scm_hashq_remove_x (scm_i_port_weak_hash, port); + entry->alist = SCM_EOL; - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); -} -#undef FUNC_NAME + if (SCM_PORT_DESCRIPTOR (ret)->free) + scm_i_set_finalizer (SCM2PTR (ret), finalize_port, NULL); + if (SCM_PORT_DESCRIPTOR (ret)->flags & SCM_PORT_TYPE_HAS_FLUSH) + scm_weak_set_add_x (scm_i_port_weak_set, ret); -/* Functions for debugging. */ -#ifdef GUILE_DEBUG -SCM_DEFINE (scm_pt_size, "pt-size", 0, 0, 0, - (), - "Return the number of ports in the port table. @code{pt-size}\n" - "is only included in @code{--enable-guile-debug} builds.") -#define FUNC_NAME s_scm_pt_size -{ - return scm_from_int (SCM_HASHTABLE_N_ITEMS (scm_i_port_weak_hash)); + return ret; } -#undef FUNC_NAME -#endif -void -scm_port_non_buffer (scm_t_port *pt) +SCM +scm_c_make_port (scm_t_bits tag, unsigned long mode_bits, scm_t_bits stream) { - pt->read_pos = pt->read_buf = pt->read_end = &pt->shortbuf; - pt->write_buf = pt->write_pos = &pt->shortbuf; - pt->read_buf_size = pt->write_buf_size = 1; - pt->write_end = pt->write_buf + pt->write_buf_size; + return scm_c_make_port_with_encoding (tag, mode_bits, + scm_i_default_port_encoding (), + scm_i_default_port_conversion_handler (), + stream); } - -/* Revealed counts --- an oddity inherited from SCSH. */ - -/* Find a port in the table and return its revealed count. - Also used by the garbage collector. - */ - -int -scm_revealed_count (SCM port) +SCM +scm_new_port_table_entry (scm_t_bits tag) { - return SCM_REVEALED(port); + return scm_c_make_port (tag, 0, 0); } + +/* Predicates. */ -/* Return the revealed count for a port. */ - -SCM_DEFINE (scm_port_revealed, "port-revealed", 1, 0, 0, - (SCM port), - "Return the revealed count for @var{port}.") -#define FUNC_NAME s_scm_port_revealed +SCM_DEFINE (scm_port_p, "port?", 1, 0, 0, + (SCM x), + "Return a boolean indicating whether @var{x} is a port.\n" + "Equivalent to @code{(or (input-port? @var{x}) (output-port?\n" + "@var{x}))}.") +#define FUNC_NAME s_scm_port_p { - port = SCM_COERCE_OUTPORT (port); - SCM_VALIDATE_OPENPORT (1, port); - return scm_from_int (scm_revealed_count (port)); + return scm_from_bool (SCM_PORTP (x)); } #undef FUNC_NAME -/* Set the revealed count for a port. */ -SCM_DEFINE (scm_set_port_revealed_x, "set-port-revealed!", 2, 0, 0, - (SCM port, SCM rcount), - "Sets the revealed count for a port to a given value.\n" - "The return value is unspecified.") -#define FUNC_NAME s_scm_set_port_revealed_x +SCM_DEFINE (scm_input_port_p, "input-port?", 1, 0, 0, + (SCM x), + "Return @code{#t} if @var{x} is an input port, otherwise return\n" + "@code{#f}. Any object satisfying this predicate also satisfies\n" + "@code{port?}.") +#define FUNC_NAME s_scm_input_port_p { - port = SCM_COERCE_OUTPORT (port); - SCM_VALIDATE_OPENPORT (1, port); - SCM_REVEALED (port) = scm_to_int (rcount); - return SCM_UNSPECIFIED; + return scm_from_bool (SCM_INPUT_PORT_P (x)); } #undef FUNC_NAME - - -/* Retrieving a port's mode. */ - -/* Return the flags that characterize a port based on the mode - * string used to open a file for that port. - * - * See PORT FLAGS in scm.h - */ - -static long -scm_i_mode_bits_n (SCM modes) -{ - return (SCM_OPN - | (scm_i_string_contains_char (modes, 'r') - || scm_i_string_contains_char (modes, '+') ? SCM_RDNG : 0) - | (scm_i_string_contains_char (modes, 'w') - || scm_i_string_contains_char (modes, 'a') - || scm_i_string_contains_char (modes, '+') ? SCM_WRTNG : 0) - | (scm_i_string_contains_char (modes, '0') ? SCM_BUF0 : 0) - | (scm_i_string_contains_char (modes, 'l') ? SCM_BUFLINE : 0)); -} - -long -scm_mode_bits (char *modes) +SCM_DEFINE (scm_output_port_p, "output-port?", 1, 0, 0, + (SCM x), + "Return @code{#t} if @var{x} is an output port, otherwise return\n" + "@code{#f}. Any object satisfying this predicate also satisfies\n" + "@code{port?}.") +#define FUNC_NAME s_scm_output_port_p { - return scm_i_mode_bits (scm_from_locale_string (modes)); + x = SCM_COERCE_OUTPORT (x); + return scm_from_bool (SCM_OUTPUT_PORT_P (x)); } +#undef FUNC_NAME -long -scm_i_mode_bits (SCM modes) +SCM_DEFINE (scm_port_closed_p, "port-closed?", 1, 0, 0, + (SCM port), + "Return @code{#t} if @var{port} is closed or @code{#f} if it is\n" + "open.") +#define FUNC_NAME s_scm_port_closed_p { - long bits; - - if (!scm_is_string (modes)) - scm_wrong_type_arg_msg (NULL, 0, modes, "string"); - - bits = scm_i_mode_bits_n (modes); - scm_remember_upto_here_1 (modes); - return bits; + SCM_VALIDATE_PORT (1, port); + return scm_from_bool (!SCM_OPPORTP (port)); } +#undef FUNC_NAME -/* Return the mode flags from an open port. - * Some modes such as "append" are only used when opening - * a file and are not returned here. */ - -SCM_DEFINE (scm_port_mode, "port-mode", 1, 0, 0, - (SCM port), - "Return the port modes associated with the open port @var{port}.\n" - "These will not necessarily be identical to the modes used when\n" - "the port was opened, since modes such as \"append\" which are\n" - "used only during port creation are not retained.") -#define FUNC_NAME s_scm_port_mode +SCM_DEFINE (scm_eof_object_p, "eof-object?", 1, 0, 0, + (SCM x), + "Return @code{#t} if @var{x} is an end-of-file object; otherwise\n" + "return @code{#f}.") +#define FUNC_NAME s_scm_eof_object_p { - char modes[4]; - modes[0] = '\0'; - - port = SCM_COERCE_OUTPORT (port); - SCM_VALIDATE_OPPORT (1, port); - if (SCM_CELL_WORD_0 (port) & SCM_RDNG) { - if (SCM_CELL_WORD_0 (port) & SCM_WRTNG) - strcpy (modes, "r+"); - else - strcpy (modes, "r"); - } - else if (SCM_CELL_WORD_0 (port) & SCM_WRTNG) - strcpy (modes, "w"); - if (SCM_CELL_WORD_0 (port) & SCM_BUF0) - strcat (modes, "0"); - return scm_from_locale_string (modes); + return scm_from_bool (SCM_EOF_OBJECT_P (x)); } #undef FUNC_NAME + /* Closing ports. */ +static void close_iconv_descriptors (scm_t_iconv_descriptors *id); + /* scm_close_port * Call the close operation on a port object. * see also scm_close. @@ -858,7 +779,7 @@ SCM_DEFINE (scm_close_port, "close-port", 1, 0, 0, "descriptors.") #define FUNC_NAME s_scm_close_port { - size_t i; + scm_t_port *p; int rv; port = SCM_COERCE_OUTPORT (port); @@ -866,13 +787,28 @@ SCM_DEFINE (scm_close_port, "close-port", 1, 0, 0, SCM_VALIDATE_PORT (1, port); if (SCM_CLOSEDP (port)) return SCM_BOOL_F; - i = SCM_PTOBNUM (port); - if (scm_ptobs[i].close) - rv = (scm_ptobs[i].close) (port); + + p = SCM_PTAB_ENTRY (port); + SCM_CLR_PORT_OPEN_FLAG (port); + + if (SCM_PORT_DESCRIPTOR (port)->flags & SCM_PORT_TYPE_HAS_FLUSH) + scm_weak_set_remove_x (scm_i_port_weak_set, port); + + if (SCM_PORT_DESCRIPTOR (port)->close) + /* Note! This may throw an exception. Anything after this point + should be resilient to non-local exits. */ + rv = SCM_PORT_DESCRIPTOR (port)->close (port); else rv = 0; - scm_i_remove_port (port); - SCM_CLR_PORT_OPEN_FLAG (port); + + if (p->iconv_descriptors) + { + /* If we don't get here, the iconv_descriptors finalizer will + clean up. */ + close_iconv_descriptors (p->iconv_descriptors); + p->iconv_descriptors = NULL; + } + return scm_from_bool (rv >= 0); } #undef FUNC_NAME @@ -908,183 +844,616 @@ SCM_DEFINE (scm_close_output_port, "close-output-port", 1, 0, 0, } #undef FUNC_NAME -static SCM -collect_keys (void *unused, SCM key, SCM value, SCM result) + + + +/* Encoding characters to byte streams, and decoding byte streams to + characters. */ + +/* A fluid specifying the default encoding for newly created ports. If it is + a string, that is the encoding. If it is #f, it is in the "native" + (Latin-1) encoding. */ +SCM_VARIABLE (default_port_encoding_var, "%default-port-encoding"); + +static int scm_port_encoding_init = 0; + +/* Use ENCODING as the default encoding for future ports. */ +void +scm_i_set_default_port_encoding (const char *encoding) { - return scm_cons (key, result); + if (!scm_port_encoding_init + || !scm_is_fluid (SCM_VARIABLE_REF (default_port_encoding_var))) + scm_misc_error (NULL, "tried to set port encoding fluid before it is initialized", + SCM_EOL); + + if (encoding_matches (encoding, "ISO-8859-1")) + scm_fluid_set_x (SCM_VARIABLE_REF (default_port_encoding_var), SCM_BOOL_F); + else + scm_fluid_set_x (SCM_VARIABLE_REF (default_port_encoding_var), + scm_from_latin1_string (canonicalize_encoding (encoding))); } -void -scm_c_port_for_each (void (*proc)(void *data, SCM p), void *data) +/* Return the name of the default encoding for newly created ports. */ +const char * +scm_i_default_port_encoding (void) { - SCM ports; + if (!scm_port_encoding_init) + return "ISO-8859-1"; + else if (!scm_is_fluid (SCM_VARIABLE_REF (default_port_encoding_var))) + return "ISO-8859-1"; + else + { + SCM encoding; + + encoding = scm_fluid_ref (SCM_VARIABLE_REF (default_port_encoding_var)); + if (!scm_is_string (encoding)) + return "ISO-8859-1"; + else + return scm_i_string_chars (encoding); + } +} - /* Copy out the port table as a list so that we get strong references - to all the values. */ - scm_i_pthread_mutex_lock (&scm_i_port_table_mutex); - ports = scm_internal_hash_fold (collect_keys, NULL, - SCM_EOL, scm_i_port_weak_hash); - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); +/* A fluid specifying the default conversion handler for newly created + ports. Its value should be one of the symbols below. */ +SCM_VARIABLE (default_conversion_strategy_var, + "%default-port-conversion-strategy"); - for (; scm_is_pair (ports); ports = scm_cdr (ports)) +/* Whether the above fluid is initialized. */ +static int scm_conversion_strategy_init = 0; + +/* The possible conversion strategies. */ +SCM_SYMBOL (sym_error, "error"); +SCM_SYMBOL (sym_substitute, "substitute"); +SCM_SYMBOL (sym_escape, "escape"); + +/* Return the default failed encoding conversion policy for new created + ports. */ +scm_t_string_failed_conversion_handler +scm_i_default_port_conversion_handler (void) +{ + scm_t_string_failed_conversion_handler handler; + + if (!scm_conversion_strategy_init + || !scm_is_fluid (SCM_VARIABLE_REF (default_conversion_strategy_var))) + handler = SCM_FAILED_CONVERSION_QUESTION_MARK; + else { - SCM p = scm_car (ports); - if (SCM_PORTP (p)) - proc (data, p); + SCM fluid, value; + + fluid = SCM_VARIABLE_REF (default_conversion_strategy_var); + value = scm_fluid_ref (fluid); + + if (scm_is_eq (sym_substitute, value)) + handler = SCM_FAILED_CONVERSION_QUESTION_MARK; + else if (scm_is_eq (sym_escape, value)) + handler = SCM_FAILED_CONVERSION_ESCAPE_SEQUENCE; + else + /* Default to 'error also when the fluid's value is not one of + the valid symbols. */ + handler = SCM_FAILED_CONVERSION_ERROR; } + + return handler; } -SCM_DEFINE (scm_port_for_each, "port-for-each", 1, 0, 0, - (SCM proc), - "Apply @var{proc} to each port in the Guile port table\n" - "in turn. The return value is unspecified. More specifically,\n" - "@var{proc} is applied exactly once to every port that exists\n" - "in the system at the time @code{port-for-each} is invoked.\n" - "Changes to the port table while @code{port-for-each} is running\n" - "have no effect as far as @code{port-for-each} is concerned.") -#define FUNC_NAME s_scm_port_for_each +/* Use HANDLER as the default conversion strategy for future ports. */ +void +scm_i_set_default_port_conversion_handler (scm_t_string_failed_conversion_handler + handler) { - SCM ports; + SCM strategy; - SCM_VALIDATE_PROC (1, proc); + if (!scm_conversion_strategy_init + || !scm_is_fluid (SCM_VARIABLE_REF (default_conversion_strategy_var))) + scm_misc_error (NULL, "tried to set conversion strategy fluid before it is initialized", + SCM_EOL); - /* Copy out the port table as a list so that we get strong references - to all the values. */ - scm_i_pthread_mutex_lock (&scm_i_port_table_mutex); - ports = scm_internal_hash_fold (collect_keys, NULL, - SCM_EOL, scm_i_port_weak_hash); - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); + switch (handler) + { + case SCM_FAILED_CONVERSION_ERROR: + strategy = sym_error; + break; - for (; scm_is_pair (ports); ports = scm_cdr (ports)) - if (SCM_PORTP (SCM_CAR (ports))) - scm_call_1 (proc, SCM_CAR (ports)); + case SCM_FAILED_CONVERSION_ESCAPE_SEQUENCE: + strategy = sym_escape; + break; - return SCM_UNSPECIFIED; + case SCM_FAILED_CONVERSION_QUESTION_MARK: + strategy = sym_substitute; + break; + + default: + abort (); + } + + scm_fluid_set_x (SCM_VARIABLE_REF (default_conversion_strategy_var), + strategy); } -#undef FUNC_NAME +static void +finalize_iconv_descriptors (void *ptr, void *data) +{ + close_iconv_descriptors (ptr); +} - -/* Utter miscellany. Gosh, we should clean this up some time. */ +static scm_t_iconv_descriptors * +open_iconv_descriptors (const char *encoding, int reading, int writing) +{ + scm_t_iconv_descriptors *id; + iconv_t input_cd, output_cd; + size_t i; -SCM_DEFINE (scm_input_port_p, "input-port?", 1, 0, 0, - (SCM x), - "Return @code{#t} if @var{x} is an input port, otherwise return\n" - "@code{#f}. Any object satisfying this predicate also satisfies\n" - "@code{port?}.") -#define FUNC_NAME s_scm_input_port_p + input_cd = (iconv_t) -1; + output_cd = (iconv_t) -1; + + for (i = 0; encoding[i]; i++) + if (encoding[i] > 127) + goto invalid_encoding; + + if (reading) + { + /* Open an input iconv conversion descriptor, from ENCODING + to UTF-8. We choose UTF-8, not UTF-32, because iconv + implementations can typically convert from anything to + UTF-8, but not to UTF-32 (see + <http://lists.gnu.org/archive/html/bug-libunistring/2010-09/msg00007.html>). */ + + /* Assume opening an iconv descriptor causes about 16 KB of + allocation. */ + scm_gc_register_allocation (16 * 1024); + + input_cd = iconv_open ("UTF-8", encoding); + if (input_cd == (iconv_t) -1) + goto invalid_encoding; + } + + if (writing) + { + /* Assume opening an iconv descriptor causes about 16 KB of + allocation. */ + scm_gc_register_allocation (16 * 1024); + + output_cd = iconv_open (encoding, "UTF-8"); + if (output_cd == (iconv_t) -1) + { + if (input_cd != (iconv_t) -1) + iconv_close (input_cd); + goto invalid_encoding; + } + } + + id = scm_gc_malloc_pointerless (sizeof (*id), "iconv descriptors"); + id->input_cd = input_cd; + id->output_cd = output_cd; + + /* Register a finalizer to close the descriptors. */ + scm_i_set_finalizer (id, finalize_iconv_descriptors, NULL); + + return id; + + invalid_encoding: + { + SCM err; + err = scm_from_latin1_string (encoding); + scm_misc_error ("open_iconv_descriptors", + "invalid or unknown character encoding ~s", + scm_list_1 (err)); + } +} + +static void +close_iconv_descriptors (scm_t_iconv_descriptors *id) { - return scm_from_bool (SCM_INPUT_PORT_P (x)); + if (id->input_cd != (iconv_t) -1) + iconv_close (id->input_cd); + if (id->output_cd != (iconv_t) -1) + iconv_close (id->output_cd); + id->input_cd = (void *) -1; + id->output_cd = (void *) -1; } -#undef FUNC_NAME -SCM_DEFINE (scm_output_port_p, "output-port?", 1, 0, 0, - (SCM x), - "Return @code{#t} if @var{x} is an output port, otherwise return\n" - "@code{#f}. Any object satisfying this predicate also satisfies\n" - "@code{port?}.") -#define FUNC_NAME s_scm_output_port_p +scm_t_iconv_descriptors * +scm_i_port_iconv_descriptors (SCM port) { - x = SCM_COERCE_OUTPORT (x); - return scm_from_bool (SCM_OUTPUT_PORT_P (x)); + scm_t_port *pt; + + pt = SCM_PTAB_ENTRY (port); + + assert (pt->encoding_mode == SCM_PORT_ENCODING_MODE_ICONV); + + if (!pt->iconv_descriptors) + { + if (!pt->encoding) + pt->encoding = "ISO-8859-1"; + pt->iconv_descriptors = + open_iconv_descriptors (pt->encoding, + SCM_INPUT_PORT_P (port), + SCM_OUTPUT_PORT_P (port)); + } + + return pt->iconv_descriptors; } -#undef FUNC_NAME -SCM_DEFINE (scm_port_p, "port?", 1, 0, 0, - (SCM x), - "Return a boolean indicating whether @var{x} is a port.\n" - "Equivalent to @code{(or (input-port? @var{x}) (output-port?\n" - "@var{x}))}.") -#define FUNC_NAME s_scm_port_p +/* The name of the encoding is itself encoded in ASCII. */ +void +scm_i_set_port_encoding_x (SCM port, const char *encoding) { - return scm_from_bool (SCM_PORTP (x)); + scm_t_port *pt; + scm_t_iconv_descriptors *prev; + + /* Set the character encoding for this port. */ + pt = SCM_PTAB_ENTRY (port); + prev = pt->iconv_descriptors; + + if (encoding_matches (encoding, "UTF-8")) + { + pt->encoding = "UTF-8"; + pt->encoding_mode = SCM_PORT_ENCODING_MODE_UTF8; + pt->iconv_descriptors = NULL; + } + else if (encoding_matches (encoding, "ISO-8859-1")) + { + pt->encoding = "ISO-8859-1"; + pt->encoding_mode = SCM_PORT_ENCODING_MODE_LATIN1; + pt->iconv_descriptors = NULL; + } + else + { + /* Open descriptors before mutating the port. */ + char *gc_encoding = canonicalize_encoding (encoding); + pt->iconv_descriptors = + open_iconv_descriptors (gc_encoding, + SCM_INPUT_PORT_P (port), + SCM_OUTPUT_PORT_P (port)); + pt->encoding = gc_encoding; + pt->encoding_mode = SCM_PORT_ENCODING_MODE_ICONV; + } + + if (prev) + close_iconv_descriptors (prev); +} + +SCM_DEFINE (scm_port_encoding, "port-encoding", 1, 0, 0, + (SCM port), + "Returns, as a string, the character encoding that @var{port}\n" + "uses to interpret its input and output.\n") +#define FUNC_NAME s_scm_port_encoding +{ + SCM_VALIDATE_PORT (1, port); + + return scm_from_latin1_string (SCM_PTAB_ENTRY (port)->encoding); } #undef FUNC_NAME -SCM_DEFINE (scm_port_closed_p, "port-closed?", 1, 0, 0, - (SCM port), - "Return @code{#t} if @var{port} is closed or @code{#f} if it is\n" - "open.") -#define FUNC_NAME s_scm_port_closed_p +SCM_DEFINE (scm_set_port_encoding_x, "set-port-encoding!", 2, 0, 0, + (SCM port, SCM enc), + "Sets the character encoding that will be used to interpret all\n" + "port I/O. New ports are created with the encoding\n" + "appropriate for the current locale if @code{setlocale} has \n" + "been called or ISO-8859-1 otherwise\n" + "and this procedure can be used to modify that encoding.\n") +#define FUNC_NAME s_scm_set_port_encoding_x { + char *enc_str; + SCM_VALIDATE_PORT (1, port); - return scm_from_bool (!SCM_OPPORTP (port)); + SCM_VALIDATE_STRING (2, enc); + + enc_str = scm_to_latin1_string (enc); + scm_i_set_port_encoding_x (port, enc_str); + free (enc_str); + + return SCM_UNSPECIFIED; } #undef FUNC_NAME -SCM_DEFINE (scm_eof_object_p, "eof-object?", 1, 0, 0, - (SCM x), - "Return @code{#t} if @var{x} is an end-of-file object; otherwise\n" - "return @code{#f}.") -#define FUNC_NAME s_scm_eof_object_p +SCM_DEFINE (scm_port_conversion_strategy, "port-conversion-strategy", + 1, 0, 0, (SCM port), + "Returns the behavior of the port when handling a character that\n" + "is not representable in the port's current encoding.\n" + "It returns the symbol @code{error} if unrepresentable characters\n" + "should cause exceptions, @code{substitute} if the port should\n" + "try to replace unrepresentable characters with question marks or\n" + "approximate characters, or @code{escape} if unrepresentable\n" + "characters should be converted to string escapes.\n" + "\n" + "If @var{port} is @code{#f}, then the current default behavior\n" + "will be returned. New ports will have this default behavior\n" + "when they are created.\n") +#define FUNC_NAME s_scm_port_conversion_strategy { - return scm_from_bool(SCM_EOF_OBJECT_P (x)); + scm_t_string_failed_conversion_handler h; + + SCM_VALIDATE_OPPORT (1, port); + + if (scm_is_false (port)) + h = scm_i_default_port_conversion_handler (); + else + { + scm_t_port *pt; + + SCM_VALIDATE_OPPORT (1, port); + pt = SCM_PTAB_ENTRY (port); + + h = pt->ilseq_handler; + } + + if (h == SCM_FAILED_CONVERSION_ERROR) + return scm_from_latin1_symbol ("error"); + else if (h == SCM_FAILED_CONVERSION_QUESTION_MARK) + return scm_from_latin1_symbol ("substitute"); + else if (h == SCM_FAILED_CONVERSION_ESCAPE_SEQUENCE) + return scm_from_latin1_symbol ("escape"); + else + abort (); + + /* Never gets here. */ + return SCM_UNDEFINED; } #undef FUNC_NAME -SCM_DEFINE (scm_force_output, "force-output", 0, 1, 0, - (SCM port), - "Flush the specified output port, or the current output port if @var{port}\n" - "is omitted. The current output buffer contents are passed to the\n" - "underlying port implementation (e.g., in the case of fports, the\n" - "data will be written to the file and the output buffer will be cleared.)\n" - "It has no effect on an unbuffered port.\n\n" - "The return value is unspecified.") -#define FUNC_NAME s_scm_force_output +SCM_DEFINE (scm_set_port_conversion_strategy_x, "set-port-conversion-strategy!", + 2, 0, 0, + (SCM port, SCM sym), + "Sets the behavior of the interpreter when outputting a character\n" + "that is not representable in the port's current encoding.\n" + "@var{sym} can be either @code{'error}, @code{'substitute}, or\n" + "@code{'escape}. If it is @code{'error}, an error will be thrown\n" + "when an unconvertible character is encountered. If it is\n" + "@code{'substitute}, then unconvertible characters will \n" + "be replaced with approximate characters, or with question marks\n" + "if no approximately correct character is available.\n" + "If it is @code{'escape},\n" + "it will appear as a hex escape when output.\n" + "\n" + "If @var{port} is an open port, the conversion error behavior\n" + "is set for that port. If it is @code{#f}, it is set as the\n" + "default behavior for any future ports that get created in\n" + "this thread.\n") +#define FUNC_NAME s_scm_set_port_conversion_strategy_x { - if (SCM_UNBNDP (port)) - port = scm_current_output_port (); + scm_t_string_failed_conversion_handler handler; + + if (scm_is_eq (sym, sym_error)) + handler = SCM_FAILED_CONVERSION_ERROR; + else if (scm_is_eq (sym, sym_substitute)) + handler = SCM_FAILED_CONVERSION_QUESTION_MARK; + else if (scm_is_eq (sym, sym_escape)) + handler = SCM_FAILED_CONVERSION_ESCAPE_SEQUENCE; + else + SCM_MISC_ERROR ("unknown conversion strategy ~s", scm_list_1 (sym)); + + if (scm_is_false (port)) + scm_i_set_default_port_conversion_handler (handler); else { - port = SCM_COERCE_OUTPORT (port); - SCM_VALIDATE_OPOUTPORT (1, port); + SCM_VALIDATE_OPPORT (1, port); + SCM_PTAB_ENTRY (port)->ilseq_handler = handler; } - scm_flush (port); + return SCM_UNSPECIFIED; } #undef FUNC_NAME + + +/* The port lock. */ + static void -flush_output_port (void *closure, SCM port) +lock_port (void *mutex) { - if (SCM_OPOUTPORTP (port)) - scm_flush (port); + scm_i_pthread_mutex_lock (mutex); } -SCM_DEFINE (scm_flush_all_ports, "flush-all-ports", 0, 0, 0, - (), - "Equivalent to calling @code{force-output} on\n" - "all open output ports. The return value is unspecified.") -#define FUNC_NAME s_scm_flush_all_ports +static void +unlock_port (void *mutex) { - scm_c_port_for_each (&flush_output_port, NULL); - return SCM_UNSPECIFIED; + scm_i_pthread_mutex_unlock (mutex); +} + +void +scm_dynwind_lock_port (SCM port) +#define FUNC_NAME "dynwind-lock-port" +{ + scm_i_pthread_mutex_t *lock; + SCM_VALIDATE_OPPORT (SCM_ARG1, port); + scm_c_lock_port (port, &lock); + if (lock) + { + scm_dynwind_unwind_handler (unlock_port, lock, SCM_F_WIND_EXPLICITLY); + scm_dynwind_rewind_handler (lock_port, lock, 0); + } } #undef FUNC_NAME -SCM_DEFINE (scm_read_char, "read-char", 0, 1, 0, - (SCM port), - "Return the next character available from @var{port}, updating\n" - "@var{port} to point to the following character. If no more\n" - "characters are available, the end-of-file object is returned.\n" - "\n" - "When @var{port}'s data cannot be decoded according to its\n" - "character encoding, a @code{decoding-error} is raised and\n" - "@var{port} points past the erroneous byte sequence.\n") -#define FUNC_NAME s_scm_read_char + + + +/* Input. */ + +int +scm_get_byte_or_eof (SCM port) { - scm_t_wchar c; - if (SCM_UNBNDP (port)) - port = scm_current_input_port (); + scm_i_pthread_mutex_t *lock; + int ret; + + scm_c_lock_port (port, &lock); + ret = scm_get_byte_or_eof_unlocked (port); + if (lock) + scm_i_pthread_mutex_unlock (lock); + + return ret; +} + +int +scm_peek_byte_or_eof (SCM port) +{ + scm_i_pthread_mutex_t *lock; + int ret; + + scm_c_lock_port (port, &lock); + ret = scm_peek_byte_or_eof_unlocked (port); + if (lock) + scm_i_pthread_mutex_unlock (lock); + + return ret; +} + +/* scm_c_read + * + * Used by an application to read arbitrary number of bytes from an + * SCM port. Same semantics as libc read, except that scm_c_read only + * returns less than SIZE bytes if at end-of-file. + * + * Warning: Doesn't update port line and column counts! */ + +/* This structure, and the following swap_buffer function, are used + for temporarily swapping a port's own read buffer, and the buffer + that the caller of scm_c_read provides. */ +struct port_and_swap_buffer +{ + scm_t_port *pt; + unsigned char *buffer; + size_t size; +}; + +static void +swap_buffer (void *data) +{ + struct port_and_swap_buffer *psb = (struct port_and_swap_buffer *) data; + unsigned char *old_buf = psb->pt->read_buf; + size_t old_size = psb->pt->read_buf_size; + + /* Make the port use (buffer, size) from the struct. */ + psb->pt->read_pos = psb->pt->read_buf = psb->pt->read_end = psb->buffer; + psb->pt->read_buf_size = psb->size; + + /* Save the port's old (buffer, size) in the struct. */ + psb->buffer = old_buf; + psb->size = old_size; +} + +size_t +scm_c_read_unlocked (SCM port, void *buffer, size_t size) +#define FUNC_NAME "scm_c_read" +{ + scm_t_port *pt; + size_t n_read = 0, n_available; + struct port_and_swap_buffer psb; + SCM_VALIDATE_OPINPORT (1, port); - c = scm_getc (port); - if (EOF == c) - return SCM_EOF_VAL; - return SCM_MAKE_CHAR (c); + + pt = SCM_PTAB_ENTRY (port); + if (pt->rw_active == SCM_PORT_WRITE) + SCM_PORT_DESCRIPTOR (port)->flush (port); + + if (pt->rw_random) + pt->rw_active = SCM_PORT_READ; + + /* Take bytes first from the port's read buffer. */ + if (pt->read_pos < pt->read_end) + { + n_available = min (size, pt->read_end - pt->read_pos); + memcpy (buffer, pt->read_pos, n_available); + buffer = (char *) buffer + n_available; + pt->read_pos += n_available; + n_read += n_available; + size -= n_available; + } + + /* Avoid the scm_dynwind_* costs if we now have enough data. */ + if (size == 0) + return n_read; + + /* Now we will call scm_fill_input repeatedly until we have read the + requested number of bytes. (Note that a single scm_fill_input + call does not guarantee to fill the whole of the port's read + buffer.) */ + if (pt->read_buf_size <= 1 + && pt->encoding_mode == SCM_PORT_ENCODING_MODE_LATIN1) + { + /* The port that we are reading from is unbuffered - i.e. does + not have its own persistent buffer - but we have a buffer, + provided by our caller, that is the right size for the data + that is wanted. For the following scm_fill_input calls, + therefore, we use the buffer in hand as the port's read + buffer. + + We need to make sure that the port's normal (1 byte) buffer + is reinstated in case one of the scm_fill_input () calls + throws an exception; we use the scm_dynwind_* API to achieve + that. + + A consequence of this optimization is that the fill_input + functions can't unget characters. That'll push data to the + pushback buffer instead of this psb buffer. */ +#if SCM_DEBUG == 1 + unsigned char *pback = pt->putback_buf; +#endif + psb.pt = pt; + psb.buffer = buffer; + psb.size = size; + scm_dynwind_begin (SCM_F_DYNWIND_REWINDABLE); + scm_dynwind_rewind_handler (swap_buffer, &psb, SCM_F_WIND_EXPLICITLY); + scm_dynwind_unwind_handler (swap_buffer, &psb, SCM_F_WIND_EXPLICITLY); + + /* Call scm_fill_input until we have all the bytes that we need, + or we hit EOF. */ + while (pt->read_buf_size && (scm_fill_input_unlocked (port) != EOF)) + { + pt->read_buf_size -= (pt->read_end - pt->read_pos); + pt->read_pos = pt->read_buf = pt->read_end; + } +#if SCM_DEBUG == 1 + if (pback != pt->putback_buf + || pt->read_buf - (unsigned char *) buffer < 0) + scm_misc_error (FUNC_NAME, + "scm_c_read must not call a fill function that pushes " + "back characters onto an unbuffered port", SCM_EOL); +#endif + n_read += pt->read_buf - (unsigned char *) buffer; + + /* Reinstate the port's normal buffer. */ + scm_dynwind_end (); + } + else + { + /* The port has its own buffer. It is important that we use it, + even if it happens to be smaller than our caller's buffer, so + that a custom port implementation's entry points (in + particular, fill_input) can rely on the buffer always being + the same as they first set up. */ + while (size && (scm_fill_input_unlocked (port) != EOF)) + { + n_available = min (size, pt->read_end - pt->read_pos); + memcpy (buffer, pt->read_pos, n_available); + buffer = (char *) buffer + n_available; + pt->read_pos += n_available; + n_read += n_available; + size -= n_available; + } + } + + return n_read; } #undef FUNC_NAME +size_t +scm_c_read (SCM port, void *buffer, size_t size) +{ + scm_i_pthread_mutex_t *lock; + size_t ret; + + scm_c_lock_port (port, &lock); + ret = scm_c_read_unlocked (port, buffer, size); + if (lock) + scm_i_pthread_mutex_unlock (lock); + + + return ret; +} + /* Update the line and column number of PORT after consumption of C. */ static inline void update_port_lf (scm_t_wchar c, SCM port) @@ -1171,7 +1540,7 @@ get_utf8_codepoint (SCM port, scm_t_wchar *codepoint, *len = 0; pt = SCM_PTAB_ENTRY (port); - byte = scm_get_byte_or_eof (port); + byte = scm_get_byte_or_eof_unlocked (port); if (byte == EOF) { *codepoint = EOF; @@ -1187,7 +1556,7 @@ get_utf8_codepoint (SCM port, scm_t_wchar *codepoint, else if (buf[0] >= 0xc2 && buf[0] <= 0xdf) { /* 2-byte form. */ - byte = scm_peek_byte_or_eof (port); + byte = scm_peek_byte_or_eof_unlocked (port); ASSERT_NOT_EOF (byte); if (SCM_UNLIKELY ((byte & 0xc0) != 0x80)) @@ -1203,7 +1572,7 @@ get_utf8_codepoint (SCM port, scm_t_wchar *codepoint, else if ((buf[0] & 0xf0) == 0xe0) { /* 3-byte form. */ - byte = scm_peek_byte_or_eof (port); + byte = scm_peek_byte_or_eof_unlocked (port); ASSERT_NOT_EOF (byte); if (SCM_UNLIKELY ((byte & 0xc0) != 0x80 @@ -1215,7 +1584,7 @@ get_utf8_codepoint (SCM port, scm_t_wchar *codepoint, buf[1] = (scm_t_uint8) byte; *len = 2; - byte = scm_peek_byte_or_eof (port); + byte = scm_peek_byte_or_eof_unlocked (port); ASSERT_NOT_EOF (byte); if (SCM_UNLIKELY ((byte & 0xc0) != 0x80)) @@ -1232,7 +1601,7 @@ get_utf8_codepoint (SCM port, scm_t_wchar *codepoint, else if (buf[0] >= 0xf0 && buf[0] <= 0xf4) { /* 4-byte form. */ - byte = scm_peek_byte_or_eof (port); + byte = scm_peek_byte_or_eof_unlocked (port); ASSERT_NOT_EOF (byte); if (SCM_UNLIKELY (((byte & 0xc0) != 0x80) @@ -1244,7 +1613,7 @@ get_utf8_codepoint (SCM port, scm_t_wchar *codepoint, buf[1] = (scm_t_uint8) byte; *len = 2; - byte = scm_peek_byte_or_eof (port); + byte = scm_peek_byte_or_eof_unlocked (port); ASSERT_NOT_EOF (byte); if (SCM_UNLIKELY ((byte & 0xc0) != 0x80)) @@ -1254,7 +1623,7 @@ get_utf8_codepoint (SCM port, scm_t_wchar *codepoint, buf[2] = (scm_t_uint8) byte; *len = 3; - byte = scm_peek_byte_or_eof (port); + byte = scm_peek_byte_or_eof_unlocked (port); ASSERT_NOT_EOF (byte); if (SCM_UNLIKELY ((byte & 0xc0) != 0x80)) @@ -1286,19 +1655,39 @@ get_utf8_codepoint (SCM port, scm_t_wchar *codepoint, #undef ASSERT_NOT_EOF } +/* Read an ISO-8859-1 codepoint (a byte) from PORT. On success, return + 0 and set *CODEPOINT to the codepoint that was read, fill BUF with + its UTF-8 representation, and set *LEN to the length in bytes. + Return `EILSEQ' on error. */ +static int +get_latin1_codepoint (SCM port, scm_t_wchar *codepoint, + char buf[SCM_MBCHAR_BUF_SIZE], size_t *len) +{ + *codepoint = scm_get_byte_or_eof_unlocked (port); + + if (*codepoint == EOF) + *len = 0; + else + { + *len = 1; + buf[0] = *codepoint; + } + return 0; +} + /* Likewise, read a byte sequence from PORT, passing it through its input conversion descriptor. */ static int get_iconv_codepoint (SCM port, scm_t_wchar *codepoint, char buf[SCM_MBCHAR_BUF_SIZE], size_t *len) { - scm_t_port *pt; + scm_t_iconv_descriptors *id; int err, byte_read; size_t bytes_consumed, output_size; char *output; scm_t_uint8 utf8_buf[SCM_MBCHAR_BUF_SIZE]; - pt = SCM_PTAB_ENTRY (port); + id = scm_i_port_iconv_descriptors (port); for (output_size = 0, output = (char *) utf8_buf, bytes_consumed = 0, err = 0; @@ -1309,7 +1698,7 @@ get_iconv_codepoint (SCM port, scm_t_wchar *codepoint, char *input; size_t input_left, output_left, done; - byte_read = scm_get_byte_or_eof (port); + byte_read = scm_get_byte_or_eof_unlocked (port); if (byte_read == EOF) { if (bytes_consumed == 0) @@ -1328,8 +1717,7 @@ get_iconv_codepoint (SCM port, scm_t_wchar *codepoint, input_left = bytes_consumed + 1; output_left = sizeof (utf8_buf); - done = iconv (pt->input_cd, &input, &input_left, - &output, &output_left); + done = iconv (id->input_cd, &input, &input_left, &output, &output_left); if (done == (size_t) -1) { err = errno; @@ -1358,20 +1746,17 @@ get_iconv_codepoint (SCM port, scm_t_wchar *codepoint, with the byte representation of the codepoint in PORT's encoding, and set *LEN to the length in bytes of that representation. Return 0 on success and an errno value on error. */ -static int +static SCM_C_INLINE int get_codepoint (SCM port, scm_t_wchar *codepoint, char buf[SCM_MBCHAR_BUF_SIZE], size_t *len) { int err; scm_t_port *pt = SCM_PTAB_ENTRY (port); - if (pt->input_cd == (iconv_t) -1) - /* Initialize the conversion descriptors, if needed. */ - scm_i_set_port_encoding_x (port, pt->encoding); - - /* FIXME: In 2.1, add a flag to determine whether a port is UTF-8. */ - if (pt->input_cd == (iconv_t) -1) + if (pt->encoding_mode == SCM_PORT_ENCODING_MODE_UTF8) err = get_utf8_codepoint (port, codepoint, (scm_t_uint8 *) buf, len); + else if (pt->encoding_mode == SCM_PORT_ENCODING_MODE_LATIN1) + err = get_latin1_codepoint (port, codepoint, buf, len); else err = get_iconv_codepoint (port, codepoint, buf, len); @@ -1389,7 +1774,7 @@ get_codepoint (SCM port, scm_t_wchar *codepoint, /* Read a codepoint from PORT and return it. */ scm_t_wchar -scm_getc (SCM port) +scm_getc_unlocked (SCM port) #define FUNC_NAME "scm_getc" { int err; @@ -1407,274 +1792,50 @@ scm_getc (SCM port) } #undef FUNC_NAME -/* this should only be called when the read buffer is empty. it - tries to refill the read buffer. it returns the first char from - the port, which is either EOF or *(pt->read_pos). */ -int -scm_fill_input (SCM port) -{ - scm_t_port *pt = SCM_PTAB_ENTRY (port); - - assert (pt->read_pos == pt->read_end); - - if (pt->read_buf == pt->putback_buf) - { - /* finished reading put-back chars. */ - pt->read_buf = pt->saved_read_buf; - pt->read_pos = pt->saved_read_pos; - pt->read_end = pt->saved_read_end; - pt->read_buf_size = pt->saved_read_buf_size; - if (pt->read_pos < pt->read_end) - return *(pt->read_pos); - } - return scm_ptobs[SCM_PTOBNUM (port)].fill_input (port); -} - - -/* scm_lfwrite - * - * This function differs from scm_c_write; it updates port line and - * column. */ - -void -scm_lfwrite (const char *ptr, size_t size, SCM port) -{ - scm_t_port *pt = SCM_PTAB_ENTRY (port); - scm_t_ptob_descriptor *ptob = &scm_ptobs[SCM_PTOBNUM (port)]; - - if (pt->rw_active == SCM_PORT_READ) - scm_end_input (port); - - ptob->write (port, ptr, size); - - for (; size; ptr++, size--) - update_port_lf ((scm_t_wchar) (unsigned char) *ptr, port); - - if (pt->rw_random) - pt->rw_active = SCM_PORT_WRITE; -} - -/* Write STR to PORT from START inclusive to END exclusive. */ -void -scm_lfwrite_substr (SCM str, size_t start, size_t end, SCM port) +scm_t_wchar +scm_getc (SCM port) { - scm_t_port *pt = SCM_PTAB_ENTRY (port); - - if (pt->rw_active == SCM_PORT_READ) - scm_end_input (port); - - if (end == (size_t) -1) - end = scm_i_string_length (str); + scm_i_pthread_mutex_t *lock; + scm_t_wchar ret; - scm_i_display_substring (str, start, end, port); + scm_c_lock_port (port, &lock); + ret = scm_getc_unlocked (port); + if (lock) + scm_i_pthread_mutex_unlock (lock); + - if (pt->rw_random) - pt->rw_active = SCM_PORT_WRITE; + return ret; } -/* scm_c_read - * - * Used by an application to read arbitrary number of bytes from an - * SCM port. Same semantics as libc read, except that scm_c_read only - * returns less than SIZE bytes if at end-of-file. - * - * Warning: Doesn't update port line and column counts! */ - -/* This structure, and the following swap_buffer function, are used - for temporarily swapping a port's own read buffer, and the buffer - that the caller of scm_c_read provides. */ -struct port_and_swap_buffer -{ - scm_t_port *pt; - unsigned char *buffer; - size_t size; -}; - -static void -swap_buffer (void *data) -{ - struct port_and_swap_buffer *psb = (struct port_and_swap_buffer *) data; - unsigned char *old_buf = psb->pt->read_buf; - size_t old_size = psb->pt->read_buf_size; - - /* Make the port use (buffer, size) from the struct. */ - psb->pt->read_pos = psb->pt->read_buf = psb->pt->read_end = psb->buffer; - psb->pt->read_buf_size = psb->size; - - /* Save the port's old (buffer, size) in the struct. */ - psb->buffer = old_buf; - psb->size = old_size; -} - -size_t -scm_c_read (SCM port, void *buffer, size_t size) -#define FUNC_NAME "scm_c_read" +SCM_DEFINE (scm_read_char, "read-char", 0, 1, 0, + (SCM port), + "Return the next character available from @var{port}, updating\n" + "@var{port} to point to the following character. If no more\n" + "characters are available, the end-of-file object is returned.\n" + "\n" + "When @var{port}'s data cannot be decoded according to its\n" + "character encoding, a @code{decoding-error} is raised and\n" + "@var{port} points past the erroneous byte sequence.\n") +#define FUNC_NAME s_scm_read_char { - scm_t_port *pt; - size_t n_read = 0, n_available; - struct port_and_swap_buffer psb; - + scm_t_wchar c; + if (SCM_UNBNDP (port)) + port = scm_current_input_port (); SCM_VALIDATE_OPINPORT (1, port); - - pt = SCM_PTAB_ENTRY (port); - if (pt->rw_active == SCM_PORT_WRITE) - scm_ptobs[SCM_PTOBNUM (port)].flush (port); - - if (pt->rw_random) - pt->rw_active = SCM_PORT_READ; - - /* Take bytes first from the port's read buffer. */ - if (pt->read_pos < pt->read_end) - { - n_available = min (size, pt->read_end - pt->read_pos); - memcpy (buffer, pt->read_pos, n_available); - buffer = (char *) buffer + n_available; - pt->read_pos += n_available; - n_read += n_available; - size -= n_available; - } - - /* Avoid the scm_dynwind_* costs if we now have enough data. */ - if (size == 0) - return n_read; - - /* Now we will call scm_fill_input repeatedly until we have read the - requested number of bytes. (Note that a single scm_fill_input - call does not guarantee to fill the whole of the port's read - buffer.) */ - if (pt->read_buf_size <= 1 && pt->encoding == NULL) - { - /* The port that we are reading from is unbuffered - i.e. does - not have its own persistent buffer - but we have a buffer, - provided by our caller, that is the right size for the data - that is wanted. For the following scm_fill_input calls, - therefore, we use the buffer in hand as the port's read - buffer. - - We need to make sure that the port's normal (1 byte) buffer - is reinstated in case one of the scm_fill_input () calls - throws an exception; we use the scm_dynwind_* API to achieve - that. - - A consequence of this optimization is that the fill_input - functions can't unget characters. That'll push data to the - pushback buffer instead of this psb buffer. */ -#if SCM_DEBUG == 1 - unsigned char *pback = pt->putback_buf; -#endif - psb.pt = pt; - psb.buffer = buffer; - psb.size = size; - scm_dynwind_begin (SCM_F_DYNWIND_REWINDABLE); - scm_dynwind_rewind_handler (swap_buffer, &psb, SCM_F_WIND_EXPLICITLY); - scm_dynwind_unwind_handler (swap_buffer, &psb, SCM_F_WIND_EXPLICITLY); - - /* Call scm_fill_input until we have all the bytes that we need, - or we hit EOF. */ - while (pt->read_buf_size && (scm_fill_input (port) != EOF)) - { - pt->read_buf_size -= (pt->read_end - pt->read_pos); - pt->read_pos = pt->read_buf = pt->read_end; - } -#if SCM_DEBUG == 1 - if (pback != pt->putback_buf - || pt->read_buf - (unsigned char *) buffer < 0) - scm_misc_error (FUNC_NAME, - "scm_c_read must not call a fill function that pushes " - "back characters onto an unbuffered port", SCM_EOL); -#endif - n_read += pt->read_buf - (unsigned char *) buffer; - - /* Reinstate the port's normal buffer. */ - scm_dynwind_end (); - } - else - { - /* The port has its own buffer. It is important that we use it, - even if it happens to be smaller than our caller's buffer, so - that a custom port implementation's entry points (in - particular, fill_input) can rely on the buffer always being - the same as they first set up. */ - while (size && (scm_fill_input (port) != EOF)) - { - n_available = min (size, pt->read_end - pt->read_pos); - memcpy (buffer, pt->read_pos, n_available); - buffer = (char *) buffer + n_available; - pt->read_pos += n_available; - n_read += n_available; - size -= n_available; - } - } - - return n_read; -} -#undef FUNC_NAME - -/* scm_c_write - * - * Used by an application to write arbitrary number of bytes to an SCM - * port. Similar semantics as libc write. However, unlike libc - * write, scm_c_write writes the requested number of bytes and has no - * return value. - * - * Warning: Doesn't update port line and column counts! - */ - -void -scm_c_write (SCM port, const void *ptr, size_t size) -#define FUNC_NAME "scm_c_write" -{ - scm_t_port *pt; - scm_t_ptob_descriptor *ptob; - - SCM_VALIDATE_OPOUTPORT (1, port); - - pt = SCM_PTAB_ENTRY (port); - ptob = &scm_ptobs[SCM_PTOBNUM (port)]; - - if (pt->rw_active == SCM_PORT_READ) - scm_end_input (port); - - ptob->write (port, ptr, size); - - if (pt->rw_random) - pt->rw_active = SCM_PORT_WRITE; + c = scm_getc_unlocked (port); + if (EOF == c) + return SCM_EOF_VAL; + return SCM_MAKE_CHAR (c); } #undef FUNC_NAME -void -scm_flush (SCM port) -{ - long i = SCM_PTOBNUM (port); - assert (i >= 0); - (scm_ptobs[i].flush) (port); -} - -void -scm_end_input (SCM port) -{ - long offset; - scm_t_port *pt = SCM_PTAB_ENTRY (port); - - if (pt->read_buf == pt->putback_buf) - { - offset = pt->read_end - pt->read_pos; - pt->read_buf = pt->saved_read_buf; - pt->read_pos = pt->saved_read_pos; - pt->read_end = pt->saved_read_end; - pt->read_buf_size = pt->saved_read_buf_size; - } - else - offset = 0; - - scm_ptobs[SCM_PTOBNUM (port)].end_input (port, offset); -} +/* Pushback. */ void -scm_unget_byte (int c, SCM port) +scm_unget_byte_unlocked (int c, SCM port) #define FUNC_NAME "scm_unget_byte" { scm_t_port *pt = SCM_PTAB_ENTRY (port); @@ -1737,24 +1898,29 @@ scm_unget_byte (int c, SCM port) } #undef FUNC_NAME +void +scm_unget_byte (int c, SCM port) +{ + scm_i_pthread_mutex_t *lock; + scm_c_lock_port (port, &lock); + scm_unget_byte_unlocked (c, port); + if (lock) + scm_i_pthread_mutex_unlock (lock); + +} + void -scm_ungetc (scm_t_wchar c, SCM port) +scm_ungetc_unlocked (scm_t_wchar c, SCM port) #define FUNC_NAME "scm_ungetc" { scm_t_port *pt = SCM_PTAB_ENTRY (port); char *result; char result_buf[10]; - const char *encoding; size_t len; int i; - if (pt->encoding != NULL) - encoding = pt->encoding; - else - encoding = "ISO-8859-1"; - len = sizeof (result_buf); - result = u32_conv_to_encoding (encoding, + result = u32_conv_to_encoding (pt->encoding, (enum iconv_ilseq_handler) pt->ilseq_handler, (uint32_t *) &c, 1, NULL, result_buf, &len); @@ -1765,7 +1931,7 @@ scm_ungetc (scm_t_wchar c, SCM port) SCM_BOOL_F, SCM_MAKE_CHAR (c)); for (i = len - 1; i >= 0; i--) - scm_unget_byte (result[i], port); + scm_unget_byte_unlocked (result[i], port); if (SCM_UNLIKELY (result != result_buf)) free (result); @@ -1782,9 +1948,19 @@ scm_ungetc (scm_t_wchar c, SCM port) } #undef FUNC_NAME +void +scm_ungetc (scm_t_wchar c, SCM port) +{ + scm_i_pthread_mutex_t *lock; + scm_c_lock_port (port, &lock); + scm_ungetc_unlocked (c, port); + if (lock) + scm_i_pthread_mutex_unlock (lock); + +} void -scm_ungets (const char *s, int n, SCM port) +scm_ungets_unlocked (const char *s, int n, SCM port) { /* This is simple minded and inefficient, but unreading strings is * probably not a common operation, and remember that line and @@ -1793,9 +1969,19 @@ scm_ungets (const char *s, int n, SCM port) * Please feel free to write an optimized version! */ while (n--) - scm_ungetc (s[n], port); + scm_ungetc_unlocked (s[n], port); } +void +scm_ungets (const char *s, int n, SCM port) +{ + scm_i_pthread_mutex_t *lock; + scm_c_lock_port (port, &lock); + scm_ungets_unlocked (s, n, port); + if (lock) + scm_i_pthread_mutex_unlock (lock); + +} SCM_DEFINE (scm_peek_char, "peek-char", 0, 1, 0, (SCM port), @@ -1837,7 +2023,7 @@ SCM_DEFINE (scm_peek_char, "peek-char", 0, 1, 0, err = get_codepoint (port, &c, bytes, &len); for (i = len - 1; i >= 0; i--) - scm_unget_byte (bytes[i], port); + scm_unget_byte_unlocked (bytes[i], port); SCM_COL (port) = column; SCM_LINUM (port) = line; @@ -1876,7 +2062,7 @@ SCM_DEFINE (scm_unread_char, "unread-char", 1, 1, 0, c = SCM_CHAR (cobj); - scm_ungetc (c, port); + scm_ungetc_unlocked (c, port); return cobj; } #undef FUNC_NAME @@ -1898,12 +2084,384 @@ SCM_DEFINE (scm_unread_string, "unread-string", 2, 0, 0, n = scm_i_string_length (str); while (n--) - scm_ungetc (scm_i_string_ref (str, n), port); + scm_ungetc_unlocked (scm_i_string_ref (str, n), port); return str; } #undef FUNC_NAME + + + +/* Manipulating the buffers. */ + +/* This routine does not take any locks, as it is usually called as part + of a port implementation. */ +void +scm_port_non_buffer (scm_t_port *pt) +{ + pt->read_pos = pt->read_buf = pt->read_end = &pt->shortbuf; + pt->write_buf = pt->write_pos = &pt->shortbuf; + pt->read_buf_size = pt->write_buf_size = 1; + pt->write_end = pt->write_buf + pt->write_buf_size; +} + +/* this should only be called when the read buffer is empty. it + tries to refill the read buffer. it returns the first char from + the port, which is either EOF or *(pt->read_pos). */ +int +scm_fill_input_unlocked (SCM port) +{ + scm_t_port *pt = SCM_PTAB_ENTRY (port); + + assert (pt->read_pos == pt->read_end); + + if (pt->read_buf == pt->putback_buf) + { + /* finished reading put-back chars. */ + pt->read_buf = pt->saved_read_buf; + pt->read_pos = pt->saved_read_pos; + pt->read_end = pt->saved_read_end; + pt->read_buf_size = pt->saved_read_buf_size; + if (pt->read_pos < pt->read_end) + return *(pt->read_pos); + } + return SCM_PORT_DESCRIPTOR (port)->fill_input (port); +} + +int +scm_fill_input (SCM port) +{ + scm_i_pthread_mutex_t *lock; + int ret; + + scm_c_lock_port (port, &lock); + ret = scm_fill_input_unlocked (port); + if (lock) + scm_i_pthread_mutex_unlock (lock); + + + return ret; +} + +/* Move up to READ_LEN bytes from PORT's putback and/or read buffers + into memory starting at DEST. Return the number of bytes moved. + PORT's line/column numbers are left unchanged. */ +size_t +scm_take_from_input_buffers (SCM port, char *dest, size_t read_len) +{ + scm_t_port *pt = SCM_PTAB_ENTRY (port); + size_t bytes_read = 0; + size_t from_buf = min (pt->read_end - pt->read_pos, read_len); + + if (from_buf > 0) + { + memcpy (dest, pt->read_pos, from_buf); + pt->read_pos += from_buf; + bytes_read += from_buf; + read_len -= from_buf; + dest += from_buf; + } + + /* if putback was active, try the real input buffer too. */ + if (pt->read_buf == pt->putback_buf) + { + from_buf = min (pt->saved_read_end - pt->saved_read_pos, read_len); + if (from_buf > 0) + { + memcpy (dest, pt->saved_read_pos, from_buf); + pt->saved_read_pos += from_buf; + bytes_read += from_buf; + } + } + + return bytes_read; +} + +/* Clear a port's read buffers, returning the contents. */ +SCM_DEFINE (scm_drain_input, "drain-input", 1, 0, 0, + (SCM port), + "This procedure clears a port's input buffers, similar\n" + "to the way that force-output clears the output buffer. The\n" + "contents of the buffers are returned as a single string, e.g.,\n" + "\n" + "@lisp\n" + "(define p (open-input-file ...))\n" + "(drain-input p) => empty string, nothing buffered yet.\n" + "(unread-char (read-char p) p)\n" + "(drain-input p) => initial chars from p, up to the buffer size.\n" + "@end lisp\n\n" + "Draining the buffers may be useful for cleanly finishing\n" + "buffered I/O so that the file descriptor can be used directly\n" + "for further input.") +#define FUNC_NAME s_scm_drain_input +{ + SCM result; + char *data; + scm_t_port *pt; + long count; + + SCM_VALIDATE_OPINPORT (1, port); + pt = SCM_PTAB_ENTRY (port); + + count = pt->read_end - pt->read_pos; + if (pt->read_buf == pt->putback_buf) + count += pt->saved_read_end - pt->saved_read_pos; + + if (count) + { + result = scm_i_make_string (count, &data, 0); + scm_take_from_input_buffers (port, data, count); + } + else + result = scm_nullstr; + + return result; +} +#undef FUNC_NAME + +void +scm_end_input_unlocked (SCM port) +{ + long offset; + scm_t_port *pt = SCM_PTAB_ENTRY (port); + + if (pt->read_buf == pt->putback_buf) + { + offset = pt->read_end - pt->read_pos; + pt->read_buf = pt->saved_read_buf; + pt->read_pos = pt->saved_read_pos; + pt->read_end = pt->saved_read_end; + pt->read_buf_size = pt->saved_read_buf_size; + } + else + offset = 0; + + SCM_PORT_DESCRIPTOR (port)->end_input (port, offset); +} + +void +scm_end_input (SCM port) +{ + scm_i_pthread_mutex_t *lock; + scm_c_lock_port (port, &lock); + scm_end_input_unlocked (port); + if (lock) + scm_i_pthread_mutex_unlock (lock); + +} + +SCM_DEFINE (scm_force_output, "force-output", 0, 1, 0, + (SCM port), + "Flush the specified output port, or the current output port if @var{port}\n" + "is omitted. The current output buffer contents are passed to the\n" + "underlying port implementation (e.g., in the case of fports, the\n" + "data will be written to the file and the output buffer will be cleared.)\n" + "It has no effect on an unbuffered port.\n\n" + "The return value is unspecified.") +#define FUNC_NAME s_scm_force_output +{ + if (SCM_UNBNDP (port)) + port = scm_current_output_port (); + else + { + port = SCM_COERCE_OUTPORT (port); + SCM_VALIDATE_OPOUTPORT (1, port); + } + scm_flush_unlocked (port); + return SCM_UNSPECIFIED; +} +#undef FUNC_NAME + +void +scm_flush_unlocked (SCM port) +{ + SCM_PORT_DESCRIPTOR (port)->flush (port); +} + +void +scm_flush (SCM port) +{ + scm_i_pthread_mutex_t *lock; + scm_c_lock_port (port, &lock); + scm_flush_unlocked (port); + if (lock) + scm_i_pthread_mutex_unlock (lock); + +} + + + + +/* Output. */ + +void +scm_putc (char c, SCM port) +{ + scm_i_pthread_mutex_t *lock; + scm_c_lock_port (port, &lock); + scm_putc_unlocked (c, port); + if (lock) + scm_i_pthread_mutex_unlock (lock); + +} + +void +scm_puts (const char *s, SCM port) +{ + scm_i_pthread_mutex_t *lock; + scm_c_lock_port (port, &lock); + scm_puts_unlocked (s, port); + if (lock) + scm_i_pthread_mutex_unlock (lock); + +} + +/* scm_c_write + * + * Used by an application to write arbitrary number of bytes to an SCM + * port. Similar semantics as libc write. However, unlike libc + * write, scm_c_write writes the requested number of bytes and has no + * return value. + * + * Warning: Doesn't update port line and column counts! + */ +void +scm_c_write_unlocked (SCM port, const void *ptr, size_t size) +#define FUNC_NAME "scm_c_write" +{ + scm_t_port *pt; + scm_t_ptob_descriptor *ptob; + + SCM_VALIDATE_OPOUTPORT (1, port); + + pt = SCM_PTAB_ENTRY (port); + ptob = SCM_PORT_DESCRIPTOR (port); + + if (pt->rw_active == SCM_PORT_READ) + scm_end_input_unlocked (port); + + ptob->write (port, ptr, size); + + if (pt->rw_random) + pt->rw_active = SCM_PORT_WRITE; +} +#undef FUNC_NAME + +void +scm_c_write (SCM port, const void *ptr, size_t size) +{ + scm_i_pthread_mutex_t *lock; + scm_c_lock_port (port, &lock); + scm_c_write_unlocked (port, ptr, size); + if (lock) + scm_i_pthread_mutex_unlock (lock); + +} + +/* scm_lfwrite + * + * This function differs from scm_c_write; it updates port line and + * column. */ +void +scm_lfwrite_unlocked (const char *ptr, size_t size, SCM port) +{ + scm_t_port *pt = SCM_PTAB_ENTRY (port); + scm_t_ptob_descriptor *ptob = SCM_PORT_DESCRIPTOR (port); + + if (pt->rw_active == SCM_PORT_READ) + scm_end_input_unlocked (port); + + ptob->write (port, ptr, size); + + for (; size; ptr++, size--) + update_port_lf ((scm_t_wchar) (unsigned char) *ptr, port); + + if (pt->rw_random) + pt->rw_active = SCM_PORT_WRITE; +} + +void +scm_lfwrite (const char *ptr, size_t size, SCM port) +{ + scm_i_pthread_mutex_t *lock; + scm_c_lock_port (port, &lock); + scm_lfwrite_unlocked (ptr, size, port); + if (lock) + scm_i_pthread_mutex_unlock (lock); + +} + +/* Write STR to PORT from START inclusive to END exclusive. */ +void +scm_lfwrite_substr (SCM str, size_t start, size_t end, SCM port) +{ + scm_t_port *pt = SCM_PTAB_ENTRY (port); + + if (pt->rw_active == SCM_PORT_READ) + scm_end_input_unlocked (port); + + if (end == (size_t) -1) + end = scm_i_string_length (str); + + scm_i_display_substring (str, start, end, port); + + if (pt->rw_random) + pt->rw_active = SCM_PORT_WRITE; +} + + + + +/* Querying and setting positions, and character availability. */ + +SCM_DEFINE (scm_char_ready_p, "char-ready?", 0, 1, 0, + (SCM port), + "Return @code{#t} if a character is ready on input @var{port}\n" + "and return @code{#f} otherwise. If @code{char-ready?} returns\n" + "@code{#t} then the next @code{read-char} operation on\n" + "@var{port} is guaranteed not to hang. If @var{port} is a file\n" + "port at end of file then @code{char-ready?} returns @code{#t}.\n" + "\n" + "@code{char-ready?} exists to make it possible for a\n" + "program to accept characters from interactive ports without\n" + "getting stuck waiting for input. Any input editors associated\n" + "with such ports must make sure that characters whose existence\n" + "has been asserted by @code{char-ready?} cannot be rubbed out.\n" + "If @code{char-ready?} were to return @code{#f} at end of file,\n" + "a port at end of file would be indistinguishable from an\n" + "interactive port that has no ready characters.") +#define FUNC_NAME s_scm_char_ready_p +{ + scm_t_port *pt; + + if (SCM_UNBNDP (port)) + port = scm_current_input_port (); + /* It's possible to close the current input port, so validate even in + this case. */ + SCM_VALIDATE_OPINPORT (1, port); + + pt = SCM_PTAB_ENTRY (port); + + /* if the current read buffer is filled, or the + last pushed-back char has been read and the saved buffer is + filled, result is true. */ + if (pt->read_pos < pt->read_end + || (pt->read_buf == pt->putback_buf + && pt->saved_read_pos < pt->saved_read_end)) + return SCM_BOOL_T; + else + { + scm_t_ptob_descriptor *ptob = SCM_PORT_DESCRIPTOR (port); + + if (ptob->input_waiting) + return scm_from_bool(ptob->input_waiting (port)); + else + return SCM_BOOL_T; + } +} +#undef FUNC_NAME + SCM_DEFINE (scm_seek, "seek", 3, 0, 0, (SCM fd_port, SCM offset, SCM whence), "Sets the current position of @var{fd_port} to the integer\n" @@ -1941,7 +2499,7 @@ SCM_DEFINE (scm_seek, "seek", 3, 0, 0, if (SCM_OPPORTP (fd_port)) { - scm_t_ptob_descriptor *ptob = scm_ptobs + SCM_PTOBNUM (fd_port); + scm_t_ptob_descriptor *ptob = SCM_PORT_DESCRIPTOR (fd_port); off_t_or_off64_t off = scm_to_off_t_or_off64_t (offset); off_t_or_off64_t rv; @@ -2037,12 +2595,12 @@ SCM_DEFINE (scm_truncate_file, "truncate-file", 1, 1, 0, { off_t_or_off64_t c_length = scm_to_off_t_or_off64_t (length); scm_t_port *pt = SCM_PTAB_ENTRY (object); - scm_t_ptob_descriptor *ptob = scm_ptobs + SCM_PTOBNUM (object); + scm_t_ptob_descriptor *ptob = SCM_PORT_DESCRIPTOR (object); if (!ptob->truncate) SCM_MISC_ERROR ("port is not truncatable", SCM_EOL); if (pt->rw_active == SCM_PORT_READ) - scm_end_input (object); + scm_end_input_unlocked (object); else if (pt->rw_active == SCM_PORT_WRITE) ptob->flush (object); @@ -2153,357 +2711,116 @@ SCM_DEFINE (scm_set_port_filename_x, "set-port-filename!", 2, 0, 0, } #undef FUNC_NAME -/* A fluid specifying the default encoding for newly created ports. If it is - a string, that is the encoding. If it is #f, it is in the "native" - (Latin-1) encoding. */ -SCM_VARIABLE (default_port_encoding_var, "%default-port-encoding"); - -static int scm_port_encoding_init = 0; -/* Use ENCODING as the default encoding for future ports. */ -void -scm_i_set_default_port_encoding (const char *encoding) -{ - if (!scm_port_encoding_init - || !scm_is_fluid (SCM_VARIABLE_REF (default_port_encoding_var))) - scm_misc_error (NULL, "tried to set port encoding fluid before it is initialized", - SCM_EOL); - - if (encoding == NULL - || !strcmp (encoding, "ASCII") - || !strcmp (encoding, "ANSI_X3.4-1968") - || !strcmp (encoding, "ISO-8859-1")) - scm_fluid_set_x (SCM_VARIABLE_REF (default_port_encoding_var), SCM_BOOL_F); - else - scm_fluid_set_x (SCM_VARIABLE_REF (default_port_encoding_var), - scm_from_locale_string (encoding)); -} - -/* Return the name of the default encoding for newly created ports; a - return value of NULL means "ISO-8859-1". */ -const char * -scm_i_default_port_encoding (void) -{ - if (!scm_port_encoding_init) - return NULL; - else if (!scm_is_fluid (SCM_VARIABLE_REF (default_port_encoding_var))) - return NULL; - else - { - SCM encoding; + - encoding = scm_fluid_ref (SCM_VARIABLE_REF (default_port_encoding_var)); - if (!scm_is_string (encoding)) - return NULL; - else - return scm_i_string_chars (encoding); - } -} +/* Implementation helpers for port printing functions. */ void -scm_i_set_port_encoding_x (SCM port, const char *encoding) -{ - scm_t_port *pt; - iconv_t new_input_cd, new_output_cd; - - new_input_cd = (iconv_t) -1; - new_output_cd = (iconv_t) -1; - - /* Set the character encoding for this port. */ - pt = SCM_PTAB_ENTRY (port); - - if (encoding == NULL) - encoding = "ISO-8859-1"; - - if (pt->encoding != encoding) - pt->encoding = scm_gc_strdup (encoding, "port"); - - /* If ENCODING is UTF-8, then no conversion descriptor is opened - because we do I/O ourselves. This saves 100+ KiB for each - descriptor. */ - if (strcmp (encoding, "UTF-8")) - { - if (SCM_CELL_WORD_0 (port) & SCM_RDNG) - { - /* Open an input iconv conversion descriptor, from ENCODING - to UTF-8. We choose UTF-8, not UTF-32, because iconv - implementations can typically convert from anything to - UTF-8, but not to UTF-32 (see - <http://lists.gnu.org/archive/html/bug-libunistring/2010-09/msg00007.html>). */ - new_input_cd = iconv_open ("UTF-8", encoding); - if (new_input_cd == (iconv_t) -1) - goto invalid_encoding; - } - - if (SCM_CELL_WORD_0 (port) & SCM_WRTNG) - { - new_output_cd = iconv_open (encoding, "UTF-8"); - if (new_output_cd == (iconv_t) -1) - { - if (new_input_cd != (iconv_t) -1) - iconv_close (new_input_cd); - goto invalid_encoding; - } - } - } - - if (pt->input_cd != (iconv_t) -1) - iconv_close (pt->input_cd); - if (pt->output_cd != (iconv_t) -1) - iconv_close (pt->output_cd); - - pt->input_cd = new_input_cd; - pt->output_cd = new_output_cd; - - return; - - invalid_encoding: - { - SCM err; - err = scm_from_locale_string (encoding); - scm_misc_error ("scm_i_set_port_encoding_x", - "invalid or unknown character encoding ~s", - scm_list_1 (err)); - } -} - -SCM_DEFINE (scm_port_encoding, "port-encoding", 1, 0, 0, - (SCM port), - "Returns, as a string, the character encoding that @var{port}\n" - "uses to interpret its input and output.\n") -#define FUNC_NAME s_scm_port_encoding +scm_print_port_mode (SCM exp, SCM port) { - scm_t_port *pt; - const char *enc; - - SCM_VALIDATE_PORT (1, port); - - pt = SCM_PTAB_ENTRY (port); - enc = pt->encoding; - if (enc) - return scm_from_locale_string (pt->encoding); - else - return SCM_BOOL_F; + scm_puts_unlocked (SCM_CLOSEDP (exp) + ? "closed: " + : (SCM_RDNG & SCM_CELL_WORD_0 (exp) + ? (SCM_WRTNG & SCM_CELL_WORD_0 (exp) + ? "input-output: " + : "input: ") + : (SCM_WRTNG & SCM_CELL_WORD_0 (exp) + ? "output: " + : "bogus: ")), + port); } -#undef FUNC_NAME -SCM_DEFINE (scm_set_port_encoding_x, "set-port-encoding!", 2, 0, 0, - (SCM port, SCM enc), - "Sets the character encoding that will be used to interpret all\n" - "port I/O. New ports are created with the encoding\n" - "appropriate for the current locale if @code{setlocale} has \n" - "been called or ISO-8859-1 otherwise\n" - "and this procedure can be used to modify that encoding.\n") -#define FUNC_NAME s_scm_set_port_encoding_x +int +scm_port_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED) { - char *enc_str; - - SCM_VALIDATE_PORT (1, port); - SCM_VALIDATE_STRING (2, enc); - - enc_str = scm_to_locale_string (enc); - scm_i_set_port_encoding_x (port, enc_str); - free (enc_str); - - return SCM_UNSPECIFIED; + char *type = SCM_PTOBNAME (SCM_PTOBNUM (exp)); + if (!type) + type = "port"; + scm_puts_unlocked ("#<", port); + scm_print_port_mode (exp, port); + scm_puts_unlocked (type, port); + scm_putc_unlocked (' ', port); + scm_uintprint (SCM_CELL_WORD_1 (exp), 16, port); + scm_putc_unlocked ('>', port); + return 1; } -#undef FUNC_NAME - -/* A fluid specifying the default conversion handler for newly created - ports. Its value should be one of the symbols below. */ -SCM_VARIABLE (default_conversion_strategy_var, - "%default-port-conversion-strategy"); -/* Whether the above fluid is initialized. */ -static int scm_conversion_strategy_init = 0; + -/* The possible conversion strategies. */ -SCM_SYMBOL (sym_error, "error"); -SCM_SYMBOL (sym_substitute, "substitute"); -SCM_SYMBOL (sym_escape, "escape"); +/* Iterating over all ports. */ -/* Return the default failed encoding conversion policy for new created - ports. */ -scm_t_string_failed_conversion_handler -scm_i_default_port_conversion_handler (void) +struct for_each_data { - scm_t_string_failed_conversion_handler handler; - - if (!scm_conversion_strategy_init - || !scm_is_fluid (SCM_VARIABLE_REF (default_conversion_strategy_var))) - handler = SCM_FAILED_CONVERSION_QUESTION_MARK; - else - { - SCM fluid, value; - - fluid = SCM_VARIABLE_REF (default_conversion_strategy_var); - value = scm_fluid_ref (fluid); + void (*proc) (void *data, SCM p); + void *data; +}; - if (scm_is_eq (sym_substitute, value)) - handler = SCM_FAILED_CONVERSION_QUESTION_MARK; - else if (scm_is_eq (sym_escape, value)) - handler = SCM_FAILED_CONVERSION_ESCAPE_SEQUENCE; - else - /* Default to 'error also when the fluid's value is not one of - the valid symbols. */ - handler = SCM_FAILED_CONVERSION_ERROR; - } +static SCM +for_each_trampoline (void *data, SCM port, SCM result) +{ + struct for_each_data *d = data; + + d->proc (d->data, port); - return handler; + return result; } -/* Use HANDLER as the default conversion strategy for future ports. */ void -scm_i_set_default_port_conversion_handler (scm_t_string_failed_conversion_handler - handler) +scm_c_port_for_each (void (*proc)(void *data, SCM p), void *data) { - SCM strategy; - - if (!scm_conversion_strategy_init - || !scm_is_fluid (SCM_VARIABLE_REF (default_conversion_strategy_var))) - scm_misc_error (NULL, "tried to set conversion strategy fluid before it is initialized", - SCM_EOL); - - switch (handler) - { - case SCM_FAILED_CONVERSION_ERROR: - strategy = sym_error; - break; - - case SCM_FAILED_CONVERSION_ESCAPE_SEQUENCE: - strategy = sym_escape; - break; - - case SCM_FAILED_CONVERSION_QUESTION_MARK: - strategy = sym_substitute; - break; - - default: - abort (); - } + struct for_each_data d; + + d.proc = proc; + d.data = data; - scm_fluid_set_x (SCM_VARIABLE_REF (default_conversion_strategy_var), - strategy); + scm_c_weak_set_fold (for_each_trampoline, &d, SCM_EOL, + scm_i_port_weak_set); } -SCM_DEFINE (scm_port_conversion_strategy, "port-conversion-strategy", - 1, 0, 0, (SCM port), - "Returns the behavior of the port when handling a character that\n" - "is not representable in the port's current encoding.\n" - "It returns the symbol @code{error} if unrepresentable characters\n" - "should cause exceptions, @code{substitute} if the port should\n" - "try to replace unrepresentable characters with question marks or\n" - "approximate characters, or @code{escape} if unrepresentable\n" - "characters should be converted to string escapes.\n" - "\n" - "If @var{port} is @code{#f}, then the current default behavior\n" - "will be returned. New ports will have this default behavior\n" - "when they are created.\n") -#define FUNC_NAME s_scm_port_conversion_strategy +static void +scm_for_each_trampoline (void *data, SCM port) { - scm_t_string_failed_conversion_handler h; - - if (scm_is_false (port)) - h = scm_i_default_port_conversion_handler (); - else - { - scm_t_port *pt; - - SCM_VALIDATE_OPPORT (1, port); - pt = SCM_PTAB_ENTRY (port); - - h = pt->ilseq_handler; - } - - if (h == SCM_FAILED_CONVERSION_ERROR) - return scm_from_latin1_symbol ("error"); - else if (h == SCM_FAILED_CONVERSION_QUESTION_MARK) - return scm_from_latin1_symbol ("substitute"); - else if (h == SCM_FAILED_CONVERSION_ESCAPE_SEQUENCE) - return scm_from_latin1_symbol ("escape"); - else - abort (); - - /* Never gets here. */ - return SCM_UNDEFINED; + scm_call_1 (SCM_PACK_POINTER (data), port); } -#undef FUNC_NAME -SCM_DEFINE (scm_set_port_conversion_strategy_x, "set-port-conversion-strategy!", - 2, 0, 0, - (SCM port, SCM sym), - "Sets the behavior of the interpreter when outputting a character\n" - "that is not representable in the port's current encoding.\n" - "@var{sym} can be either @code{'error}, @code{'substitute}, or\n" - "@code{'escape}. If it is @code{'error}, an error will be thrown\n" - "when an unconvertible character is encountered. If it is\n" - "@code{'substitute}, then unconvertible characters will \n" - "be replaced with approximate characters, or with question marks\n" - "if no approximately correct character is available.\n" - "If it is @code{'escape},\n" - "it will appear as a hex escape when output.\n" - "\n" - "If @var{port} is an open port, the conversion error behavior\n" - "is set for that port. If it is @code{#f}, it is set as the\n" - "default behavior for any future ports that get created in\n" - "this thread.\n") -#define FUNC_NAME s_scm_set_port_conversion_strategy_x +SCM_DEFINE (scm_port_for_each, "port-for-each", 1, 0, 0, + (SCM proc), + "Apply @var{proc} to each port in the Guile port table\n" + "in turn. The return value is unspecified. More specifically,\n" + "@var{proc} is applied exactly once to every port that exists\n" + "in the system at the time @code{port-for-each} is invoked.\n" + "Changes to the port table while @code{port-for-each} is running\n" + "have no effect as far as @code{port-for-each} is concerned.") +#define FUNC_NAME s_scm_port_for_each { - scm_t_string_failed_conversion_handler handler; - - if (scm_is_eq (sym, sym_error)) - handler = SCM_FAILED_CONVERSION_ERROR; - else if (scm_is_eq (sym, sym_substitute)) - handler = SCM_FAILED_CONVERSION_QUESTION_MARK; - else if (scm_is_eq (sym, sym_escape)) - handler = SCM_FAILED_CONVERSION_ESCAPE_SEQUENCE; - else - SCM_MISC_ERROR ("unknown conversion strategy ~s", scm_list_1 (sym)); - - if (scm_is_false (port)) - scm_i_set_default_port_conversion_handler (handler); - else - { - SCM_VALIDATE_OPPORT (1, port); - SCM_PTAB_ENTRY (port)->ilseq_handler = handler; - } + SCM_VALIDATE_PROC (1, proc); + scm_c_port_for_each (scm_for_each_trampoline, SCM_UNPACK_POINTER (proc)); + return SCM_UNSPECIFIED; } #undef FUNC_NAME - - -void -scm_print_port_mode (SCM exp, SCM port) +static void +flush_output_port (void *closure, SCM port) { - scm_puts (SCM_CLOSEDP (exp) - ? "closed: " - : (SCM_RDNG & SCM_CELL_WORD_0 (exp) - ? (SCM_WRTNG & SCM_CELL_WORD_0 (exp) - ? "input-output: " - : "input: ") - : (SCM_WRTNG & SCM_CELL_WORD_0 (exp) - ? "output: " - : "bogus: ")), - port); + if (SCM_OPOUTPORTP (port)) + scm_flush_unlocked (port); } -int -scm_port_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED) +SCM_DEFINE (scm_flush_all_ports, "flush-all-ports", 0, 0, 0, + (), + "Equivalent to calling @code{force-output} on\n" + "all open output ports. The return value is unspecified.") +#define FUNC_NAME s_scm_flush_all_ports { - char *type = SCM_PTOBNAME (SCM_PTOBNUM (exp)); - if (!type) - type = "port"; - scm_puts ("#<", port); - scm_print_port_mode (exp, port); - scm_puts (type, port); - scm_putc (' ', port); - scm_uintprint (SCM_CELL_WORD_1 (exp), 16, port); - scm_putc ('>', port); - return 1; + scm_c_port_for_each (&flush_output_port, NULL); + return SCM_UNSPECIFIED; } +#undef FUNC_NAME + @@ -2526,18 +2843,13 @@ write_void_port (SCM port SCM_UNUSED, static SCM scm_i_void_port (long mode_bits) { - scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex); - { - SCM answer = scm_new_port_table_entry (scm_tc16_void_port); - scm_t_port * pt = SCM_PTAB_ENTRY(answer); + SCM ret; + + ret = scm_c_make_port (scm_tc16_void_port, mode_bits, 0); - scm_port_non_buffer (pt); + scm_port_non_buffer (SCM_PTAB_ENTRY (ret)); - SCM_SETSTREAM (answer, 0); - SCM_SET_CELL_TYPE (answer, scm_tc16_void_port | mode_bits); - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); - return answer; - } + return ret; } SCM @@ -2558,7 +2870,9 @@ SCM_DEFINE (scm_sys_make_void_port, "%make-void-port", 1, 0, 0, } #undef FUNC_NAME + + /* Initialization. */ void @@ -2577,7 +2891,7 @@ scm_init_ports () cur_errport_fluid = scm_make_fluid (); cur_loadport_fluid = scm_make_fluid (); - scm_i_port_weak_hash = scm_make_weak_key_hash_table (SCM_I_MAKINUM(31)); + scm_i_port_weak_set = scm_c_make_weak_set (31); #include "libguile/ports.x" diff --git a/libguile/ports.h b/libguile/ports.h index d4d59b70e..c1ba71921 100644 --- a/libguile/ports.h +++ b/libguile/ports.h @@ -26,7 +26,12 @@ #include "libguile/__scm.h" +#include <stdio.h> +#include <string.h> #include <unistd.h> +#include "libguile/gc.h" +#include "libguile/tags.h" +#include "libguile/error.h" #include "libguile/print.h" #include "libguile/struct.h" #include "libguile/threads.h" @@ -43,14 +48,28 @@ typedef enum scm_t_port_rw_active { SCM_PORT_WRITE = 2 } scm_t_port_rw_active; +typedef enum scm_t_port_encoding_mode { + SCM_PORT_ENCODING_MODE_UTF8, + SCM_PORT_ENCODING_MODE_LATIN1, + SCM_PORT_ENCODING_MODE_ICONV +} scm_t_port_encoding_mode; + +/* This is a separate object so that only those ports that use iconv + cause finalizers to be registered. */ +typedef struct scm_t_iconv_descriptors +{ + /* input/output iconv conversion descriptors */ + void *input_cd; + void *output_cd; +} scm_t_iconv_descriptors; + /* C representation of a Scheme port. */ typedef struct { SCM port; /* Link back to the port object. */ - int revealed; /* 0 not revealed, > 1 revealed. - * Revealed ports do not get GC'd. - */ + scm_i_pthread_mutex_t *lock; /* A recursive lock for this port. */ + /* data for the underlying port implementation as a raw C value. */ scm_t_bits stream; @@ -58,10 +77,6 @@ typedef struct long line_number; /* debugging support. */ int column_number; /* debugging support. */ - /* Character encoding support */ - char *encoding; - scm_t_string_failed_conversion_handler ilseq_handler; - /* port buffers. the buffer(s) are set up for all ports. in the case of string ports, the buffer is the string itself. in the case of unbuffered file ports, the buffer is a @@ -112,14 +127,19 @@ typedef struct unsigned char *putback_buf; size_t putback_buf_size; /* allocated size of putback_buf. */ - /* input/output iconv conversion descriptors */ - void *input_cd; - void *output_cd; + /* Character encoding support */ + char *encoding; + scm_t_port_encoding_mode encoding_mode; + scm_t_string_failed_conversion_handler ilseq_handler; + scm_t_iconv_descriptors *iconv_descriptors; + + /* an alist for storing additional information + (e.g. used to store per-port read options) */ + SCM alist; } scm_t_port; -SCM_INTERNAL scm_i_pthread_mutex_t scm_i_port_table_mutex; -SCM_INTERNAL SCM scm_i_port_weak_hash; +SCM_INTERNAL SCM scm_i_port_weak_set; #define SCM_READ_BUFFER_EMPTY_P(c_port) (c_port->read_pos >= c_port->read_end) @@ -139,22 +159,19 @@ SCM_INTERNAL SCM scm_i_port_weak_hash; #define SCM_BUF0 (8L<<16) /* Is it unbuffered? */ #define SCM_BUFLINE (64L<<16) /* Is it line-buffered? */ -#define SCM_PORTP(x) (!SCM_IMP (x) && (SCM_TYP7 (x) == scm_tc7_port)) -#define SCM_OPPORTP(x) (!SCM_IMP(x) && (((0x7f | SCM_OPN) & SCM_CELL_WORD_0(x))==(scm_tc7_port | SCM_OPN))) -#define SCM_OPINPORTP(x) (!SCM_IMP(x) && (((0x7f | SCM_OPN | SCM_RDNG) & SCM_CELL_WORD_0(x))==(scm_tc7_port | SCM_OPN | SCM_RDNG))) -#define SCM_OPOUTPORTP(x) (!SCM_IMP(x) && (((0x7f | SCM_OPN | SCM_WRTNG) & SCM_CELL_WORD_0(x))==(scm_tc7_port | SCM_OPN | SCM_WRTNG))) -#define SCM_INPUT_PORT_P(x) \ - (!SCM_IMP(x) \ - && (((0x7f | SCM_RDNG) & SCM_CELL_WORD_0(x)) == (scm_tc7_port | SCM_RDNG))) -#define SCM_OUTPUT_PORT_P(x) \ - (!SCM_IMP(x) \ - && (((0x7f | SCM_WRTNG) & SCM_CELL_WORD_0(x))==(scm_tc7_port | SCM_WRTNG))) -#define SCM_OPENP(x) (!SCM_IMP(x) && (SCM_OPN & SCM_CELL_WORD_0 (x))) -#define SCM_CLOSEDP(x) (!SCM_OPENP(x)) +#define SCM_PORTP(x) (SCM_HAS_TYP7 (x, scm_tc7_port)) +#define SCM_OPPORTP(x) (SCM_PORTP (x) && (SCM_CELL_WORD_0 (x) & SCM_OPN)) +#define SCM_INPUT_PORT_P(x) (SCM_PORTP (x) && (SCM_CELL_WORD_0 (x) & SCM_RDNG)) +#define SCM_OUTPUT_PORT_P(x) (SCM_PORTP (x) && (SCM_CELL_WORD_0 (x) & SCM_WRTNG)) +#define SCM_OPINPORTP(x) (SCM_OPPORTP (x) && SCM_INPUT_PORT_P (x)) +#define SCM_OPOUTPORTP(x) (SCM_OPPORTP (x) && SCM_OUTPUT_PORT_P (x)) +#define SCM_OPENP(x) (SCM_OPPORTP (x)) +#define SCM_CLOSEDP(x) (!SCM_OPENP (x)) #define SCM_CLR_PORT_OPEN_FLAG(p) \ SCM_SET_CELL_WORD_0 ((p), SCM_CELL_WORD_0 (p) & ~SCM_OPN) #define SCM_PTAB_ENTRY(x) ((scm_t_port *) SCM_CELL_WORD_1 (x)) +#define SCM_PORT_DESCRIPTOR(port) ((scm_t_ptob_descriptor *) SCM_CELL_WORD_2 (port)) #define SCM_SETPTAB_ENTRY(x, ent) (SCM_SET_CELL_WORD_1 ((x), (scm_t_bits) (ent))) #define SCM_STREAM(x) (SCM_PTAB_ENTRY(x)->stream) #define SCM_SETSTREAM(x, s) (SCM_PTAB_ENTRY(x)->stream = (scm_t_bits) (s)) @@ -162,8 +179,6 @@ SCM_INTERNAL SCM scm_i_port_weak_hash; #define SCM_SET_FILENAME(x, n) (SCM_PTAB_ENTRY(x)->file_name = (n)) #define SCM_LINUM(x) (SCM_PTAB_ENTRY(x)->line_number) #define SCM_COL(x) (SCM_PTAB_ENTRY(x)->column_number) -#define SCM_REVEALED(x) (SCM_PTAB_ENTRY(x)->revealed) -#define SCM_SETREVEALED(x, s) (SCM_PTAB_ENTRY(x)->revealed = (s)) #define SCM_INCLINE(port) do {SCM_LINUM (port) += 1; SCM_COL (port) = 0;} while (0) #define SCM_ZEROCOL(port) do {SCM_COL (port) = 0;} while (0) @@ -176,6 +191,10 @@ SCM_INTERNAL SCM scm_i_port_weak_hash; +typedef enum scm_t_port_type_flags { + SCM_PORT_TYPE_HAS_FLUSH = 1 << 0 +} scm_t_port_type_flags; + /* port-type description. */ typedef struct scm_t_ptob_descriptor { @@ -196,24 +215,18 @@ typedef struct scm_t_ptob_descriptor scm_t_off (*seek) (SCM port, scm_t_off OFFSET, int WHENCE); void (*truncate) (SCM port, scm_t_off length); + unsigned flags; } scm_t_ptob_descriptor; #define SCM_TC2PTOBNUM(x) (0x0ff & ((x) >> 8)) #define SCM_PTOBNUM(x) (SCM_TC2PTOBNUM (SCM_CELL_TYPE (x))) /* SCM_PTOBNAME can be 0 if name is missing */ -#define SCM_PTOBNAME(ptobnum) scm_ptobs[ptobnum].name - - - -/* Hey you! Yes you, reading the header file! We're going to deprecate - scm_ptobs in 2.2, so please don't write any new code that uses it. - Thanks. */ -SCM_API scm_t_ptob_descriptor *scm_ptobs; -SCM_API long scm_numptob; - - +#define SCM_PTOBNAME(ptobnum) (scm_c_port_type_ref (ptobnum)->name) -SCM_API SCM scm_markstream (SCM ptr); +/* Port types, and their vtables. */ +SCM_INTERNAL long scm_c_num_port_types (void); +SCM_API scm_t_ptob_descriptor* scm_c_port_type_ref (long ptobnum); +SCM_API long scm_c_port_type_add_x (scm_t_ptob_descriptor *desc); SCM_API scm_t_bits scm_make_port_type (char *name, int (*fill_input) (SCM port), void (*write) (SCM port, @@ -228,11 +241,10 @@ SCM_API void scm_set_port_print (scm_t_bits tc, SCM_API void scm_set_port_equalp (scm_t_bits tc, SCM (*equalp) (SCM, SCM)); SCM_API void scm_set_port_close (scm_t_bits tc, int (*close) (SCM)); -SCM_API void scm_set_port_flush (scm_t_bits tc, - void (*flush) (SCM port)); +SCM_API void scm_set_port_flush (scm_t_bits tc, void (*flush) (SCM port)); SCM_API void scm_set_port_end_input (scm_t_bits tc, - void (*end_input) (SCM port, - int offset)); + void (*end_input) (SCM port, + int offset)); SCM_API void scm_set_port_seek (scm_t_bits tc, scm_t_off (*seek) (SCM port, scm_t_off OFFSET, @@ -241,10 +253,8 @@ SCM_API void scm_set_port_truncate (scm_t_bits tc, void (*truncate) (SCM port, scm_t_off length)); SCM_API void scm_set_port_input_waiting (scm_t_bits tc, int (*input_waiting) (SCM)); -SCM_API SCM scm_char_ready_p (SCM port); -SCM_API size_t scm_take_from_input_buffers (SCM port, char *dest, - size_t read_len); -SCM_API SCM scm_drain_input (SCM port); + +/* The input, output, error, and load ports. */ SCM_API SCM scm_current_input_port (void); SCM_API SCM scm_current_output_port (void); SCM_API SCM scm_current_error_port (void); @@ -257,44 +267,104 @@ SCM_API SCM scm_set_current_warning_port (SCM port); SCM_API void scm_dynwind_current_input_port (SCM port); SCM_API void scm_dynwind_current_output_port (SCM port); SCM_API void scm_dynwind_current_error_port (SCM port); -SCM_API SCM scm_new_port_table_entry (scm_t_bits tag); -SCM_API void scm_grow_port_cbuf (SCM port, size_t requested); -SCM_API SCM scm_pt_size (void); -SCM_API SCM scm_pt_member (SCM member); -SCM_API void scm_port_non_buffer (scm_t_port *pt); -SCM_API int scm_revealed_count (SCM port); -SCM_API SCM scm_port_revealed (SCM port); -SCM_API SCM scm_set_port_revealed_x (SCM port, SCM rcount); +SCM_INTERNAL void scm_i_dynwind_current_load_port (SCM port); + +/* Mode bits. */ +SCM_INTERNAL long scm_i_mode_bits (SCM modes); SCM_API long scm_mode_bits (char *modes); SCM_API SCM scm_port_mode (SCM port); -SCM_API SCM scm_close_input_port (SCM port); -SCM_API SCM scm_close_output_port (SCM port); -SCM_API SCM scm_close_port (SCM port); -SCM_API SCM scm_port_for_each (SCM proc); -SCM_API void scm_c_port_for_each (void (*proc)(void *data, SCM p), void *data); + +/* Low-level constructors. */ +SCM_API SCM +scm_c_make_port_with_encoding (scm_t_bits tag, + unsigned long mode_bits, + const char *encoding, + scm_t_string_failed_conversion_handler handler, + scm_t_bits stream); +SCM_API SCM scm_c_make_port (scm_t_bits tag, unsigned long mode_bits, + scm_t_bits stream); +SCM_API SCM scm_new_port_table_entry (scm_t_bits tag); + +/* Predicates. */ +SCM_API SCM scm_port_p (SCM x); SCM_API SCM scm_input_port_p (SCM x); SCM_API SCM scm_output_port_p (SCM x); -SCM_API SCM scm_port_p (SCM x); SCM_API SCM scm_port_closed_p (SCM port); SCM_API SCM scm_eof_object_p (SCM x); -SCM_API SCM scm_force_output (SCM port); -SCM_API SCM scm_flush_all_ports (void); -SCM_API SCM scm_read_char (SCM port); -SCM_API scm_t_wchar scm_getc (SCM port); + +/* Closing ports. */ +SCM_API SCM scm_close_port (SCM port); +SCM_API SCM scm_close_input_port (SCM port); +SCM_API SCM scm_close_output_port (SCM port); + +/* Encoding characters to byte streams, and decoding byte streams to + characters. */ +SCM_INTERNAL const char *scm_i_default_port_encoding (void); +SCM_INTERNAL void scm_i_set_default_port_encoding (const char *); +SCM_INTERNAL scm_t_string_failed_conversion_handler +scm_i_default_port_conversion_handler (void); +SCM_INTERNAL void +scm_i_set_default_port_conversion_handler (scm_t_string_failed_conversion_handler); +SCM_INTERNAL scm_t_iconv_descriptors *scm_i_port_iconv_descriptors (SCM port); +SCM_INTERNAL void scm_i_set_port_encoding_x (SCM port, const char *str); +SCM_API SCM scm_port_encoding (SCM port); +SCM_API SCM scm_set_port_encoding_x (SCM port, SCM encoding); +SCM_API SCM scm_port_conversion_strategy (SCM port); +SCM_API SCM scm_set_port_conversion_strategy_x (SCM port, SCM behavior); + +/* Acquiring and releasing the port lock. */ +SCM_API void scm_dynwind_lock_port (SCM port); +SCM_INLINE int scm_c_lock_port (SCM port, scm_i_pthread_mutex_t **lock); +SCM_INLINE int scm_c_try_lock_port (SCM port, scm_i_pthread_mutex_t **lock); + +/* Input. */ +SCM_API int scm_get_byte_or_eof (SCM port); +SCM_INLINE int scm_get_byte_or_eof_unlocked (SCM port); +SCM_API int scm_peek_byte_or_eof (SCM port); +SCM_INLINE int scm_peek_byte_or_eof_unlocked (SCM port); SCM_API size_t scm_c_read (SCM port, void *buffer, size_t size); -SCM_API void scm_c_write (SCM port, const void *buffer, size_t size); -SCM_API void scm_lfwrite (const char *ptr, size_t size, SCM port); -SCM_INTERNAL void scm_lfwrite_substr (SCM str, size_t start, size_t end, - SCM port); -SCM_API void scm_flush (SCM port); -SCM_API void scm_end_input (SCM port); -SCM_API int scm_fill_input (SCM port); +SCM_API size_t scm_c_read_unlocked (SCM port, void *buffer, size_t size); +SCM_API scm_t_wchar scm_getc (SCM port); +SCM_API scm_t_wchar scm_getc_unlocked (SCM port); +SCM_API SCM scm_read_char (SCM port); + +/* Pushback. */ SCM_API void scm_unget_byte (int c, SCM port); +SCM_API void scm_unget_byte_unlocked (int c, SCM port); SCM_API void scm_ungetc (scm_t_wchar c, SCM port); +SCM_API void scm_ungetc_unlocked (scm_t_wchar c, SCM port); SCM_API void scm_ungets (const char *s, int n, SCM port); +SCM_API void scm_ungets_unlocked (const char *s, int n, SCM port); SCM_API SCM scm_peek_char (SCM port); SCM_API SCM scm_unread_char (SCM cobj, SCM port); SCM_API SCM scm_unread_string (SCM str, SCM port); + +/* Manipulating the buffers. */ +SCM_API void scm_port_non_buffer (scm_t_port *pt); +SCM_API int scm_fill_input (SCM port); +SCM_API int scm_fill_input_unlocked (SCM port); +SCM_INTERNAL size_t scm_take_from_input_buffers (SCM port, char *dest, size_t read_len); +SCM_API SCM scm_drain_input (SCM port); +SCM_API void scm_end_input (SCM port); +SCM_API void scm_end_input_unlocked (SCM port); +SCM_API SCM scm_force_output (SCM port); +SCM_API void scm_flush (SCM port); +SCM_API void scm_flush_unlocked (SCM port); + +/* Output. */ +SCM_API void scm_putc (char c, SCM port); +SCM_INLINE void scm_putc_unlocked (char c, SCM port); +SCM_API void scm_puts (const char *str_data, SCM port); +SCM_INLINE void scm_puts_unlocked (const char *str_data, SCM port); +SCM_API void scm_c_write (SCM port, const void *buffer, size_t size); +SCM_API void scm_c_write_unlocked (SCM port, const void *buffer, size_t size); +SCM_API void scm_lfwrite (const char *ptr, size_t size, SCM port); +SCM_API void scm_lfwrite_unlocked (const char *ptr, size_t size, SCM port); +SCM_INTERNAL void scm_lfwrite_substr (SCM str, size_t start, size_t end, + SCM port); + +/* Querying and setting positions, and character availability. */ +SCM_API SCM scm_char_ready_p (SCM port); SCM_API SCM scm_seek (SCM object, SCM offset, SCM whence); SCM_API SCM scm_truncate_file (SCM object, SCM length); SCM_API SCM scm_port_line (SCM port); @@ -303,39 +373,116 @@ SCM_API SCM scm_port_column (SCM port); SCM_API SCM scm_set_port_column_x (SCM port, SCM line); SCM_API SCM scm_port_filename (SCM port); SCM_API SCM scm_set_port_filename_x (SCM port, SCM filename); -SCM_INTERNAL const char *scm_i_default_port_encoding (void); -SCM_INTERNAL void scm_i_set_default_port_encoding (const char *); -SCM_INTERNAL void scm_i_set_port_encoding_x (SCM port, const char *str); -SCM_API SCM scm_port_encoding (SCM port); -SCM_API SCM scm_set_port_encoding_x (SCM port, SCM encoding); -SCM_INTERNAL scm_t_string_failed_conversion_handler -scm_i_default_port_conversion_handler (void); -/* Use HANDLER as the default conversion strategy for future ports. */ -SCM_INTERNAL void -scm_i_set_default_port_conversion_handler (scm_t_string_failed_conversion_handler); -SCM_API SCM scm_port_conversion_strategy (SCM port); -SCM_API SCM scm_set_port_conversion_strategy_x (SCM port, SCM behavior); +/* Implementation helpers for port printing functions. */ SCM_API int scm_port_print (SCM exp, SCM port, scm_print_state *); SCM_API void scm_print_port_mode (SCM exp, SCM port); + +/* Iterating over all ports. */ +SCM_API SCM scm_port_for_each (SCM proc); +SCM_API void scm_c_port_for_each (void (*proc)(void *data, SCM p), void *data); +SCM_API SCM scm_flush_all_ports (void); + +/* Void ports. */ SCM_API SCM scm_void_port (char * mode_str); SCM_API SCM scm_sys_make_void_port (SCM mode); + +/* Initialization. */ SCM_INTERNAL void scm_init_ports (void); -#if SCM_ENABLE_DEPRECATED==1 -SCM_DEPRECATED scm_t_port * scm_add_to_port_table (SCM port); -#endif -#ifdef GUILE_DEBUG -SCM_API SCM scm_pt_size (void); -SCM_API SCM scm_pt_member (SCM member); -#endif /* GUILE_DEBUG */ +/* Inline function implementations. */ -/* internal */ +#if SCM_CAN_INLINE || defined SCM_INLINE_C_IMPLEMENTING_INLINES +SCM_INLINE_IMPLEMENTATION int +scm_c_lock_port (SCM port, scm_i_pthread_mutex_t **lock) +{ + *lock = SCM_PTAB_ENTRY (port)->lock; -SCM_INTERNAL long scm_i_mode_bits (SCM modes); -SCM_INTERNAL void scm_i_dynwind_current_load_port (SCM port); + if (*lock) + return scm_i_pthread_mutex_lock (*lock); + else + return 0; +} + +SCM_INLINE_IMPLEMENTATION int +scm_c_try_lock_port (SCM port, scm_i_pthread_mutex_t **lock) +{ + *lock = SCM_PTAB_ENTRY (port)->lock; + if (*lock) + { + int ret = scm_i_pthread_mutex_trylock (*lock); + if (ret != 0) + *lock = NULL; + return ret; + } + else + return 0; +} + +SCM_INLINE_IMPLEMENTATION int +scm_get_byte_or_eof_unlocked (SCM port) +{ + int c; + scm_t_port *pt = SCM_PTAB_ENTRY (port); + if (pt->rw_active == SCM_PORT_WRITE) + /* may be marginally faster than calling scm_flush. */ + SCM_PORT_DESCRIPTOR (port)->flush (port); + + if (pt->rw_random) + pt->rw_active = SCM_PORT_READ; + + if (pt->read_pos >= pt->read_end) + { + if (SCM_UNLIKELY (scm_fill_input_unlocked (port) == EOF)) + return EOF; + } + + c = *(pt->read_pos++); + + return c; +} + +/* Like `scm_get_byte_or_eof' but does not change PORT's `read_pos'. */ +SCM_INLINE_IMPLEMENTATION int +scm_peek_byte_or_eof_unlocked (SCM port) +{ + int c; + scm_t_port *pt = SCM_PTAB_ENTRY (port); + + if (pt->rw_active == SCM_PORT_WRITE) + /* may be marginally faster than calling scm_flush. */ + SCM_PORT_DESCRIPTOR (port)->flush (port); + + if (pt->rw_random) + pt->rw_active = SCM_PORT_READ; + + if (pt->read_pos >= pt->read_end) + { + if (SCM_UNLIKELY (scm_fill_input_unlocked (port) == EOF)) + return EOF; + } + + c = *pt->read_pos; + + return c; +} + +SCM_INLINE_IMPLEMENTATION void +scm_putc_unlocked (char c, SCM port) +{ + SCM_ASSERT_TYPE (SCM_OPOUTPORTP (port), port, 0, NULL, "output port"); + scm_lfwrite_unlocked (&c, 1, port); +} + +SCM_INLINE_IMPLEMENTATION void +scm_puts_unlocked (const char *s, SCM port) +{ + SCM_ASSERT_TYPE (SCM_OPOUTPORTP (port), port, 0, NULL, "output port"); + scm_lfwrite_unlocked (s, strlen (s), port); +} +#endif /* SCM_CAN_INLINE || defined SCM_INLINE_C_IMPLEMENTING_INLINES */ #endif /* SCM_PORTS_H */ diff --git a/libguile/posix.c b/libguile/posix.c index 39661a0f6..383ab76fd 100644 --- a/libguile/posix.c +++ b/libguile/posix.c @@ -1251,6 +1251,7 @@ SCM_DEFINE (scm_fork, "primitive-fork", 0, 0, 0, #define FUNC_NAME s_scm_fork { int pid; + scm_i_finalizer_pre_fork (); if (scm_ilength (scm_all_threads ()) != 1) /* Other threads may be holding on to resources that Guile needs -- it is not safe to permit one thread to fork while others are diff --git a/libguile/print.c b/libguile/print.c index 647eed8cb..5d5c56d2f 100644 --- a/libguile/print.c +++ b/libguile/print.c @@ -40,7 +40,6 @@ #include "libguile/macros.h" #include "libguile/procprop.h" #include "libguile/read.h" -#include "libguile/weaks.h" #include "libguile/programs.h" #include "libguile/alist.h" #include "libguile/struct.h" @@ -161,7 +160,7 @@ do \ { \ if (pstate->top - pstate->list_offset >= pstate->level) \ { \ - scm_putc ('#', port); \ + scm_putc_unlocked ('#', port); \ return; \ } \ } \ @@ -305,9 +304,9 @@ print_circref (SCM port, scm_print_state *pstate, SCM ref) for (i = pstate->top - 1; 1; --i) if (scm_is_eq (PSTATE_STACK_REF(pstate, i), ref)) break; - scm_putc ('#', port); + scm_putc_unlocked ('#', port); scm_intprint (i - self, 10, port); - scm_putc ('#', port); + scm_putc_unlocked ('#', port); } /* Print the name of a symbol. */ @@ -336,6 +335,7 @@ quote_keywordish_symbols (void) (INITIAL_IDENTIFIER_MASK \ | UC_CATEGORY_MASK_Nd | UC_CATEGORY_MASK_Mc | UC_CATEGORY_MASK_Me) +/* FIXME: Cache this information on the symbol, somehow. */ static int symbol_has_extended_read_syntax (SCM sym) { @@ -348,26 +348,56 @@ symbol_has_extended_read_syntax (SCM sym) c = scm_i_symbol_ref (sym, 0); - /* Single dot; conflicts with dotted-pair notation. */ - if (len == 1 && c == '.') - return 1; - - /* Other initial-character constraints. */ - if (c == '\'' || c == '`' || c == ',' || c == '"' || c == ';' || c == '#') - return 1; + switch (c) + { + case '\'': + case '`': + case ',': + case '"': + case ';': + case '#': + /* Some initial-character constraints. */ + return 1; - /* Keywords can be identified by trailing colons too. */ - if (c == ':' || scm_i_symbol_ref (sym, len - 1) == ':') - return quote_keywordish_symbols (); + case ':': + /* Symbols that look like keywords. */ + return quote_keywordish_symbols (); - /* Number-ish symbols. */ - if (scm_is_true (scm_i_string_to_number (scm_symbol_to_string (sym), 10))) - return 1; + case '.': + /* Single dot conflicts with dotted-pair notation. */ + if (len == 1) + return 1; + /* Fall through to check numbers. */ + case '+': + case '-': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + /* Number-ish symbols. Numbers with radixes already caught be # + above. */ + if (scm_is_true (scm_i_string_to_number (scm_symbol_to_string (sym), 10))) + return 1; + break; + + default: + break; + } /* Other disallowed first characters. */ if (!uc_is_general_category_withtable (c, INITIAL_IDENTIFIER_MASK)) return 1; + /* Keywords can be identified by trailing colons too. */ + if (scm_i_symbol_ref (sym, len - 1) == ':') + return quote_keywordish_symbols (); + /* Otherwise, any character that's in the identifier category mask is fine to pass through as-is, provided it's not one of the ASCII delimiters like `;'. */ @@ -386,7 +416,16 @@ symbol_has_extended_read_syntax (SCM sym) static void print_normal_symbol (SCM sym, SCM port) { - scm_display (scm_symbol_to_string (sym), port); + size_t len; + scm_t_string_failed_conversion_handler strategy; + + len = scm_i_symbol_length (sym); + strategy = SCM_PTAB_ENTRY (port)->ilseq_handler; + + if (scm_i_is_narrow_symbol (sym)) + display_string (scm_i_symbol_chars (sym), 1, len, port, strategy); + else + display_string (scm_i_symbol_wide_chars (sym), 0, len, port, strategy); } static void @@ -398,7 +437,7 @@ print_extended_symbol (SCM sym, SCM port) len = scm_i_symbol_length (sym); strategy = PORT_CONVERSION_HANDLER (port); - scm_lfwrite ("#{", 2, port); + scm_lfwrite_unlocked ("#{", 2, port); for (pos = 0; pos < len; pos++) { @@ -421,12 +460,12 @@ print_extended_symbol (SCM sym, SCM port) } } - scm_lfwrite ("}#", 2, port); + scm_lfwrite_unlocked ("}#", 2, port); } /* FIXME: allow R6RS hex escapes instead of #{...}#. */ -void -scm_i_print_symbol_name (SCM sym, SCM port) +static void +print_symbol (SCM sym, SCM port) { if (symbol_has_extended_read_syntax (sym)) print_extended_symbol (sym, port); @@ -437,8 +476,8 @@ scm_i_print_symbol_name (SCM sym, SCM port) void scm_print_symbol_name (const char *str, size_t len, SCM port) { - SCM symbol = scm_from_locale_symboln (str, len); - scm_i_print_symbol_name (symbol, port); + SCM symbol = scm_from_utf8_symboln (str, len); + print_symbol (symbol, port); } /* Print generally. Handles both write and display according to PSTATE. @@ -457,7 +496,7 @@ static void iprin1 (SCM exp, SCM port, scm_print_state *pstate); scm_intprint (i, 8, port); \ else \ { \ - scm_puts ("x", port); \ + scm_puts_unlocked ("x", port); \ scm_intprint (i, 16, port); \ } \ } \ @@ -512,7 +551,7 @@ iprin1 (SCM exp, SCM port, scm_print_state *pstate) else if (SCM_IFLAGP (exp) && ((size_t) SCM_IFLAGNUM (exp) < (sizeof iflagnames / sizeof (char *)))) { - scm_puts (iflagnames [SCM_IFLAGNUM (exp)], port); + scm_puts_unlocked (iflagnames [SCM_IFLAGNUM (exp)], port); } else { @@ -533,7 +572,7 @@ iprin1 (SCM exp, SCM port, scm_print_state *pstate) goto print_struct; pwps = scm_i_port_with_print_state (port, pstate->handle); pstate->revealed = 1; - scm_call_generic_2 (print, exp, pwps); + scm_call_2 (print, exp, pwps); } else { @@ -601,16 +640,16 @@ iprin1 (SCM exp, SCM port, scm_print_state *pstate) case scm_tc7_symbol: if (scm_i_symbol_is_interned (exp)) { - scm_i_print_symbol_name (exp, port); + print_symbol (exp, port); scm_remember_upto_here_1 (exp); } else { - scm_puts ("#<uninterned-symbol ", port); - scm_i_print_symbol_name (exp, port); - scm_putc (' ', port); + scm_puts_unlocked ("#<uninterned-symbol ", port); + print_symbol (exp, port); + scm_putc_unlocked (' ', port); scm_uintprint (SCM_UNPACK (exp), 16, port); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); } break; case scm_tc7_variable: @@ -625,6 +664,12 @@ iprin1 (SCM exp, SCM port, scm_print_state *pstate) case scm_tc7_hashtable: scm_i_hashtable_print (exp, port, pstate); break; + case scm_tc7_weak_set: + scm_i_weak_set_print (exp, port, pstate); + break; + case scm_tc7_weak_table: + scm_i_weak_table_print (exp, port, pstate); + break; case scm_tc7_fluid: scm_i_fluid_print (exp, port, pstate); break; @@ -643,12 +688,6 @@ iprin1 (SCM exp, SCM port, scm_print_state *pstate) case scm_tc7_vm_cont: scm_i_vm_cont_print (exp, port, pstate); break; - case scm_tc7_prompt: - scm_i_prompt_print (exp, port, pstate); - break; - case scm_tc7_with_fluids: - scm_i_with_fluids_print (exp, port, pstate); - break; case scm_tc7_array: ENTER_NESTED_DATA (pstate, exp, circref); scm_i_print_array (exp, port, pstate); @@ -662,14 +701,11 @@ iprin1 (SCM exp, SCM port, scm_print_state *pstate) break; case scm_tc7_wvect: ENTER_NESTED_DATA (pstate, exp, circref); - if (SCM_IS_WHVEC (exp)) - scm_puts ("#wh(", port); - else - scm_puts ("#w(", port); + scm_puts_unlocked ("#w(", port); goto common_vector_printer; case scm_tc7_vector: ENTER_NESTED_DATA (pstate, exp, circref); - scm_puts ("#(", port); + scm_puts_unlocked ("#(", port); common_vector_printer: { register long i; @@ -681,43 +717,26 @@ iprin1 (SCM exp, SCM port, scm_print_state *pstate) last = pstate->length - 1; cutp = 1; } - if (SCM_I_WVECTP (exp)) - { - /* Elements of weak vectors may not be accessed via the - `SIMPLE_VECTOR_REF ()' macro. */ - for (i = 0; i < last; ++i) - { - scm_iprin1 (scm_c_vector_ref (exp, i), - port, pstate); - scm_putc (' ', port); - } - } - else - { - for (i = 0; i < last; ++i) - { - scm_iprin1 (SCM_SIMPLE_VECTOR_REF (exp, i), port, pstate); - scm_putc (' ', port); - } - } - + for (i = 0; i < last; ++i) + { + scm_iprin1 (scm_c_vector_ref (exp, i), port, pstate); + scm_putc_unlocked (' ', port); + } if (i == last) { /* CHECK_INTS; */ scm_iprin1 (scm_c_vector_ref (exp, i), port, pstate); } if (cutp) - scm_puts (" ...", port); - scm_putc (')', port); + scm_puts_unlocked (" ...", port); + scm_putc_unlocked (')', port); } EXIT_NESTED_DATA (pstate); break; case scm_tc7_port: { - register long i = SCM_PTOBNUM (exp); - if (i < scm_numptob - && scm_ptobs[i].print - && (scm_ptobs[i].print) (exp, port, pstate)) + scm_t_ptob_descriptor *ptob = SCM_PORT_DESCRIPTOR (exp); + if (ptob->print && ptob->print (exp, port, pstate)) break; goto punk; } @@ -862,7 +881,7 @@ display_string_as_utf8 (const void *str, int narrow_p, size_t len, /* INPUT was successfully converted, entirely; print the result. */ - scm_lfwrite (utf8_buf, utf8_len, port); + scm_lfwrite_unlocked (utf8_buf, utf8_len, port); printed += i - printed; } @@ -871,6 +890,54 @@ display_string_as_utf8 (const void *str, int narrow_p, size_t len, return len; } +/* Write STR to PORT as ISO-8859-1. STR is a LEN-codepoint string; it + is narrow if NARROW_P is true, wide otherwise. Return LEN. */ +static size_t +display_string_as_latin1 (const void *str, int narrow_p, size_t len, + SCM port, + scm_t_string_failed_conversion_handler strategy) +{ + size_t printed = 0; + + if (narrow_p) + { + scm_lfwrite_unlocked (str, len, port); + return len; + } + + while (printed < len) + { + char buf[256]; + size_t i; + + for (i = 0; i < sizeof(buf) && printed < len; i++, printed++) + { + scm_t_wchar c = STR_REF (str, printed); + + if (c < 256) + buf[i] = c; + else + break; + } + + scm_lfwrite_unlocked (buf, i, port); + + if (i < sizeof(buf) && printed < len) + { + if (strategy == SCM_FAILED_CONVERSION_ERROR) + break; + else if (strategy == SCM_FAILED_CONVERSION_ESCAPE_SEQUENCE) + write_character_escaped (STR_REF (str, printed), 1, port); + else + /* STRATEGY is `SCM_FAILED_CONVERSION_QUESTION_MARK'. */ + display_string ("?", 1, 1, port, strategy); + printed++; + } + } + + return printed; +} + /* Convert STR through PORT's output conversion descriptor and write the output to PORT. Return the number of codepoints written. */ static size_t @@ -879,9 +946,9 @@ display_string_using_iconv (const void *str, int narrow_p, size_t len, scm_t_string_failed_conversion_handler strategy) { size_t printed; - scm_t_port *pt; + scm_t_iconv_descriptors *id; - pt = SCM_PTAB_ENTRY (port); + id = scm_i_port_iconv_descriptors (port); printed = 0; @@ -910,7 +977,7 @@ display_string_using_iconv (const void *str, int narrow_p, size_t len, output = encoded_output; output_left = sizeof (encoded_output); - done = iconv (pt->output_cd, &input, &input_left, + done = iconv (id->output_cd, &input, &input_left, &output, &output_left); output_len = sizeof (encoded_output) - output_left; @@ -920,10 +987,10 @@ display_string_using_iconv (const void *str, int narrow_p, size_t len, int errno_save = errno; /* Reset the `iconv' state. */ - iconv (pt->output_cd, NULL, NULL, NULL, NULL); + iconv (id->output_cd, NULL, NULL, NULL, NULL); /* Print the OUTPUT_LEN bytes successfully converted. */ - scm_lfwrite (encoded_output, output_len, port); + scm_lfwrite_unlocked (encoded_output, output_len, port); /* See how many input codepoints these OUTPUT_LEN bytes corresponds to. */ @@ -958,7 +1025,7 @@ display_string_using_iconv (const void *str, int narrow_p, size_t len, { /* INPUT was successfully converted, entirely; print the result. */ - scm_lfwrite (encoded_output, output_len, port); + scm_lfwrite_unlocked (encoded_output, output_len, port); codepoints_read = i - printed; printed += codepoints_read; } @@ -978,22 +1045,17 @@ static size_t display_string (const void *str, int narrow_p, size_t len, SCM port, scm_t_string_failed_conversion_handler strategy) - { scm_t_port *pt; pt = SCM_PTAB_ENTRY (port); - if (pt->output_cd == (iconv_t) -1) - /* Initialize the conversion descriptors, if needed. */ - scm_i_set_port_encoding_x (port, pt->encoding); - - /* FIXME: In 2.1, add a flag to determine whether a port is UTF-8. */ - if (pt->output_cd == (iconv_t) -1) + if (pt->encoding_mode == SCM_PORT_ENCODING_MODE_UTF8) return display_string_as_utf8 (str, narrow_p, len, port); + else if (pt->encoding_mode == SCM_PORT_ENCODING_MODE_LATIN1) + return display_string_as_latin1 (str, narrow_p, len, port, strategy); else - return display_string_using_iconv (str, narrow_p, len, - port, strategy); + return display_string_using_iconv (str, narrow_p, len, port, strategy); } /* Attempt to display CH to PORT according to STRATEGY. Return non-zero @@ -1038,7 +1100,7 @@ write_character_escaped (scm_t_wchar ch, int string_escapes_p, SCM port) /* Use special escapes for some C0 controls. */ buf[0] = '\\'; buf[1] = escapes[ch - 0x07]; - scm_lfwrite (buf, 2, port); + scm_lfwrite_unlocked (buf, 2, port); } else if (!SCM_R6RS_ESCAPES_P) { @@ -1048,7 +1110,7 @@ write_character_escaped (scm_t_wchar ch, int string_escapes_p, SCM port) buf[1] = 'x'; buf[2] = hex[ch / 16]; buf[3] = hex[ch % 16]; - scm_lfwrite (buf, 4, port); + scm_lfwrite_unlocked (buf, 4, port); } else if (ch <= 0xFFFF) { @@ -1058,7 +1120,7 @@ write_character_escaped (scm_t_wchar ch, int string_escapes_p, SCM port) buf[3] = hex[(ch & 0xF00) >> 8]; buf[4] = hex[(ch & 0xF0) >> 4]; buf[5] = hex[(ch & 0xF)]; - scm_lfwrite (buf, 6, port); + scm_lfwrite_unlocked (buf, 6, port); } else if (ch > 0xFFFF) { @@ -1070,7 +1132,7 @@ write_character_escaped (scm_t_wchar ch, int string_escapes_p, SCM port) buf[5] = hex[(ch & 0xF00) >> 8]; buf[6] = hex[(ch & 0xF0) >> 4]; buf[7] = hex[(ch & 0xF)]; - scm_lfwrite (buf, 8, port); + scm_lfwrite_unlocked (buf, 8, port); } } else @@ -1093,7 +1155,7 @@ write_character_escaped (scm_t_wchar ch, int string_escapes_p, SCM port) buf[i] = 'x'; i --; buf[i] = '\\'; - scm_lfwrite (buf + i, 9 - i, port); + scm_lfwrite_unlocked (buf + i, 9 - i, port); } } else @@ -1103,7 +1165,7 @@ write_character_escaped (scm_t_wchar ch, int string_escapes_p, SCM port) name = scm_i_charname (SCM_MAKE_CHAR (ch)); if (name != NULL) - scm_puts (name, port); + scm_puts_unlocked (name, port); else PRINT_CHAR_ESCAPE (ch, port); } @@ -1197,14 +1259,14 @@ void scm_intprint (scm_t_intmax n, int radix, SCM port) { char num_buf[SCM_INTBUFLEN]; - scm_lfwrite (num_buf, scm_iint2str (n, radix, num_buf), port); + scm_lfwrite_unlocked (num_buf, scm_iint2str (n, radix, num_buf), port); } void scm_uintprint (scm_t_uintmax n, int radix, SCM port) { char num_buf[SCM_INTBUFLEN]; - scm_lfwrite (num_buf, scm_iuint2str (n, radix, num_buf), port); + scm_lfwrite_unlocked (num_buf, scm_iuint2str (n, radix, num_buf), port); } /* Print an object of unrecognized type. @@ -1213,19 +1275,19 @@ scm_uintprint (scm_t_uintmax n, int radix, SCM port) void scm_ipruk (char *hdr, SCM ptr, SCM port) { - scm_puts ("#<unknown-", port); - scm_puts (hdr, port); + scm_puts_unlocked ("#<unknown-", port); + scm_puts_unlocked (hdr, port); if (1) /* (scm_in_heap_p (ptr)) */ /* FIXME */ { - scm_puts (" (0x", port); + scm_puts_unlocked (" (0x", port); scm_uintprint (SCM_CELL_WORD_0 (ptr), 16, port); - scm_puts (" . 0x", port); + scm_puts_unlocked (" . 0x", port); scm_uintprint (SCM_CELL_WORD_1 (ptr), 16, port); - scm_puts (") @", port); + scm_puts_unlocked (") @", port); } - scm_puts (" 0x", port); + scm_puts_unlocked (" 0x", port); scm_uintprint (SCM_UNPACK (ptr), 16, port); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); } @@ -1236,7 +1298,7 @@ scm_iprlist (char *hdr, SCM exp, int tlr, SCM port, scm_print_state *pstate) { register SCM hare, tortoise; long floor = pstate->top - 2; - scm_puts (hdr, port); + scm_puts_unlocked (hdr, port); /* CHECK_INTS; */ if (pstate->fancyp) goto fancy_printing; @@ -1266,18 +1328,18 @@ scm_iprlist (char *hdr, SCM exp, int tlr, SCM port, scm_print_state *pstate) if (scm_is_eq (PSTATE_STACK_REF(pstate, i), exp)) goto circref; PUSH_REF (pstate, exp); - scm_putc (' ', port); + scm_putc_unlocked (' ', port); /* CHECK_INTS; */ scm_iprin1 (SCM_CAR (exp), port, pstate); } if (!SCM_NULL_OR_NIL_P (exp)) { - scm_puts (" . ", port); + scm_puts_unlocked (" . ", port); scm_iprin1 (exp, port, pstate); } end: - scm_putc (tlr, port); + scm_putc_unlocked (tlr, port); pstate->top = floor + 2; return; @@ -1298,7 +1360,7 @@ fancy_printing: { if (n == 0) { - scm_puts (" ...", port); + scm_puts_unlocked (" ...", port); goto skip_tail; } else @@ -1306,14 +1368,14 @@ fancy_printing: } PUSH_REF(pstate, exp); ++pstate->list_offset; - scm_putc (' ', port); + scm_putc_unlocked (' ', port); /* CHECK_INTS; */ scm_iprin1 (SCM_CAR (exp), port, pstate); } } if (!SCM_NULL_OR_NIL_P (exp)) { - scm_puts (" . ", port); + scm_puts_unlocked (" . ", port); scm_iprin1 (exp, port, pstate); } skip_tail: @@ -1324,7 +1386,7 @@ fancy_circref: pstate->list_offset -= pstate->top - floor - 2; circref: - scm_puts (" . ", port); + scm_puts_unlocked (" . ", port); print_circref (port, pstate, exp); goto end; } @@ -1349,7 +1411,11 @@ scm_write (SCM obj, SCM port) SCM_ASSERT (scm_valid_oport_value_p (port), port, SCM_ARG2, s_write); + scm_dynwind_begin (0); + scm_dynwind_lock_port (SCM_COERCE_OUTPORT (port)); scm_prin1 (obj, port, 1); + scm_dynwind_end (); + return SCM_UNSPECIFIED; } @@ -1364,7 +1430,11 @@ scm_display (SCM obj, SCM port) SCM_ASSERT (scm_valid_oport_value_p (port), port, SCM_ARG2, s_display); + scm_dynwind_begin (0); + scm_dynwind_lock_port (SCM_COERCE_OUTPORT (port)); scm_prin1 (obj, port, 0); + scm_dynwind_end (); + return SCM_UNSPECIFIED; } @@ -1477,7 +1547,7 @@ SCM_DEFINE (scm_newline, "newline", 0, 1, 0, SCM_VALIDATE_OPORT_VALUE (1, port); - scm_putc ('\n', SCM_COERCE_OUTPORT (port)); + scm_putc_unlocked ('\n', SCM_COERCE_OUTPORT (port)); return SCM_UNSPECIFIED; } #undef FUNC_NAME @@ -1522,7 +1592,7 @@ static int port_with_ps_print (SCM obj, SCM port, scm_print_state *pstate) { obj = SCM_PORT_WITH_PS_PORT (obj); - return scm_ptobs[SCM_PTOBNUM (obj)].print (obj, port, pstate); + return SCM_PORT_DESCRIPTOR (obj)->print (obj, port, pstate); } SCM @@ -1569,8 +1639,6 @@ scm_init_print () { SCM type; - scm_gc_register_root (&print_state_pool); - scm_gc_register_root (&scm_print_state_vtable); type = scm_make_vtable (scm_from_locale_string (SCM_PRINT_STATE_LAYOUT), SCM_BOOL_F); scm_set_struct_vtable_name_x (type, scm_from_latin1_symbol ("print-state")); diff --git a/libguile/print.h b/libguile/print.h index 4c60b52f1..80a9922f2 100644 --- a/libguile/print.h +++ b/libguile/print.h @@ -85,7 +85,6 @@ SCM_API void scm_intprint (scm_t_intmax n, int radix, SCM port); SCM_API void scm_uintprint (scm_t_uintmax n, int radix, SCM port); SCM_API void scm_ipruk (char *hdr, SCM ptr, SCM port); SCM_API void scm_iprlist (char *hdr, SCM exp, int tlr, SCM port, scm_print_state *pstate); -SCM_INTERNAL void scm_i_print_symbol_name (SCM sym, SCM port); SCM_API void scm_print_symbol_name (const char *str, size_t len, SCM port); SCM_API void scm_prin1 (SCM exp, SCM port, int writingp); SCM_API void scm_iprin1 (SCM exp, SCM port, scm_print_state *pstate); diff --git a/libguile/private-gc.h b/libguile/private-gc.h index 42514c1e2..4c691dd0b 100644 --- a/libguile/private-gc.h +++ b/libguile/private-gc.h @@ -1,7 +1,7 @@ /* * private-gc.h - private declarations for garbage collection. * - * Copyright (C) 2002, 03, 04, 05, 06, 07, 08, 09 Free Software Foundation, Inc. + * Copyright (C) 2002, 03, 04, 05, 06, 07, 08, 09, 11 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -49,18 +49,6 @@ typedef enum { return_on_error, abort_on_error } policy_on_error; #define SCM_MAX(A, B) ((A) > (B) ? (A) : (B)) #define SCM_MIN(A, B) ((A) < (B) ? (A) : (B)) -/* CELL_P checks a random word whether it has the right form for a - pointer to a cell. Use scm_i_find_heap_segment_containing_object - to find out whether it actually points to a real cell. - - The right form for a cell pointer is this: the low three bits must - be scm_tc3_cons, and when the scm_tc3_cons tag is stripped, the - resulting pointer must be correctly aligned. - scm_i_initialize_heap_segment_data guarantees that the test below - works. -*/ -#define CELL_P(x) ((SCM_UNPACK(x) & (sizeof(scm_t_cell)-1)) == scm_tc3_cons) - SCM_INTERNAL char const *scm_i_tag_name (scm_t_bits tag); /* MOVEME */ #endif diff --git a/libguile/procprop.c b/libguile/procprop.c index 36228d3f3..ff4648d00 100644 --- a/libguile/procprop.c +++ b/libguile/procprop.c @@ -1,6 +1,5 @@ -/* Copyright (C) 1995, 1996, 1998, 2000, 2001, 2003, 2004, 2006, - * 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. - * +/* Copyright (C) 1995,1996,1998,2000,2001,2003,2004, 2006, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version 3 of @@ -23,20 +22,16 @@ # include <config.h> #endif -#define SCM_BUILDING_DEPRECATED_CODE - #include "libguile/_scm.h" #include "libguile/alist.h" -#include "libguile/deprecation.h" -#include "libguile/deprecated.h" #include "libguile/eval.h" #include "libguile/procs.h" #include "libguile/gsubr.h" #include "libguile/smob.h" #include "libguile/root.h" #include "libguile/vectors.h" -#include "libguile/hashtab.h" +#include "libguile/weak-table.h" #include "libguile/programs.h" #include "libguile/validate.h" @@ -44,13 +39,9 @@ SCM_GLOBAL_SYMBOL (scm_sym_system_procedure, "system-procedure"); -#if (SCM_ENABLE_DEPRECATED == 1) -SCM_GLOBAL_SYMBOL (scm_sym_arity, "arity"); -#endif SCM_GLOBAL_SYMBOL (scm_sym_name, "name"); static SCM overrides; -static scm_i_pthread_mutex_t overrides_lock = SCM_I_PTHREAD_MUTEX_INITIALIZER; static SCM arity_overrides; @@ -59,9 +50,7 @@ scm_i_procedure_arity (SCM proc, int *req, int *opt, int *rest) { SCM o; - scm_i_pthread_mutex_lock (&overrides_lock); - o = scm_hashq_ref (arity_overrides, proc, SCM_BOOL_F); - scm_i_pthread_mutex_unlock (&overrides_lock); + o = scm_weak_table_refq (arity_overrides, proc, SCM_BOOL_F); if (scm_is_true (o)) { @@ -73,16 +62,18 @@ scm_i_procedure_arity (SCM proc, int *req, int *opt, int *rest) while (!SCM_PROGRAM_P (proc)) { - if (SCM_IMP (proc)) - return 0; - switch (SCM_TYP7 (proc)) + if (SCM_STRUCTP (proc)) + { + if (!SCM_STRUCT_APPLICABLE_P (proc)) + return 0; + proc = SCM_STRUCT_PROCEDURE (proc); + } + else if (SCM_HAS_TYP7 (proc, scm_tc7_smob)) { - case scm_tc7_smob: if (!SCM_SMOB_APPLICABLE_P (proc)) return 0; - if (!scm_i_program_arity - (SCM_SMOB_DESCRIPTOR (proc).apply_trampoline_objcode, - req, opt, rest)) + if (!scm_i_program_arity (SCM_SMOB_DESCRIPTOR (proc).apply_trampoline, + req, opt, rest)) return 0; /* The trampoline gets the smob too, which users don't @@ -90,14 +81,9 @@ scm_i_procedure_arity (SCM proc, int *req, int *opt, int *rest) *req -= 1; return 1; - case scm_tcs_struct: - if (!SCM_STRUCT_APPLICABLE_P (proc)) - return 0; - proc = SCM_STRUCT_PROCEDURE (proc); - break; - default: - return 0; } + else + return 0; } return scm_i_program_arity (proc, req, opt, rest); @@ -115,9 +101,7 @@ SCM_DEFINE (scm_set_procedure_minimum_arity_x, "set-procedure-minimum-arity!", SCM_VALIDATE_INT_COPY (3, opt, t); SCM_VALIDATE_BOOL (4, rest); - scm_i_pthread_mutex_lock (&overrides_lock); - scm_hashq_set_x (arity_overrides, proc, scm_list_3 (req, opt, rest)); - scm_i_pthread_mutex_unlock (&overrides_lock); + scm_weak_table_putq_x (arity_overrides, proc, scm_list_3 (req, opt, rest)); return SCM_UNDEFINED; } #undef FUNC_NAME @@ -156,9 +140,7 @@ SCM_DEFINE (scm_procedure_properties, "procedure-properties", 1, 0, 0, SCM_VALIDATE_PROC (1, proc); - scm_i_pthread_mutex_lock (&overrides_lock); - ret = scm_hashq_ref (overrides, proc, SCM_BOOL_F); - scm_i_pthread_mutex_unlock (&overrides_lock); + ret = scm_weak_table_refq (overrides, proc, SCM_BOOL_F); if (scm_is_false (ret)) { @@ -168,10 +150,6 @@ SCM_DEFINE (scm_procedure_properties, "procedure-properties", 1, 0, 0, ret = SCM_EOL; } -#if (SCM_ENABLE_DEPRECATED == 1) - ret = scm_acons (scm_sym_arity, scm_procedure_minimum_arity (proc), ret); -#endif - return ret; } #undef FUNC_NAME @@ -183,14 +161,7 @@ SCM_DEFINE (scm_set_procedure_properties_x, "set-procedure-properties!", 2, 0, 0 { SCM_VALIDATE_PROC (1, proc); -#if (SCM_ENABLE_DEPRECATED == 1) - if (scm_is_true (scm_assq (scm_sym_arity, alist))) - SCM_MISC_ERROR ("arity is a read-only property", SCM_EOL); -#endif - - scm_i_pthread_mutex_lock (&overrides_lock); - scm_hashq_set_x (overrides, proc, alist); - scm_i_pthread_mutex_unlock (&overrides_lock); + scm_weak_table_putq_x (overrides, proc, alist); return SCM_UNSPECIFIED; } @@ -203,13 +174,6 @@ SCM_DEFINE (scm_procedure_property, "procedure-property", 2, 0, 0, { SCM_VALIDATE_PROC (1, proc); -#if (SCM_ENABLE_DEPRECATED == 1) - if (scm_is_eq (key, scm_sym_arity)) - scm_c_issue_deprecation_warning - ("Accessing a procedure's arity via `procedure-property' is deprecated.\n" - "Use `procedure-minimum-arity instead."); -#endif - return scm_assq_ref (scm_procedure_properties (proc), key); } #undef FUNC_NAME @@ -224,13 +188,8 @@ SCM_DEFINE (scm_set_procedure_property_x, "set-procedure-property!", 3, 0, 0, SCM_VALIDATE_PROC (1, proc); -#if (SCM_ENABLE_DEPRECATED == 1) - if (scm_is_eq (key, scm_sym_arity)) - SCM_MISC_ERROR ("arity is a deprecated read-only property", SCM_EOL); -#endif - - scm_i_pthread_mutex_lock (&overrides_lock); - props = scm_hashq_ref (overrides, proc, SCM_BOOL_F); + scm_i_pthread_mutex_lock (&scm_i_misc_mutex); + props = scm_weak_table_refq (overrides, proc, SCM_BOOL_F); if (scm_is_false (props)) { if (SCM_PROGRAM_P (proc)) @@ -238,8 +197,8 @@ SCM_DEFINE (scm_set_procedure_property_x, "set-procedure-property!", 3, 0, 0, else props = SCM_EOL; } - scm_hashq_set_x (overrides, proc, scm_assq_set_x (props, key, val)); - scm_i_pthread_mutex_unlock (&overrides_lock); + scm_weak_table_putq_x (overrides, proc, scm_assq_set_x (props, key, val)); + scm_i_pthread_mutex_unlock (&scm_i_misc_mutex); return SCM_UNSPECIFIED; } @@ -251,8 +210,8 @@ SCM_DEFINE (scm_set_procedure_property_x, "set-procedure-property!", 3, 0, 0, void scm_init_procprop () { - overrides = scm_make_weak_key_hash_table (SCM_UNDEFINED); - arity_overrides = scm_make_weak_key_hash_table (SCM_UNDEFINED); + overrides = scm_c_make_weak_table (0, SCM_WEAK_TABLE_KIND_KEY); + arity_overrides = scm_c_make_weak_table (0, SCM_WEAK_TABLE_KIND_KEY); #include "libguile/procprop.x" } diff --git a/libguile/procprop.h b/libguile/procprop.h index 919fa4d3a..88e44ec30 100644 --- a/libguile/procprop.h +++ b/libguile/procprop.h @@ -3,7 +3,7 @@ #ifndef SCM_PROCPROP_H #define SCM_PROCPROP_H -/* Copyright (C) 1995,1996,1998,2000, 2006, 2008, 2009, 2010 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1998,2000, 2006, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -28,9 +28,6 @@ SCM_API SCM scm_sym_name; -#if (SCM_ENABLE_DEPRECATED == 1) -SCM_DEPRECATED SCM scm_sym_arity; -#endif SCM_API SCM scm_sym_system_procedure; diff --git a/libguile/procs.c b/libguile/procs.c index 59caed1b4..5899df035 100644 --- a/libguile/procs.c +++ b/libguile/procs.c @@ -47,21 +47,10 @@ SCM_DEFINE (scm_procedure_p, "procedure?", 1, 0, 0, "Return @code{#t} if @var{obj} is a procedure.") #define FUNC_NAME s_scm_procedure_p { - if (SCM_NIMP (obj)) - switch (SCM_TYP7 (obj)) - { - case scm_tcs_struct: - if (!((SCM_OBJ_CLASS_FLAGS (obj) & SCM_CLASSF_PURE_GENERIC) - || SCM_STRUCT_APPLICABLE_P (obj))) - break; - case scm_tc7_program: - return SCM_BOOL_T; - case scm_tc7_smob: - return scm_from_bool (SCM_SMOB_DESCRIPTOR (obj).apply); - default: - return SCM_BOOL_F; - } - return SCM_BOOL_F; + return scm_from_bool (SCM_PROGRAM_P (obj) + || (SCM_STRUCTP (obj) && SCM_STRUCT_APPLICABLE_P (obj)) + || (SCM_HAS_TYP7 (obj, scm_tc7_smob) + && SCM_SMOB_APPLICABLE_P (obj))); } #undef FUNC_NAME @@ -147,14 +136,15 @@ SCM_PRIMITIVE_GENERIC (scm_setter, "setter", 1, 0, 0, "applicable struct with a setter.") #define FUNC_NAME s_scm_setter { - SCM_GASSERT1 (SCM_STRUCTP (proc), g_scm_setter, proc, SCM_ARG1, FUNC_NAME); + if (SCM_UNLIKELY (!SCM_STRUCTP (proc))) + return scm_wta_dispatch_1 (g_scm_setter, proc, SCM_ARG1, FUNC_NAME); if (SCM_STRUCT_SETTER_P (proc)) return SCM_STRUCT_SETTER (proc); if (SCM_PUREGENERICP (proc) && SCM_IS_A_P (proc, scm_class_generic_with_setter)) /* FIXME: might not be an accessor */ return SCM_GENERIC_SETTER (proc); - SCM_WTA_DISPATCH_1 (g_scm_setter, proc, SCM_ARG1, FUNC_NAME); + return scm_wta_dispatch_1 (g_scm_setter, proc, SCM_ARG1, FUNC_NAME); return SCM_BOOL_F; /* not reached */ } #undef FUNC_NAME diff --git a/libguile/programs.c b/libguile/programs.c index b84f84bd3..128e0312a 100644 --- a/libguile/programs.c +++ b/libguile/programs.c @@ -82,22 +82,22 @@ scm_i_program_print (SCM program, SCM port, scm_print_state *pstate) if (SCM_PROGRAM_IS_CONTINUATION (program)) { /* twingliness */ - scm_puts ("#<continuation ", port); + scm_puts_unlocked ("#<continuation ", port); scm_uintprint (SCM_UNPACK (program), 16, port); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); } else if (SCM_PROGRAM_IS_PARTIAL_CONTINUATION (program)) { /* twingliness */ - scm_puts ("#<partial-continuation ", port); + scm_puts_unlocked ("#<partial-continuation ", port); scm_uintprint (SCM_UNPACK (program), 16, port); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); } else if (scm_is_false (write_program) || print_error) { - scm_puts ("#<program ", port); + scm_puts_unlocked ("#<program ", port); scm_uintprint (SCM_UNPACK (program), 16, port); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); } else { diff --git a/libguile/programs.h b/libguile/programs.h index d0e788e51..d53fd8f84 100644 --- a/libguile/programs.h +++ b/libguile/programs.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2001, 2009, 2010 Free Software Foundation, Inc. +/* Copyright (C) 2001, 2009, 2010, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -32,7 +32,7 @@ #define SCM_F_PROGRAM_IS_CONTINUATION 0x800 #define SCM_F_PROGRAM_IS_PARTIAL_CONTINUATION 0x1000 -#define SCM_PROGRAM_P(x) (!SCM_IMP (x) && SCM_TYP7(x) == scm_tc7_program) +#define SCM_PROGRAM_P(x) (SCM_HAS_TYP7 (x, scm_tc7_program)) #define SCM_PROGRAM_OBJCODE(x) (SCM_CELL_OBJECT_1 (x)) #define SCM_PROGRAM_OBJTABLE(x) (SCM_CELL_OBJECT_2 (x)) #define SCM_PROGRAM_FREE_VARIABLES(x) (SCM_CELL_OBJECT_LOC (x, 3)) diff --git a/libguile/promises.c b/libguile/promises.c index 3bbb489d2..dcd0ac383 100644 --- a/libguile/promises.c +++ b/libguile/promises.c @@ -88,11 +88,11 @@ static int promise_print (SCM exp, SCM port, scm_print_state *pstate) { int writingp = SCM_WRITINGP (pstate); - scm_puts ("#<promise ", port); + scm_puts_unlocked ("#<promise ", port); SCM_SET_WRITINGP (pstate, 1); scm_iprin1 (SCM_PROMISE_DATA (exp), port, pstate); SCM_SET_WRITINGP (pstate, writingp); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); return !0; } diff --git a/libguile/pthread-threads.h b/libguile/pthread-threads.h index 4c67b1857..b5fae4e89 100644 --- a/libguile/pthread-threads.h +++ b/libguile/pthread-threads.h @@ -29,27 +29,15 @@ #include <pthread.h> #include <sched.h> -/* `libgc' defines wrapper procedures for pthread calls. */ -#include "libguile/bdw-gc.h" - /* Threads */ #define scm_i_pthread_t pthread_t #define scm_i_pthread_self pthread_self -#define scm_i_pthread_create GC_pthread_create -#define scm_i_pthread_detach GC_pthread_detach +#define scm_i_pthread_create pthread_create +#define scm_i_pthread_detach pthread_detach -#if SCM_HAVE_GC_PTHREAD_EXIT -#define scm_i_pthread_exit GC_pthread_exit -#else #define scm_i_pthread_exit pthread_exit -#endif - -#if SCM_HAVE_GC_PTHREAD_CANCEL -#define scm_i_pthread_cancel GC_pthread_cancel -#else #define scm_i_pthread_cancel pthread_cancel -#endif #define scm_i_pthread_cleanup_push pthread_cleanup_push #define scm_i_pthread_cleanup_pop pthread_cleanup_pop @@ -57,11 +45,7 @@ /* Signals */ -#if SCM_HAVE_GC_PTHREAD_SIGMASK -#define scm_i_pthread_sigmask GC_pthread_sigmask -#else #define scm_i_pthread_sigmask pthread_sigmask -#endif /* Mutexes */ diff --git a/libguile/r6rs-ports.c b/libguile/r6rs-ports.c index e8674299d..60ba38caa 100644 --- a/libguile/r6rs-ports.c +++ b/libguile/r6rs-ports.c @@ -84,17 +84,14 @@ make_bip (SCM bv) scm_t_port *c_port; const unsigned long mode_bits = SCM_OPN | SCM_RDNG; - scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex); + port = scm_c_make_port_with_encoding (bytevector_input_port_type, + mode_bits, + NULL, /* encoding */ + SCM_FAILED_CONVERSION_ERROR, + SCM_UNPACK (bv)); - port = scm_new_port_table_entry (bytevector_input_port_type); c_port = SCM_PTAB_ENTRY (port); - /* Match the expectation of `binary-port?'. */ - c_port->encoding = NULL; - - /* Prevent BV from being GC'd. */ - SCM_SETSTREAM (port, SCM_UNPACK (bv)); - /* Have the port directly access the bytevector. */ c_bv = (char *) SCM_BYTEVECTOR_CONTENTS (bv); c_len = SCM_BYTEVECTOR_LENGTH (bv); @@ -103,11 +100,6 @@ make_bip (SCM bv) c_port->read_end = (unsigned char *) c_bv + c_len; c_port->read_buf_size = c_len; - /* Mark PORT as open, readable and unbuffered (hmm, how elegant...). */ - SCM_SET_CELL_TYPE (port, bytevector_input_port_type | mode_bits); - - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); - return port; } @@ -312,27 +304,19 @@ make_cbip (SCM read_proc, SCM get_position_proc, SCM_SIMPLE_VECTOR_SET (method_vector, 2, set_position_proc); SCM_SIMPLE_VECTOR_SET (method_vector, 3, close_proc); - scm_i_pthread_mutex_lock (&scm_i_port_table_mutex); + port = scm_c_make_port_with_encoding (custom_binary_input_port_type, + mode_bits, + NULL, /* encoding */ + SCM_FAILED_CONVERSION_ERROR, + SCM_UNPACK (method_vector)); - port = scm_new_port_table_entry (custom_binary_input_port_type); c_port = SCM_PTAB_ENTRY (port); - /* Match the expectation of `binary-port?'. */ - c_port->encoding = NULL; - - /* Attach it the method vector. */ - SCM_SETSTREAM (port, SCM_UNPACK (method_vector)); - /* Have the port directly access the buffer (bytevector). */ c_port->read_pos = c_port->read_buf = (unsigned char *) c_bv; c_port->read_end = (unsigned char *) c_bv; c_port->read_buf_size = c_len; - /* Mark PORT as open, readable and unbuffered (hmm, how elegant...). */ - SCM_SET_CELL_TYPE (port, custom_binary_input_port_type | mode_bits); - - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); - return port; } @@ -491,7 +475,7 @@ SCM_DEFINE (scm_get_bytevector_n, "get-bytevector-n", 2, 0, 0, if (SCM_LIKELY (c_count > 0)) /* XXX: `scm_c_read ()' does not update the port position. */ - c_read = scm_c_read (port, c_bv, c_count); + c_read = scm_c_read_unlocked (port, c_bv, c_count); else /* Don't invoke `scm_c_read ()' since it may block. */ c_read = 0; @@ -538,7 +522,7 @@ SCM_DEFINE (scm_get_bytevector_n_x, "get-bytevector-n!", 4, 0, 0, scm_out_of_range (FUNC_NAME, count); if (SCM_LIKELY (c_count > 0)) - c_read = scm_c_read (port, c_bv + c_start, c_count); + c_read = scm_c_read_unlocked (port, c_bv + c_start, c_count); else /* Don't invoke `scm_c_read ()' since it may block. */ c_read = 0; @@ -593,7 +577,7 @@ SCM_DEFINE (scm_get_bytevector_some, "get-bytevector-some", 1, 0, 0, } /* We can't use `scm_c_read ()' since it blocks. */ - c_chr = scm_getc (port); + c_chr = scm_getc_unlocked (port); if (c_chr != EOF) { c_bv[c_total] = (char) c_chr; @@ -618,7 +602,8 @@ SCM_DEFINE (scm_get_bytevector_some, "get-bytevector-some", 1, 0, 0, c_len = (unsigned) c_total; } - result = scm_c_take_gc_bytevector ((signed char *) c_bv, c_len); + result = scm_c_take_gc_bytevector ((signed char *) c_bv, c_len, + SCM_BOOL_F); } return result; @@ -657,7 +642,7 @@ SCM_DEFINE (scm_get_bytevector_all, "get-bytevector-all", 1, 0, 0, /* `scm_c_read ()' blocks until C_COUNT bytes are available or EOF is reached. */ - c_read = scm_c_read (port, c_bv + c_total, c_count); + c_read = scm_c_read_unlocked (port, c_bv + c_total, c_count); c_total += c_read, c_count -= c_read; } while (!SCM_EOF_OBJECT_P (scm_peek_char (port))); @@ -677,7 +662,8 @@ SCM_DEFINE (scm_get_bytevector_all, "get-bytevector-all", 1, 0, 0, c_len = (unsigned) c_total; } - result = scm_c_take_gc_bytevector ((signed char *) c_bv, c_len); + result = scm_c_take_gc_bytevector ((signed char *) c_bv, c_len, + SCM_BOOL_F); } return result; @@ -702,7 +688,7 @@ SCM_DEFINE (scm_put_u8, "put-u8", 2, 0, 0, SCM_VALIDATE_BINARY_OUTPUT_PORT (1, port); c_octet = scm_to_uint8 (octet); - scm_putc ((char) c_octet, port); + scm_putc_unlocked ((char) c_octet, port); return SCM_UNSPECIFIED; } @@ -745,7 +731,7 @@ SCM_DEFINE (scm_put_bytevector, "put-bytevector", 2, 2, 0, else c_start = 0, c_count = c_len; - scm_c_write (port, c_bv + c_start, c_count); + scm_c_write_unlocked (port, c_bv + c_start, c_count); return SCM_UNSPECIFIED; } @@ -827,26 +813,19 @@ make_bop (void) scm_t_bop_buffer *buf; const unsigned long mode_bits = SCM_OPN | SCM_WRTNG; - scm_i_pthread_mutex_lock (&scm_i_port_table_mutex); - - port = scm_new_port_table_entry (bytevector_output_port_type); - c_port = SCM_PTAB_ENTRY (port); - - /* Match the expectation of `binary-port?'. */ - c_port->encoding = NULL; - buf = (scm_t_bop_buffer *) scm_gc_malloc (sizeof (* buf), SCM_GC_BOP); bop_buffer_init (buf); - c_port->write_buf = c_port->write_pos = c_port->write_end = NULL; - c_port->write_buf_size = 0; - - SCM_SET_BOP_BUFFER (port, buf); + port = scm_c_make_port_with_encoding (bytevector_output_port_type, + mode_bits, + NULL, /* encoding */ + SCM_FAILED_CONVERSION_ERROR, + (scm_t_bits)buf); - /* Mark PORT as open and writable. */ - SCM_SET_CELL_TYPE (port, bytevector_output_port_type | mode_bits); + c_port = SCM_PTAB_ENTRY (port); - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); + c_port->write_buf = c_port->write_pos = c_port->write_end = NULL; + c_port->write_buf_size = 0; /* Make the bop procedure. */ SCM_NEWSMOB (bop_proc, bytevector_output_port_procedure, buf); @@ -919,7 +898,7 @@ SCM_SMOB_APPLY (bytevector_output_port_procedure, bop_buffer_init (buf); if (result_buf.len == 0) - bv = scm_c_take_gc_bytevector (NULL, 0); + bv = scm_c_take_gc_bytevector (NULL, 0, SCM_BOOL_F); else { if (result_buf.total_len > result_buf.len) @@ -930,7 +909,7 @@ SCM_SMOB_APPLY (bytevector_output_port_procedure, SCM_GC_BOP); bv = scm_c_take_gc_bytevector ((signed char *) result_buf.buffer, - result_buf.len); + result_buf.len, SCM_BOOL_F); } return bv; @@ -986,26 +965,18 @@ make_cbop (SCM write_proc, SCM get_position_proc, SCM_SIMPLE_VECTOR_SET (method_vector, 2, set_position_proc); SCM_SIMPLE_VECTOR_SET (method_vector, 3, close_proc); - scm_i_pthread_mutex_lock (&scm_i_port_table_mutex); + port = scm_c_make_port_with_encoding (custom_binary_output_port_type, + mode_bits, + NULL, /* encoding */ + SCM_FAILED_CONVERSION_ERROR, + SCM_UNPACK (method_vector)); - port = scm_new_port_table_entry (custom_binary_output_port_type); c_port = SCM_PTAB_ENTRY (port); - /* Match the expectation of `binary-port?'. */ - c_port->encoding = NULL; - - /* Attach it the method vector. */ - SCM_SETSTREAM (port, SCM_UNPACK (method_vector)); - /* Have the port directly access the buffer (bytevector). */ c_port->write_buf = c_port->write_pos = c_port->write_end = NULL; c_port->write_buf_size = c_port->read_buf_size = 0; - /* Mark PORT as open, writable and unbuffered. */ - SCM_SET_CELL_TYPE (port, custom_binary_output_port_type | mode_bits); - - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); - return port; } @@ -1103,13 +1074,8 @@ make_tp (SCM binary_port, unsigned long mode) scm_t_port *c_port; const unsigned long mode_bits = SCM_OPN | mode; - scm_i_pthread_mutex_lock (&scm_i_port_table_mutex); - - port = scm_new_port_table_entry (transcoded_port_type); - - SCM_SETSTREAM (port, SCM_UNPACK (binary_port)); - - SCM_SET_CELL_TYPE (port, transcoded_port_type | mode_bits); + port = scm_c_make_port (transcoded_port_type, mode_bits, + SCM_UNPACK (binary_port)); if (SCM_INPUT_PORT_P (port)) { @@ -1122,15 +1088,13 @@ make_tp (SCM binary_port, unsigned long mode) SCM_SET_CELL_WORD_0 (port, SCM_CELL_WORD_0 (port) & ~SCM_BUF0); } - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); - return port; } static void tp_write (SCM port, const void *data, size_t size) { - scm_c_write (SCM_TP_BINARY_PORT (port), data, size); + scm_c_write_unlocked (SCM_TP_BINARY_PORT (port), data, size); } static int @@ -1148,7 +1112,7 @@ tp_fill_input (SCM port) scm_force_output (bport); if (c_bport->read_pos >= c_bport->read_end) - scm_fill_input (bport); + scm_fill_input_unlocked (bport); count = c_bport->read_end - c_bport->read_pos; if (count > c_port->read_buf_size) @@ -1185,7 +1149,7 @@ tp_flush (SCM port) We just throw away the data when the underlying port is closed. */ if (SCM_OPOUTPORTP (binary_port)) - scm_c_write (binary_port, c_port->write_buf, count); + scm_c_write_unlocked (binary_port, c_port->write_buf, count); c_port->write_pos = c_port->write_buf; c_port->rw_active = SCM_PORT_NEITHER; @@ -1267,7 +1231,7 @@ SCM_DEFINE (scm_get_string_n_x, for (j = c_start; j < c_end; j++) { - c = scm_getc (port); + c = scm_getc_unlocked (port); if (c == EOF) { size_t chars_read = j - c_start; diff --git a/libguile/rdelim.c b/libguile/rdelim.c index 9d1496795..c8c7d8b43 100644 --- a/libguile/rdelim.c +++ b/libguile/rdelim.c @@ -79,13 +79,13 @@ SCM_DEFINE (scm_read_delimited_x, "%read-delimited!", 3, 3, 0, { size_t k; - c = scm_getc (port); + c = scm_getc_unlocked (port); for (k = 0; k < num_delims; k++) { if (scm_i_string_ref (delims, k) == c) { if (scm_is_false (gobble)) - scm_ungetc (c, port); + scm_ungetc_unlocked (c, port); return scm_cons (SCM_MAKE_CHAR (c), scm_from_size_t (j - cstart)); @@ -149,7 +149,7 @@ SCM_DEFINE (scm_read_line, "%read-line", 0, 1, 0, } else { - buf[index] = scm_getc (port); + buf[index] = scm_getc_unlocked (port); switch (buf[index]) { case EOF: diff --git a/libguile/read.c b/libguile/read.c index 222891b7f..7c003b4e1 100644 --- a/libguile/read.c +++ b/libguile/read.c @@ -25,7 +25,6 @@ #endif #include <stdio.h> -#include <ctype.h> #include <string.h> #include <unistd.h> #include <unicase.h> @@ -258,13 +257,13 @@ read_token (SCM port, scm_t_read_opts *opts, { int chr; - chr = scm_get_byte_or_eof (port); + chr = scm_get_byte_or_eof_unlocked (port); if (chr == EOF) return 0; else if (CHAR_IS_DELIMITER (chr)) { - scm_unget_byte (chr, port); + scm_unget_byte_unlocked (chr, port); return 0; } else @@ -330,7 +329,7 @@ flush_ws (SCM port, scm_t_read_opts *opts, const char *eoferr) { scm_t_wchar c; while (1) - switch (c = scm_getc (port)) + switch (c = scm_getc_unlocked (port)) { case EOF: goteof: @@ -345,7 +344,7 @@ flush_ws (SCM port, scm_t_read_opts *opts, const char *eoferr) case ';': lp: - switch (c = scm_getc (port)) + switch (c = scm_getc_unlocked (port)) { case EOF: goto goteof; @@ -357,7 +356,7 @@ flush_ws (SCM port, scm_t_read_opts *opts, const char *eoferr) break; case '#': - switch (c = scm_getc (port)) + switch (c = scm_getc_unlocked (port)) { case EOF: eoferr = "read_sharp"; @@ -376,7 +375,7 @@ flush_ws (SCM port, scm_t_read_opts *opts, const char *eoferr) } /* fall through */ default: - scm_ungetc (c, port); + scm_ungetc_unlocked (c, port); return '#'; } break; @@ -430,7 +429,7 @@ scm_read_sexp (scm_t_wchar chr, SCM port, scm_t_read_opts *opts) if (terminating_char == c) return SCM_EOL; - scm_ungetc (c, port); + scm_ungetc_unlocked (c, port); tmp = scm_read_expression (port, opts); /* Note that it is possible for scm_read_expression to return @@ -458,7 +457,7 @@ scm_read_sexp (scm_t_wchar chr, SCM port, scm_t_read_opts *opts) "in pair: mismatched close paren: ~A", scm_list_1 (SCM_MAKE_CHAR (c))); - scm_ungetc (c, port); + scm_ungetc_unlocked (c, port); tmp = scm_read_expression (port, opts); /* See above note about scm_sym_dot. */ @@ -547,7 +546,7 @@ scm_read_sexp (scm_t_wchar chr, SCM port, scm_t_read_opts *opts) c = 0; \ while (i < ndigits) \ { \ - a = scm_getc (port); \ + a = scm_getc_unlocked (port); \ if (a == EOF) \ goto str_eof; \ if (terminator \ @@ -577,13 +576,13 @@ skip_intraline_whitespace (SCM port) do { - c = scm_getc (port); + c = scm_getc_unlocked (port); if (c == EOF) return; } while (c == '\t' || uc_is_general_category (c, UC_SPACE_SEPARATOR)); - scm_ungetc (c, port); + scm_ungetc_unlocked (c, port); } static SCM @@ -601,7 +600,7 @@ scm_read_string (int chr, SCM port, scm_t_read_opts *opts) long line = SCM_LINUM (port); int column = SCM_COL (port) - 1; - while ('"' != (c = scm_getc (port))) + while ('"' != (c = scm_getc_unlocked (port))) { if (c == EOF) { @@ -618,7 +617,7 @@ scm_read_string (int chr, SCM port, scm_t_read_opts *opts) if (c == '\\') { - switch (c = scm_getc (port)) + switch (c = scm_getc_unlocked (port)) { case EOF: goto str_eof; @@ -704,17 +703,16 @@ scm_read_number (scm_t_wchar chr, SCM port, scm_t_read_opts *opts) SCM result, str = SCM_EOL; char local_buffer[READER_BUFFER_SIZE], *buffer; size_t bytes_read; - scm_t_port *pt = SCM_PTAB_ENTRY (port); /* Need to capture line and column numbers here. */ long line = SCM_LINUM (port); int column = SCM_COL (port) - 1; - scm_ungetc (chr, port); + scm_ungetc_unlocked (chr, port); buffer = read_complete_token (port, opts, local_buffer, sizeof local_buffer, &bytes_read); - str = scm_from_stringn (buffer, bytes_read, pt->encoding, pt->ilseq_handler); + str = scm_from_port_stringn (buffer, bytes_read, port); result = scm_string_to_number (str, SCM_UNDEFINED); if (scm_is_false (result)) @@ -739,10 +737,9 @@ scm_read_mixed_case_symbol (scm_t_wchar chr, SCM port, scm_t_read_opts *opts) size_t bytes_read; int postfix = (opts->keyword_style == KEYWORD_STYLE_POSTFIX); char local_buffer[READER_BUFFER_SIZE], *buffer; - scm_t_port *pt = SCM_PTAB_ENTRY (port); SCM str; - scm_ungetc (chr, port); + scm_ungetc_unlocked (chr, port); buffer = read_complete_token (port, opts, local_buffer, sizeof local_buffer, &bytes_read); if (bytes_read > 0) @@ -750,8 +747,7 @@ scm_read_mixed_case_symbol (scm_t_wchar chr, SCM port, scm_t_read_opts *opts) if (postfix && ends_with_colon && (bytes_read > 1)) { - str = scm_from_stringn (buffer, bytes_read - 1, - pt->encoding, pt->ilseq_handler); + str = scm_from_port_stringn (buffer, bytes_read - 1, port); if (opts->case_insensitive_p) str = scm_string_downcase_x (str); @@ -759,8 +755,7 @@ scm_read_mixed_case_symbol (scm_t_wchar chr, SCM port, scm_t_read_opts *opts) } else { - str = scm_from_stringn (buffer, bytes_read, - pt->encoding, pt->ilseq_handler); + str = scm_from_port_stringn (buffer, bytes_read, port); if (opts->case_insensitive_p) str = scm_string_downcase_x (str); @@ -780,7 +775,6 @@ scm_read_number_and_radix (scm_t_wchar chr, SCM port, scm_t_read_opts *opts) char local_buffer[READER_BUFFER_SIZE], *buffer; unsigned int radix; SCM str; - scm_t_port *pt; switch (chr) { @@ -805,16 +799,15 @@ scm_read_number_and_radix (scm_t_wchar chr, SCM port, scm_t_read_opts *opts) break; default: - scm_ungetc (chr, port); - scm_ungetc ('#', port); + scm_ungetc_unlocked (chr, port); + scm_ungetc_unlocked ('#', port); radix = 10; } buffer = read_complete_token (port, opts, local_buffer, sizeof local_buffer, &read); - pt = SCM_PTAB_ENTRY (port); - str = scm_from_stringn (buffer, read, pt->encoding, pt->ilseq_handler); + str = scm_from_port_stringn (buffer, read, port); result = scm_string_to_number (str, scm_from_uint (radix)); @@ -850,12 +843,12 @@ scm_read_quote (int chr, SCM port, scm_t_read_opts *opts) { scm_t_wchar c; - c = scm_getc (port); + c = scm_getc_unlocked (port); if ('@' == c) p = scm_sym_uq_splicing; else { - scm_ungetc (c, port); + scm_ungetc_unlocked (c, port); p = scm_sym_unquote; } break; @@ -897,12 +890,12 @@ scm_read_syntax (int chr, SCM port, scm_t_read_opts *opts) { int c; - c = scm_getc (port); + c = scm_getc_unlocked (port); if ('@' == c) p = sym_unsyntax_splicing; else { - scm_ungetc (c, port); + scm_ungetc_unlocked (c, port); p = sym_unsyntax; } break; @@ -939,9 +932,9 @@ scm_read_semicolon_comment (int chr, SCM port) /* We use the get_byte here because there is no need to get the locale correct with comment input. This presumes that newline always represents itself no matter what the encoding is. */ - for (c = scm_get_byte_or_eof (port); + for (c = scm_get_byte_or_eof_unlocked (port); (c != EOF) && (c != '\n'); - c = scm_get_byte_or_eof (port)); + c = scm_get_byte_or_eof_unlocked (port)); return SCM_UNSPECIFIED; } @@ -984,7 +977,7 @@ scm_read_character (scm_t_wchar chr, SCM port, scm_t_read_opts *opts) if (bytes_read == 0) { - chr = scm_getc (port); + chr = scm_getc_unlocked (port); if (chr == EOF) scm_i_input_error (FUNC_NAME, port, "unexpected end of file " "while reading character", SCM_EOL); @@ -998,7 +991,9 @@ scm_read_character (scm_t_wchar chr, SCM port, scm_t_read_opts *opts) /* Simple ASCII characters can be processed immediately. Also, simple ISO-8859-1 characters can be processed immediately if the encoding for this port is ISO-8859-1. */ - if (bytes_read == 1 && ((unsigned char) buffer[0] <= 127 || pt->encoding == NULL)) + if (bytes_read == 1 && + ((unsigned char) buffer[0] <= 127 + || pt->encoding_mode == SCM_PORT_ENCODING_MODE_LATIN1)) { SCM_COL (port) += 1; return SCM_MAKE_CHAR (buffer[0]); @@ -1006,8 +1001,7 @@ scm_read_character (scm_t_wchar chr, SCM port, scm_t_read_opts *opts) /* Otherwise, convert the buffer into a proper scheme string for processing. */ - charname = scm_from_stringn (buffer, bytes_read, pt->encoding, - pt->ilseq_handler); + charname = scm_from_port_stringn (buffer, bytes_read, port); charname_len = scm_i_string_length (charname); SCM_COL (port) += charname_len; cp = scm_i_string_ref (charname, 0); @@ -1115,14 +1109,14 @@ read_decimal_integer (SCM port, int c, ssize_t *resp) if (c == '-') { sign = -1; - c = scm_getc (port); + c = scm_getc_unlocked (port); } while ('0' <= c && c <= '9') { res = 10*res + c-'0'; got_it = 1; - c = scm_getc (port); + c = scm_getc_unlocked (port); } if (got_it) @@ -1153,11 +1147,11 @@ scm_read_array (int c, SCM port, scm_t_read_opts *opts, long line, int column) /* Disambiguate between '#f' and uniform floating point vectors. */ if (c == 'f') { - c = scm_getc (port); + c = scm_getc_unlocked (port); if (c != '3' && c != '6') { if (c != EOF) - scm_ungetc (c, port); + scm_ungetc_unlocked (c, port); return SCM_BOOL_F; } rank = 1; @@ -1180,7 +1174,7 @@ scm_read_array (int c, SCM port, scm_t_read_opts *opts, long line, int column) && tag_len < sizeof tag_buf / sizeof tag_buf[0]) { tag_buf[tag_len++] = c; - c = scm_getc (port); + c = scm_getc_unlocked (port); } if (tag_len == 0) tag = SCM_BOOL_T; @@ -1204,7 +1198,7 @@ scm_read_array (int c, SCM port, scm_t_read_opts *opts, long line, int column) if (c == '@') { - c = scm_getc (port); + c = scm_getc_unlocked (port); c = read_decimal_integer (port, c, &lbnd); } @@ -1212,7 +1206,7 @@ scm_read_array (int c, SCM port, scm_t_read_opts *opts, long line, int column) if (c == ':') { - c = scm_getc (port); + c = scm_getc_unlocked (port); c = read_decimal_integer (port, c, &len); if (len < 0) scm_i_input_error (NULL, port, @@ -1274,15 +1268,15 @@ static SCM scm_read_bytevector (scm_t_wchar chr, SCM port, scm_t_read_opts *opts, long line, int column) { - chr = scm_getc (port); + chr = scm_getc_unlocked (port); if (chr != 'u') goto syntax; - chr = scm_getc (port); + chr = scm_getc_unlocked (port); if (chr != '8') goto syntax; - chr = scm_getc (port); + chr = scm_getc_unlocked (port); if (chr != '(') goto syntax; @@ -1305,15 +1299,15 @@ scm_read_guile_bit_vector (scm_t_wchar chr, SCM port, scm_t_read_opts *opts, terribly inefficient but who cares? */ SCM s_bits = SCM_EOL; - for (chr = scm_getc (port); + for (chr = scm_getc_unlocked (port); (chr != EOF) && ((chr == '0') || (chr == '1')); - chr = scm_getc (port)) + chr = scm_getc_unlocked (port)) { s_bits = scm_cons ((chr == '0') ? SCM_BOOL_F : SCM_BOOL_T, s_bits); } if (chr != EOF) - scm_ungetc (chr, port); + scm_ungetc_unlocked (chr, port); return maybe_annotate_source (scm_bitvector (scm_reverse_x (s_bits, SCM_EOL)), @@ -1327,7 +1321,7 @@ scm_read_scsh_block_comment (scm_t_wchar chr, SCM port) for (;;) { - int c = scm_getc (port); + int c = scm_getc_unlocked (port); if (c == EOF) scm_i_input_error ("skip_block_comment", port, @@ -1360,7 +1354,7 @@ scm_read_shebang (scm_t_wchar chr, SCM port, scm_t_read_opts *opts) while (i <= READER_DIRECTIVE_NAME_MAX_SIZE) { - c = scm_getc (port); + c = scm_getc_unlocked (port); if (c == EOF) scm_i_input_error ("skip_block_comment", port, "unterminated `#! ... !#' comment", SCM_EOL); @@ -1368,7 +1362,7 @@ scm_read_shebang (scm_t_wchar chr, SCM port, scm_t_read_opts *opts) name[i++] = c; else if (CHAR_IS_DELIMITER (c)) { - scm_ungetc (c, port); + scm_ungetc_unlocked (c, port); name[i] = '\0'; if (0 == strcmp ("r6rs", name)) ; /* Silently ignore */ @@ -1390,12 +1384,12 @@ scm_read_shebang (scm_t_wchar chr, SCM port, scm_t_read_opts *opts) } else { - scm_ungetc (c, port); + scm_ungetc_unlocked (c, port); break; } } while (i > 0) - scm_ungetc (name[--i], port); + scm_ungetc_unlocked (name[--i], port); return scm_read_scsh_block_comment (chr, port); } @@ -1406,7 +1400,7 @@ scm_read_r6rs_block_comment (scm_t_wchar chr, SCM port) nested. So care must be taken. */ int nesting_level = 1; - int a = scm_getc (port); + int a = scm_getc_unlocked (port); if (a == EOF) scm_i_input_error ("scm_read_r6rs_block_comment", port, @@ -1414,7 +1408,7 @@ scm_read_r6rs_block_comment (scm_t_wchar chr, SCM port) while (nesting_level > 0) { - int b = scm_getc (port); + int b = scm_getc_unlocked (port); if (b == EOF) scm_i_input_error ("scm_read_r6rs_block_comment", port, @@ -1447,7 +1441,7 @@ scm_read_commented_expression (scm_t_wchar chr, SCM port, if (EOF == c) scm_i_input_error ("read_commented_expression", port, "no expression after #; comment", SCM_EOL); - scm_ungetc (c, port); + scm_ungetc_unlocked (c, port); scm_read_expression (port, opts); return SCM_UNSPECIFIED; } @@ -1466,7 +1460,7 @@ scm_read_extended_symbol (scm_t_wchar chr, SCM port) buf = scm_i_string_start_writing (buf); - while ((chr = scm_getc (port)) != EOF) + while ((chr = scm_getc_unlocked (port)) != EOF) { if (saw_brace) { @@ -1493,7 +1487,7 @@ scm_read_extended_symbol (scm_t_wchar chr, SCM port) that the extended read syntax would never put a `\' before an `x'. For now, we just ignore other instances of backslash in the string. */ - switch ((chr = scm_getc (port))) + switch ((chr = scm_getc_unlocked (port))) { case EOF: goto done; @@ -1582,7 +1576,7 @@ scm_read_sharp (scm_t_wchar chr, SCM port, scm_t_read_opts *opts, { SCM result; - chr = scm_getc (port); + chr = scm_getc_unlocked (port); result = scm_read_sharp_extension (chr, port, opts); if (!scm_is_eq (result, SCM_UNSPECIFIED)) @@ -1613,29 +1607,10 @@ scm_read_sharp (scm_t_wchar chr, SCM port, scm_t_read_opts *opts, case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '@': -#if SCM_ENABLE_DEPRECATED - /* See below for 'i' and 'e'. */ - case 'a': - case 'y': - case 'h': - case 'l': -#endif return (scm_read_array (chr, port, opts, line, column)); case 'i': case 'e': -#if SCM_ENABLE_DEPRECATED - { - /* When next char is '(', it really is an old-style - uniform array. */ - scm_t_wchar next_c = scm_getc (port); - if (next_c != EOF) - scm_ungetc (next_c, port); - if (next_c == '(') - return scm_read_array (chr, port, opts, line, column); - /* Fall through. */ - } -#endif case 'b': case 'B': case 'o': @@ -1691,7 +1666,7 @@ read_inner_expression (SCM port, scm_t_read_opts *opts) { scm_t_wchar chr; - chr = scm_getc (port); + chr = scm_getc_unlocked (port); switch (chr) { @@ -1811,7 +1786,7 @@ scm_read_expression (SCM port, scm_t_read_opts *opts) int c = flush_ws (port, opts, (char *) NULL); if (c == EOF) return SCM_EOF_VAL; - scm_ungetc (c, port); + scm_ungetc_unlocked (c, port); line = SCM_LINUM (port); column = SCM_COL (port); } @@ -1824,7 +1799,7 @@ scm_read_expression (SCM port, scm_t_read_opts *opts) new expression. For example, f{n - 1}(x) => ((f (- n 1)) x). */ for (;;) { - int chr = scm_getc (port); + int chr = scm_getc_unlocked (port); if (chr == '(') /* e(...) => (e ...) */ @@ -1846,7 +1821,7 @@ scm_read_expression (SCM port, scm_t_read_opts *opts) else { if (chr != EOF) - scm_ungetc (chr, port); + scm_ungetc_unlocked (chr, port); break; } maybe_annotate_source (expr, port, opts, line, column); @@ -1880,7 +1855,7 @@ SCM_DEFINE (scm_read, "read", 0, 1, 0, c = flush_ws (port, &opts, (char *) NULL); if (EOF == c) return SCM_EOF_VAL; - scm_ungetc (c, port); + scm_ungetc_unlocked (c, port); return (scm_read_expression (port, &opts)); } @@ -1975,6 +1950,15 @@ scm_get_hash_procedure (int c) #define SCM_ENCODING_SEARCH_SIZE (500) +static int +is_encoding_char (char c) +{ + if (c >= 'a' && c <= 'z') return 1; + if (c >= 'A' && c <= 'Z') return 1; + if (c >= '0' && c <= '9') return 1; + return strchr ("_-.:/,+=()", c) != NULL; +} + /* Search the first few hundred characters of a file for an Emacs-like coding declaration. Returns either NULL or a string whose storage has been allocated with `scm_gc_malloc ()'. */ @@ -1992,7 +1976,7 @@ scm_i_scan_for_encoding (SCM port) pt = SCM_PTAB_ENTRY (port); if (pt->rw_active == SCM_PORT_WRITE) - scm_flush (port); + scm_flush_unlocked (port); if (pt->rw_random) pt->rw_active = SCM_PORT_READ; @@ -2000,7 +1984,7 @@ scm_i_scan_for_encoding (SCM port) if (pt->read_pos == pt->read_end) { /* We can use the read buffer, and thus avoid a seek. */ - if (scm_fill_input (port) == EOF) + if (scm_fill_input_unlocked (port) == EOF) return NULL; bytes_read = pt->read_end - pt->read_pos; @@ -2025,7 +2009,7 @@ scm_i_scan_for_encoding (SCM port) if (SCM_FPORTP (port) && !SCM_FDES_RANDOM_P (SCM_FPORT_FDES (port))) return NULL; - bytes_read = scm_c_read (port, header, SCM_ENCODING_SEARCH_SIZE); + bytes_read = scm_c_read_unlocked (port, header, SCM_ENCODING_SEARCH_SIZE); header[bytes_read] = '\0'; scm_seek (port, scm_from_int (0), scm_from_int (SEEK_SET)); } @@ -2060,8 +2044,7 @@ scm_i_scan_for_encoding (SCM port) i = 0; while (encoding_start + i - header <= SCM_ENCODING_SEARCH_SIZE && encoding_start + i - header < bytes_read - && (isalnum ((int) encoding_start[i]) - || strchr ("_-.:/,+=()", encoding_start[i]) != NULL)) + && is_encoding_char (encoding_start[i])) i++; encoding_length = i; @@ -2069,8 +2052,6 @@ scm_i_scan_for_encoding (SCM port) return NULL; encoding = scm_gc_strndup (encoding_start, encoding_length, "encoding"); - for (i = 0; i < encoding_length; i++) - encoding[i] = toupper ((int) encoding[i]); /* push backwards to make sure we were in a comment */ in_comment = 0; @@ -2102,7 +2083,7 @@ scm_i_scan_for_encoding (SCM port) /* This wasn't in a comment */ return NULL; - if (utf8_bom && strcmp(encoding, "UTF-8")) + if (utf8_bom && strcasecmp (encoding, "UTF-8")) scm_misc_error (NULL, "the port input declares the encoding ~s but is encoded as UTF-8", scm_list_1 (scm_from_locale_string (encoding))); @@ -2143,9 +2124,8 @@ SCM_DEFINE (scm_file_encoding, "file-encoding", 1, 0, 0, /* Per-port read options. We store per-port read options in the 'port-read-options' key of the - port's alist, which is stored in 'scm_i_port_weak_hash'. The value - stored in the alist is a single integer that contains a two-bit field - for each read option. + port's alist. The value stored in the alist is a single integer that + contains a two-bit field for each read option. If a bit field contains READ_OPTION_INHERIT (3), that indicates that the applicable value should be inherited from the corresponding @@ -2180,13 +2160,12 @@ SCM_SYMBOL (sym_port_read_options, "port-read-options"); static void set_port_read_option (SCM port, int option, int new_value) { - SCM alist, scm_read_options; + SCM scm_read_options; unsigned int read_options; new_value &= READ_OPTION_MASK; - scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex); - alist = scm_hashq_ref (scm_i_port_weak_hash, port, SCM_BOOL_F); - scm_read_options = scm_assq_ref (alist, sym_port_read_options); + scm_read_options = scm_assq_ref (SCM_PTAB_ENTRY(port)->alist, + sym_port_read_options); if (scm_is_unsigned_integer (scm_read_options, 0, READ_OPTIONS_MAX_VALUE)) read_options = scm_to_uint (scm_read_options); else @@ -2194,9 +2173,9 @@ set_port_read_option (SCM port, int option, int new_value) read_options &= ~(READ_OPTION_MASK << option); read_options |= new_value << option; scm_read_options = scm_from_uint (read_options); - alist = scm_assq_set_x (alist, sym_port_read_options, scm_read_options); - scm_hashq_set_x (scm_i_port_weak_hash, port, alist); - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); + SCM_PTAB_ENTRY(port)->alist = scm_assq_set_x (SCM_PTAB_ENTRY(port)->alist, + sym_port_read_options, + scm_read_options); } /* Set OPTS and PORT's case-insensitivity according to VALUE. */ @@ -2231,13 +2210,11 @@ set_port_curly_infix_p (SCM port, scm_t_read_opts *opts, int value) static void init_read_options (SCM port, scm_t_read_opts *opts) { - SCM alist, val, scm_read_options; + SCM val, scm_read_options; unsigned int read_options, x; - scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex); - alist = scm_hashq_ref (scm_i_port_weak_hash, port, SCM_BOOL_F); - scm_read_options = scm_assq_ref (alist, sym_port_read_options); - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); + scm_read_options = scm_assq_ref (SCM_PTAB_ENTRY(port)->alist, + sym_port_read_options); if (scm_is_unsigned_integer (scm_read_options, 0, READ_OPTIONS_MAX_VALUE)) read_options = scm_to_uint (scm_read_options); diff --git a/libguile/root.c b/libguile/root.c index 8c8fd1aa5..c83da1c3c 100644 --- a/libguile/root.c +++ b/libguile/root.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995,1996,1997,1998,1999,2000, 2001, 2002, 2006, 2008, 2009 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1997,1998,1999,2000, 2001, 2002, 2006, 2008, 2009, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -109,12 +109,14 @@ scm_internal_cwdr (scm_t_catch_body body, void *body_data, SCM_STACKITEM *stack_start) { struct cwdr_handler_data my_handler_data; - SCM answer, old_winds; + scm_t_dynstack *dynstack = &SCM_I_CURRENT_THREAD->dynstack; + SCM answer; + scm_t_dynstack *old_dynstack; /* Exit caller's dynamic state. */ - old_winds = scm_i_dynwinds (); - scm_dowinds (SCM_EOL, scm_ilength (old_winds)); + old_dynstack = scm_dynstack_capture_all (dynstack); + scm_dynstack_unwind (dynstack, SCM_DYNSTACK_FIRST (dynstack)); scm_dynwind_begin (SCM_F_DYNWIND_REWINDABLE); scm_dynwind_current_dynamic_state (scm_make_dynamic_state (SCM_UNDEFINED)); @@ -128,7 +130,7 @@ scm_internal_cwdr (scm_t_catch_body body, void *body_data, /* Enter caller's dynamic state. */ - scm_dowinds (old_winds, - scm_ilength (old_winds)); + scm_dynstack_wind (dynstack, SCM_DYNSTACK_FIRST (old_dynstack)); /* Now run the real handler iff the body did a throw. */ if (my_handler_data.run_handler) diff --git a/libguile/rw.c b/libguile/rw.c index a9b4a329a..677e0d8df 100644 --- a/libguile/rw.c +++ b/libguile/rw.c @@ -1,4 +1,4 @@ -/* Copyright (C) 2001, 2006, 2009 Free Software Foundation, Inc. +/* Copyright (C) 2001, 2006, 2009, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -248,7 +248,7 @@ SCM_DEFINE (scm_write_string_partial, "write-string/partial", 1, 3, 0, return scm_from_long (write_len); } if (pt->write_pos > pt->write_buf) - scm_flush (port); + scm_flush_unlocked (port); fdes = SCM_FPORT_FDES (port); } { diff --git a/libguile/scmsigs.c b/libguile/scmsigs.c index 723d6a8c5..86fce0fe7 100644 --- a/libguile/scmsigs.c +++ b/libguile/scmsigs.c @@ -150,6 +150,28 @@ struct signal_pipe_data int err; }; +#ifndef HAVE_GC_GET_SUSPEND_SIGNAL +static int +GC_get_suspend_signal (void) +{ +#if defined SIG_SUSPEND + return SIG_SUSPEND; +#elif defined SIGPWR + return SIGPWR; +#elif defined SIGLOST + return SIGLOST; +#elif defined _SIGRTMIN + return _SIGRTMIN + 6; +#elif defined SIGRTMIN + return SIGRTMIN + 6; +#elif defined __GLIBC__ + return 32+6; +#else + return SIGUSR1; +#endif +} +#endif /* HAVE_GC_GET_SUSPEND_SIGNAL */ + static void* read_signal_pipe_data (void * data) { @@ -168,6 +190,11 @@ signal_delivery_thread (void *data) #if HAVE_PTHREAD_SIGMASK /* not on mingw, see notes above */ sigset_t all_sigs; sigfillset (&all_sigs); + /* On libgc 7.1 and earlier, GC_do_blocking doesn't actually do + anything. So in that case, libgc will want to suspend the signal + delivery thread, so we need to allow it to do so by unmasking the + suspend signal. */ + sigdelset (&all_sigs, GC_get_suspend_signal ()); scm_i_pthread_sigmask (SIG_SETMASK, &all_sigs, NULL); #endif diff --git a/libguile/smob.c b/libguile/smob.c index c2e8f2481..c2347f3be 100644 --- a/libguile/smob.c +++ b/libguile/smob.c @@ -105,14 +105,14 @@ int scm_smob_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED) { long n = SCM_SMOBNUM (exp); - scm_puts ("#<", port); - scm_puts (SCM_SMOBNAME (n) ? SCM_SMOBNAME (n) : "smob", port); - scm_putc (' ', port); + scm_puts_unlocked ("#<", port); + scm_puts_unlocked (SCM_SMOBNAME (n) ? SCM_SMOBNAME (n) : "smob", port); + scm_putc_unlocked (' ', port); if (scm_smobs[n].size) scm_uintprint (SCM_CELL_WORD_1 (exp), 16, port); else scm_uintprint (SCM_UNPACK (exp), 16, port); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); return 1; } @@ -257,8 +257,7 @@ scm_set_smob_apply (scm_t_bits tc, SCM (*apply) (), SCM trampoline = scm_smob_trampoline (req, opt, rst); scm_smobs[SCM_TC2SMOBNUM (tc)].apply = apply; - /* In 2.2 this field is renamed to "apply_trampoline". */ - scm_smobs[SCM_TC2SMOBNUM (tc)].apply_trampoline_objcode = trampoline; + scm_smobs[SCM_TC2SMOBNUM (tc)].apply_trampoline = trampoline; if (SCM_UNPACK (scm_smob_class[0]) != 0) scm_i_inherit_applicable (scm_smob_class[SCM_TC2SMOBNUM (tc)]); @@ -294,7 +293,7 @@ smob_mark (GC_word *addr, struct GC_ms_entry *mark_stack_ptr, register SCM cell; register scm_t_bits tc, smobnum; - cell = PTR2SCM (addr); + cell = SCM_PACK_POINTER (addr); if (SCM_TYP7 (cell) != scm_tc7_smob) /* It is likely that the GC passed us a pointer to a free-list element @@ -331,7 +330,7 @@ smob_mark (GC_word *addr, struct GC_ms_entry *mark_stack_ptr, mark_stack_ptr = SCM_I_CURRENT_THREAD->current_mark_stack_ptr; - if (SCM_NIMP (obj)) + if (SCM_HEAP_OBJECT_P (obj)) /* Mark the returned object. */ mark_stack_ptr = GC_MARK_AND_PUSH (SCM2PTR (obj), mark_stack_ptr, @@ -356,7 +355,7 @@ scm_gc_mark (SCM o) #define CURRENT_MARK_LIMIT \ ((struct GC_ms_entry *)(SCM_I_CURRENT_THREAD->current_mark_stack_limit)) - if (SCM_NIMP (o)) + if (SCM_HEAP_OBJECT_P (o)) { /* At this point, the `current_mark_*' fields of the current thread must be defined (they are set in `smob_mark ()'). */ @@ -383,7 +382,7 @@ finalize_smob (void *ptr, void *data) SCM smob; size_t (* free_smob) (SCM); - smob = PTR2SCM (ptr); + smob = SCM_PACK_POINTER (ptr); #if 0 printf ("finalizing SMOB %p (smobnum: %u)\n", ptr, SCM_SMOBNUM (smob)); @@ -407,9 +406,9 @@ scm_i_new_smob (scm_t_bits tc, scm_t_bits data) allocates a double cell. We leave words 2 and 3 to there initial values, which is 0. */ if (scm_smobs [smobnum].mark) - ret = PTR2SCM (GC_generic_malloc (2 * sizeof (scm_t_cell), smob_gc_kind)); + ret = SCM_PACK_POINTER (GC_generic_malloc (2 * sizeof (scm_t_cell), smob_gc_kind)); else - ret = PTR2SCM (GC_MALLOC (sizeof (scm_t_cell))); + ret = SCM_PACK_POINTER (GC_MALLOC (sizeof (scm_t_cell))); SCM_SET_CELL_WORD_1 (ret, data); SCM_SET_CELL_WORD_0 (ret, tc); @@ -432,9 +431,9 @@ scm_i_new_double_smob (scm_t_bits tc, scm_t_bits data1, /* Use the smob_gc_kind if needed to allow the mark procedure to run. */ if (scm_smobs [smobnum].mark) - ret = PTR2SCM (GC_generic_malloc (2 * sizeof (scm_t_cell), smob_gc_kind)); + ret = SCM_PACK_POINTER (GC_generic_malloc (2 * sizeof (scm_t_cell), smob_gc_kind)); else - ret = PTR2SCM (GC_MALLOC (2 * sizeof (scm_t_cell))); + ret = SCM_PACK_POINTER (GC_MALLOC (2 * sizeof (scm_t_cell))); SCM_SET_CELL_WORD_3 (ret, data3); SCM_SET_CELL_WORD_2 (ret, data2); @@ -447,26 +446,6 @@ scm_i_new_double_smob (scm_t_bits tc, scm_t_bits data1, return ret; } - - - -/* These two are internal details of the previous implementation of - SCM_NEWSMOB and are no longer used. They are still here to preserve - ABI stability in the 2.0 series. */ -void -scm_i_finalize_smob (void *ptr, void *data) -{ - finalize_smob (ptr, data); -} - -SCM -scm_i_new_smob_with_mark_proc (scm_t_bits tc, scm_t_bits word1, - scm_t_bits word2, scm_t_bits word3) -{ - return scm_new_double_smob (tc, word1, word2, word3); -} - - void scm_smob_prehistory () @@ -490,7 +469,7 @@ scm_smob_prehistory () scm_smobs[i].print = scm_smob_print; scm_smobs[i].equalp = 0; scm_smobs[i].apply = 0; - scm_smobs[i].apply_trampoline_objcode = SCM_BOOL_F; + scm_smobs[i].apply_trampoline = SCM_BOOL_F; } } diff --git a/libguile/smob.h b/libguile/smob.h index 60abe3733..37ea64247 100644 --- a/libguile/smob.h +++ b/libguile/smob.h @@ -40,8 +40,7 @@ typedef struct scm_smob_descriptor int (*print) (SCM exp, SCM port, scm_print_state *pstate); SCM (*equalp) (SCM, SCM); scm_t_subr apply; - /* In 2.2 this field is renamed to "apply_trampoline". */ - SCM apply_trampoline_objcode; + SCM apply_trampoline; } scm_smob_descriptor; @@ -51,7 +50,7 @@ typedef struct scm_smob_descriptor #define SCM_SMOBNUM(x) (SCM_TC2SMOBNUM (SCM_CELL_TYPE (x))) /* SCM_SMOBNAME can be 0 if name is missing */ #define SCM_SMOBNAME(smobnum) (scm_smobs[smobnum].name) -#define SCM_SMOB_PREDICATE(tag, obj) SCM_TYP16_PREDICATE (tag, obj) +#define SCM_SMOB_PREDICATE(tag, obj) SCM_HAS_TYP16 (obj, tag) #define SCM_SMOB_DESCRIPTOR(x) (scm_smobs[SCM_SMOBNUM (x)]) #define SCM_SMOB_APPLICABLE_P(x) (SCM_SMOB_DESCRIPTOR (x).apply) @@ -73,14 +72,6 @@ SCM_INLINE SCM scm_new_smob (scm_t_bits tc, scm_t_bits); SCM_INLINE SCM scm_new_double_smob (scm_t_bits tc, scm_t_bits, scm_t_bits, scm_t_bits); -/* These two are internal details of the previous implementation of - SCM_NEWSMOB and are no longer used. They are still here to preserve - ABI stability in the 2.0 series. */ -SCM_API void scm_i_finalize_smob (void *ptr, void *data); -SCM_API SCM scm_i_new_smob_with_mark_proc (scm_t_bits tc, scm_t_bits, - scm_t_bits, scm_t_bits); - - #if SCM_CAN_INLINE || defined SCM_INLINE_C_IMPLEMENTING_INLINES SCM_INLINE_IMPLEMENTATION SCM scm_new_smob (scm_t_bits tc, scm_t_bits data) diff --git a/libguile/snarf.h b/libguile/snarf.h index 1c072babb..3931570f4 100644 --- a/libguile/snarf.h +++ b/libguile/snarf.h @@ -119,9 +119,9 @@ SCM_SNARF_HERE( \ ) \ SCM_SNARF_INIT( \ /* Initialize the foreign. */ \ - scm_i_paste (FNAME, __raw_objtable)[2] = scm_i_paste (FNAME, __subr_foreign); \ + scm_i_paste (FNAME, __raw_objtable)[1] = scm_i_paste (FNAME, __subr_foreign); \ /* Initialize the procedure name (an interned symbol). */ \ - scm_i_paste (FNAME, __raw_objtable)[3] = scm_i_paste (FNAME, __name); \ + scm_i_paste (FNAME, __raw_objtable)[2] = scm_i_paste (FNAME, __name); \ /* Initialize the objcode trampoline. */ \ SCM_SET_CELL_OBJECT (scm_i_paste (FNAME, __subr), 1, \ scm_subr_objcode_trampoline (REQ, OPT, VAR)); \ @@ -209,11 +209,11 @@ SCM_SNARF_INIT( \ # define SCM_SYMBOL(c_name, scheme_name) \ SCM_SNARF_HERE(static SCM c_name) \ -SCM_SNARF_INIT(c_name = scm_from_locale_symbol (scheme_name)) +SCM_SNARF_INIT(c_name = scm_from_utf8_symbol (scheme_name)) # define SCM_GLOBAL_SYMBOL(c_name, scheme_name) \ SCM_SNARF_HERE(SCM c_name) \ -SCM_SNARF_INIT(c_name = scm_from_locale_symbol (scheme_name)) +SCM_SNARF_INIT(c_name = scm_from_utf8_symbol (scheme_name)) #endif /* !SCM_SUPPORT_STATIC_ALLOCATION */ @@ -366,12 +366,11 @@ SCM_SNARF_INIT(scm_set_smob_apply((tag), (c_name), (req), (opt), (rest));) /* for primitive-generics, add a foreign to the end */ #define SCM_STATIC_SUBR_OBJVECT(c_name, foreign) \ - static SCM_ALIGNED (8) SCM c_name[4] = \ + static SCM_ALIGNED (8) SCM c_name[3] = \ { \ SCM_PACK (scm_tc7_vector | (2 << 8)), \ - SCM_PACK (0), \ foreign, \ - SCM_BOOL_F, /* the name */ \ + SCM_BOOL_F /* the name */ \ } #define SCM_STATIC_PROGRAM(c_name, objcode, objtable, freevars) \ diff --git a/libguile/socket.c b/libguile/socket.c index 5119ce3c6..232041479 100644 --- a/libguile/socket.c +++ b/libguile/socket.c @@ -40,10 +40,6 @@ #include "libguile/validate.h" #include "libguile/socket.h" -#if SCM_ENABLE_DEPRECATED == 1 -# include "libguile/deprecation.h" -#endif - #ifdef __MINGW32__ #include "win32-socket.h" #include <netdb.h> @@ -1420,33 +1416,12 @@ SCM_DEFINE (scm_recv, "recv!", 2, 1, 0, flg = scm_to_int (flags); fd = SCM_FPORT_FDES (sock); -#if SCM_ENABLE_DEPRECATED == 1 - if (SCM_UNLIKELY (scm_is_string (buf))) - { - SCM msg; - char *dest; - size_t len; - - scm_c_issue_deprecation_warning - ("Passing a string to `recv!' is deprecated, " - "use a bytevector instead."); - - len = scm_i_string_length (buf); - msg = scm_i_make_string (len, &dest, 0); - SCM_SYSCALL (rv = recv (fd, dest, len, flg)); - scm_string_copy_x (buf, scm_from_int (0), - msg, scm_from_int (0), scm_from_size_t (len)); - } - else -#endif - { - SCM_VALIDATE_BYTEVECTOR (1, buf); + SCM_VALIDATE_BYTEVECTOR (1, buf); - SCM_SYSCALL (rv = recv (fd, - SCM_BYTEVECTOR_CONTENTS (buf), - SCM_BYTEVECTOR_LENGTH (buf), - flg)); - } + SCM_SYSCALL (rv = recv (fd, + SCM_BYTEVECTOR_CONTENTS (buf), + SCM_BYTEVECTOR_LENGTH (buf), + flg)); if (SCM_UNLIKELY (rv == -1)) SCM_SYSERROR; @@ -1486,35 +1461,12 @@ SCM_DEFINE (scm_send, "send", 2, 1, 0, fd = SCM_FPORT_FDES (sock); -#if SCM_ENABLE_DEPRECATED == 1 - if (SCM_UNLIKELY (scm_is_string (message))) - { - scm_c_issue_deprecation_warning - ("Passing a string to `send' is deprecated, " - "use a bytevector instead."); - - /* If the string is wide, see if it can be coerced into a narrow - string. */ - if (!scm_i_is_narrow_string (message) - || !scm_i_try_narrow_string (message)) - SCM_MISC_ERROR ("the message string is not 8-bit: ~s", - scm_list_1 (message)); - - SCM_SYSCALL (rv = send (fd, - scm_i_string_chars (message), - scm_i_string_length (message), - flg)); - } - else -#endif - { - SCM_VALIDATE_BYTEVECTOR (1, message); + SCM_VALIDATE_BYTEVECTOR (1, message); - SCM_SYSCALL (rv = send (fd, - SCM_BYTEVECTOR_CONTENTS (message), - SCM_BYTEVECTOR_LENGTH (message), - flg)); - } + SCM_SYSCALL (rv = send (fd, + SCM_BYTEVECTOR_CONTENTS (message), + SCM_BYTEVECTOR_LENGTH (message), + flg)); if (rv == -1) SCM_SYSERROR; @@ -1572,52 +1524,28 @@ SCM_DEFINE (scm_recvfrom, "recvfrom!", 2, 3, 0, ((struct sockaddr *) &addr)->sa_family = AF_UNSPEC; -#if SCM_ENABLE_DEPRECATED == 1 - if (SCM_UNLIKELY (scm_is_string (buf))) - { - char *cbuf; - - scm_c_issue_deprecation_warning - ("Passing a string to `recvfrom!' is deprecated, " - "use a bytevector instead."); - - scm_i_get_substring_spec (scm_i_string_length (buf), - start, &offset, end, &cend); + SCM_VALIDATE_BYTEVECTOR (1, buf); - buf = scm_i_string_start_writing (buf); - cbuf = scm_i_string_writable_chars (buf); + if (SCM_UNBNDP (start)) + offset = 0; + else + offset = scm_to_size_t (start); - SCM_SYSCALL (rv = recvfrom (fd, cbuf + offset, - cend - offset, flg, - (struct sockaddr *) &addr, &addr_size)); - scm_i_string_stop_writing (); - } + if (SCM_UNBNDP (end)) + cend = SCM_BYTEVECTOR_LENGTH (buf); else -#endif { - SCM_VALIDATE_BYTEVECTOR (1, buf); - - if (SCM_UNBNDP (start)) - offset = 0; - else - offset = scm_to_size_t (start); - - if (SCM_UNBNDP (end)) - cend = SCM_BYTEVECTOR_LENGTH (buf); - else - { - cend = scm_to_size_t (end); - if (SCM_UNLIKELY (cend >= SCM_BYTEVECTOR_LENGTH (buf) - || cend < offset)) - scm_out_of_range (FUNC_NAME, end); - } - - SCM_SYSCALL (rv = recvfrom (fd, - SCM_BYTEVECTOR_CONTENTS (buf) + offset, - cend - offset, flg, - (struct sockaddr *) &addr, &addr_size)); + cend = scm_to_size_t (end); + if (SCM_UNLIKELY (cend >= SCM_BYTEVECTOR_LENGTH (buf) + || cend < offset)) + scm_out_of_range (FUNC_NAME, end); } + SCM_SYSCALL (rv = recvfrom (fd, + SCM_BYTEVECTOR_CONTENTS (buf) + offset, + cend - offset, flg, + (struct sockaddr *) &addr, &addr_size)); + if (rv == -1) SCM_SYSERROR; @@ -1687,35 +1615,12 @@ SCM_DEFINE (scm_sendto, "sendto", 3, 1, 1, flg = SCM_NUM2ULONG (5, SCM_CAR (args_and_flags)); } -#if SCM_ENABLE_DEPRECATED == 1 - if (SCM_UNLIKELY (scm_is_string (message))) - { - scm_c_issue_deprecation_warning - ("Passing a string to `sendto' is deprecated, " - "use a bytevector instead."); - - /* If the string is wide, see if it can be coerced into a narrow - string. */ - if (!scm_i_is_narrow_string (message) - || !scm_i_try_narrow_string (message)) - SCM_MISC_ERROR ("the message string is not 8-bit: ~s", - scm_list_1 (message)); - - SCM_SYSCALL (rv = sendto (fd, - scm_i_string_chars (message), - scm_i_string_length (message), - flg, soka, size)); - } - else -#endif - { - SCM_VALIDATE_BYTEVECTOR (1, message); + SCM_VALIDATE_BYTEVECTOR (1, message); - SCM_SYSCALL (rv = sendto (fd, - SCM_BYTEVECTOR_CONTENTS (message), - SCM_BYTEVECTOR_LENGTH (message), - flg, soka, size)); - } + SCM_SYSCALL (rv = sendto (fd, + SCM_BYTEVECTOR_CONTENTS (message), + SCM_BYTEVECTOR_LENGTH (message), + flg, soka, size)); if (rv == -1) { diff --git a/libguile/srcprop.c b/libguile/srcprop.c index c632bb0c5..dbebf779f 100644 --- a/libguile/srcprop.c +++ b/libguile/srcprop.c @@ -34,7 +34,6 @@ #include "libguile/hash.h" #include "libguile/ports.h" #include "libguile/root.h" -#include "libguile/weaks.h" #include "libguile/gc.h" #include "libguile/validate.h" @@ -62,7 +61,6 @@ SCM_GLOBAL_SYMBOL (scm_sym_line, "line"); SCM_GLOBAL_SYMBOL (scm_sym_column, "column"); static SCM scm_source_whash; -static scm_i_pthread_mutex_t source_lock = SCM_I_PTHREAD_MUTEX_INITIALIZER; /* @@ -106,11 +104,11 @@ static int srcprops_print (SCM obj, SCM port, scm_print_state *pstate) { int writingp = SCM_WRITINGP (pstate); - scm_puts ("#<srcprops ", port); + scm_puts_unlocked ("#<srcprops ", port); SCM_SET_WRITINGP (pstate, 1); scm_iprin1 (scm_srcprops_to_alist (obj), port, pstate); SCM_SET_WRITINGP (pstate, writingp); - scm_putc ('>', port); + scm_putc_unlocked ('>', port); return 1; } @@ -187,11 +185,7 @@ SCM_DEFINE (scm_source_properties, "source-properties", 1, 0, 0, return SCM_EOL; else { - SCM p; - - scm_i_pthread_mutex_lock (&source_lock); - p = scm_hashq_ref (scm_source_whash, obj, SCM_EOL); - scm_i_pthread_mutex_unlock (&source_lock); + SCM p = scm_weak_table_refq (scm_source_whash, obj, SCM_EOL); if (SRCPROPSP (p)) return scm_srcprops_to_alist (p); @@ -212,9 +206,7 @@ SCM_DEFINE (scm_set_source_properties_x, "set-source-properties!", 2, 0, 0, { SCM_VALIDATE_NIM (1, obj); - scm_i_pthread_mutex_lock (&source_lock); - scm_hashq_set_x (scm_source_whash, obj, alist); - scm_i_pthread_mutex_unlock (&source_lock); + scm_weak_table_putq_x (scm_source_whash, obj, alist); return alist; } @@ -227,15 +219,7 @@ scm_i_has_source_properties (SCM obj) if (SCM_IMP (obj)) return 0; else - { - int ret; - - scm_i_pthread_mutex_lock (&source_lock); - ret = scm_is_true (scm_hashq_ref (scm_source_whash, obj, SCM_BOOL_F)); - scm_i_pthread_mutex_unlock (&source_lock); - - return ret; - } + return scm_is_true (scm_weak_table_refq (scm_source_whash, obj, SCM_BOOL_F)); } #undef FUNC_NAME @@ -246,14 +230,12 @@ scm_i_set_source_properties_x (SCM obj, long line, int col, SCM fname) { SCM_VALIDATE_NIM (1, obj); - scm_i_pthread_mutex_lock (&source_lock); - scm_hashq_set_x (scm_source_whash, obj, - scm_make_srcprops (line, col, fname, - SCM_COPY_SOURCE_P - ? scm_copy_tree (obj) - : SCM_UNDEFINED, - SCM_EOL)); - scm_i_pthread_mutex_unlock (&source_lock); + scm_weak_table_putq_x (scm_source_whash, obj, + scm_make_srcprops (line, col, fname, + SCM_COPY_SOURCE_P + ? scm_copy_tree (obj) + : SCM_UNDEFINED, + SCM_EOL)); } #undef FUNC_NAME @@ -263,32 +245,27 @@ SCM_DEFINE (scm_source_property, "source-property", 2, 0, 0, "@var{obj}'s source property list.") #define FUNC_NAME s_scm_source_property { + SCM p; + if (SCM_IMP (obj)) return SCM_BOOL_F; + + p = scm_weak_table_refq (scm_source_whash, obj, SCM_EOL); + + if (!SRCPROPSP (p)) + goto alist; + if (scm_is_eq (scm_sym_line, key)) + return scm_from_int (SRCPROPLINE (p)); + else if (scm_is_eq (scm_sym_column, key)) + return scm_from_int (SRCPROPCOL (p)); + else if (scm_is_eq (scm_sym_copy, key)) + return SRCPROPCOPY (p); else { - SCM p; - - scm_i_pthread_mutex_lock (&source_lock); - p = scm_hashq_ref (scm_source_whash, obj, SCM_EOL); - scm_i_pthread_mutex_unlock (&source_lock); - - if (!SRCPROPSP (p)) - goto alist; - if (scm_is_eq (scm_sym_line, key)) - p = scm_from_int (SRCPROPLINE (p)); - else if (scm_is_eq (scm_sym_column, key)) - p = scm_from_int (SRCPROPCOL (p)); - else if (scm_is_eq (scm_sym_copy, key)) - p = SRCPROPCOPY (p); - else - { - p = SRCPROPALIST (p); - alist: - p = scm_assoc (key, p); - return (SCM_NIMP (p) ? SCM_CDR (p) : SCM_BOOL_F); - } - return SCM_UNBNDP (p) ? SCM_BOOL_F : p; + p = SRCPROPALIST (p); + alist: + p = scm_assoc (key, p); + return (scm_is_pair (p) ? SCM_CDR (p) : SCM_BOOL_F); } } #undef FUNC_NAME @@ -302,44 +279,44 @@ SCM_DEFINE (scm_set_source_property_x, "set-source-property!", 3, 0, 0, SCM p; SCM_VALIDATE_NIM (1, obj); - scm_i_pthread_mutex_lock (&source_lock); - p = scm_hashq_ref (scm_source_whash, obj, SCM_EOL); + scm_i_pthread_mutex_lock (&scm_i_misc_mutex); + p = scm_weak_table_refq (scm_source_whash, obj, SCM_EOL); if (scm_is_eq (scm_sym_line, key)) { if (SRCPROPSP (p)) SETSRCPROPLINE (p, scm_to_int (datum)); else - scm_hashq_set_x (scm_source_whash, obj, - scm_make_srcprops (scm_to_int (datum), 0, - SCM_UNDEFINED, SCM_UNDEFINED, p)); + scm_weak_table_putq_x (scm_source_whash, obj, + scm_make_srcprops (scm_to_int (datum), 0, + SCM_UNDEFINED, SCM_UNDEFINED, p)); } else if (scm_is_eq (scm_sym_column, key)) { if (SRCPROPSP (p)) SETSRCPROPCOL (p, scm_to_int (datum)); else - scm_hashq_set_x (scm_source_whash, obj, - scm_make_srcprops (0, scm_to_int (datum), - SCM_UNDEFINED, SCM_UNDEFINED, p)); + scm_weak_table_putq_x (scm_source_whash, obj, + scm_make_srcprops (0, scm_to_int (datum), + SCM_UNDEFINED, SCM_UNDEFINED, p)); } else if (scm_is_eq (scm_sym_copy, key)) { if (SRCPROPSP (p)) SETSRCPROPCOPY (p, datum); else - scm_hashq_set_x (scm_source_whash, obj, - scm_make_srcprops (0, 0, SCM_UNDEFINED, datum, p)); + scm_weak_table_putq_x (scm_source_whash, obj, + scm_make_srcprops (0, 0, SCM_UNDEFINED, datum, p)); } else { if (SRCPROPSP (p)) SETSRCPROPALIST (p, scm_acons (key, datum, SRCPROPALIST (p))); else - scm_hashq_set_x (scm_source_whash, obj, - scm_acons (key, datum, p)); + scm_weak_table_putq_x (scm_source_whash, obj, + scm_acons (key, datum, p)); } - scm_i_pthread_mutex_unlock (&source_lock); + scm_i_pthread_mutex_unlock (&scm_i_misc_mutex); return SCM_UNSPECIFIED; } @@ -355,12 +332,10 @@ SCM_DEFINE (scm_cons_source, "cons-source", 3, 0, 0, { SCM p, z; z = scm_cons (x, y); - scm_i_pthread_mutex_lock (&source_lock); /* Copy source properties possibly associated with xorig. */ - p = scm_hashq_ref (scm_source_whash, xorig, SCM_BOOL_F); + p = scm_weak_table_refq (scm_source_whash, xorig, SCM_BOOL_F); if (scm_is_true (p)) - scm_hashq_set_x (scm_source_whash, z, p); - scm_i_pthread_mutex_unlock (&source_lock); + scm_weak_table_putq_x (scm_source_whash, z, p); return z; } #undef FUNC_NAME @@ -372,7 +347,7 @@ scm_init_srcprop () scm_tc16_srcprops = scm_make_smob_type ("srcprops", 0); scm_set_smob_print (scm_tc16_srcprops, srcprops_print); - scm_source_whash = scm_make_weak_key_hash_table (scm_from_int (2047)); + scm_source_whash = scm_c_make_weak_table (0, SCM_WEAK_TABLE_KIND_KEY); scm_c_define ("source-whash", scm_source_whash); scm_last_alist_filename = scm_cons (SCM_EOL, diff --git a/libguile/srfi-14.c b/libguile/srfi-14.c index af7c1d95b..bf95ce982 100644 --- a/libguile/srfi-14.c +++ b/libguile/srfi-14.c @@ -597,27 +597,27 @@ charset_print (SCM charset, SCM port, scm_print_state *pstate SCM_UNUSED) p = SCM_CHARSET_DATA (charset); - scm_puts ("#<charset {", port); + scm_puts_unlocked ("#<charset {", port); for (i = 0; i < p->len; i++) { if (first) first = 0; else - scm_puts (" ", port); + scm_puts_unlocked (" ", port); scm_write (SCM_MAKE_CHAR (p->ranges[i].lo), port); if (p->ranges[i].lo != p->ranges[i].hi) { - scm_puts ("..", port); + scm_puts_unlocked ("..", port); scm_write (SCM_MAKE_CHAR (p->ranges[i].hi), port); } if (i >= max_ranges_to_print) { /* Too many to print here. Quit early. */ - scm_puts (" ...", port); + scm_puts_unlocked (" ...", port); break; } } - scm_puts ("}>", port); + scm_puts_unlocked ("}>", port); return 1; } @@ -630,16 +630,16 @@ charset_cursor_print (SCM cursor, SCM port, cur = (scm_t_char_set_cursor *) SCM_SMOB_DATA (cursor); - scm_puts ("#<charset-cursor ", port); + scm_puts_unlocked ("#<charset-cursor ", port); if (cur->range == (size_t) (-1)) - scm_puts ("(empty)", port); + scm_puts_unlocked ("(empty)", port); else { scm_write (scm_from_size_t (cur->range), port); - scm_puts (":", port); + scm_puts_unlocked (":", port); scm_write (scm_from_int32 (cur->n), port); } - scm_puts (">", port); + scm_puts_unlocked (">", port); return 1; } diff --git a/libguile/srfi-14.h b/libguile/srfi-14.h index 4b1a4b298..dc9718d70 100644 --- a/libguile/srfi-14.h +++ b/libguile/srfi-14.h @@ -3,7 +3,7 @@ /* srfi-14.c --- SRFI-14 procedures for Guile * - * Copyright (C) 2001, 2004, 2006, 2008 Free Software Foundation, Inc. + * Copyright (C) 2001, 2004, 2006, 2008, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -45,7 +45,7 @@ typedef struct #define SCM_CHARSET_GET(cs,idx) \ scm_i_charset_get((scm_t_char_set *)SCM_SMOB_DATA(cs),idx) -#define SCM_CHARSETP(x) (!SCM_IMP (x) && (SCM_TYP16 (x) == scm_tc16_charset)) +#define SCM_CHARSETP(x) (SCM_HAS_TYP16 (x, scm_tc16_charset)) /* Smob type code for character sets. */ SCM_API int scm_tc16_charset; diff --git a/libguile/srfi-4.c b/libguile/srfi-4.c index af8126d03..ff0c414d7 100644 --- a/libguile/srfi-4.c +++ b/libguile/srfi-4.c @@ -1,6 +1,6 @@ /* srfi-4.c --- Uniform numeric vector datatypes. * - * Copyright (C) 2001, 2004, 2006, 2009, 2010 Free Software Foundation, Inc. + * Copyright (C) 2001, 2004, 2006, 2009, 2010, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -113,7 +113,8 @@ #define DEFINE_SRFI_4_C_FUNCS(TAG, tag, ctype, width) \ SCM scm_take_##tag##vector (ctype *data, size_t n) \ { \ - return scm_c_take_typed_bytevector ((scm_t_int8*)data, n, ETYPE (TAG)); \ + return scm_c_take_typed_bytevector ((scm_t_int8*)data, n, ETYPE (TAG), \ + SCM_BOOL_F); \ } \ const ctype* scm_array_handle_##tag##_elements (scm_t_array_handle *h) \ { \ diff --git a/libguile/srfi-4.h b/libguile/srfi-4.h index b55fd1d09..0e5afc35a 100644 --- a/libguile/srfi-4.h +++ b/libguile/srfi-4.h @@ -2,7 +2,7 @@ #define SCM_SRFI_4_H /* srfi-4.c --- Homogeneous numeric vector datatypes. * - * Copyright (C) 2001, 2004, 2006, 2008, 2009, 2010 Free Software Foundation, Inc. + * Copyright (C) 2001, 2004, 2006, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -279,16 +279,6 @@ SCM_INTERNAL const char *scm_i_uniform_vector_tag (SCM uvec); SCM_INTERNAL scm_i_t_array_ref scm_i_uniform_vector_ref_proc (SCM uvec); SCM_INTERNAL scm_i_t_array_set scm_i_uniform_vector_set_proc (SCM uvec); -#if SCM_ENABLE_DEPRECATED - -/* Deprecated because we want people to use the scm_t_array_handle - interface. -*/ - -SCM_DEPRECATED size_t scm_uniform_element_size (SCM obj); - -#endif - SCM_INTERNAL void scm_init_srfi_4 (void); #endif /* SCM_SRFI_4_H */ diff --git a/libguile/stackchk.c b/libguile/stackchk.c index 6cfb783b1..208ba97ed 100644 --- a/libguile/stackchk.c +++ b/libguile/stackchk.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995,1996,1997, 2000, 2001, 2006, 2008, 2010 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1997, 2000, 2001, 2006, 2008, 2010, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -34,7 +34,6 @@ /* {Stack Checking} */ -#ifdef STACK_CHECKING int scm_stack_checking_enabled_p; SCM_SYMBOL (scm_stack_overflow_key, "stack-overflow"); @@ -65,8 +64,6 @@ scm_report_stack_overflow () scm_dynwind_end (); } -#endif - long scm_stack_size (SCM_STACKITEM *start) { @@ -89,11 +86,11 @@ scm_stack_report () scm_uintprint ((scm_stack_size (thread->continuation_base) * sizeof (SCM_STACKITEM)), 16, port); - scm_puts (" of stack: 0x", port); + scm_puts_unlocked (" of stack: 0x", port); scm_uintprint ((scm_t_bits) thread->continuation_base, 16, port); - scm_puts (" - 0x", port); + scm_puts_unlocked (" - 0x", port); scm_uintprint ((scm_t_bits) &stack, 16, port); - scm_puts ("\n", port); + scm_puts_unlocked ("\n", port); } diff --git a/libguile/stackchk.h b/libguile/stackchk.h index aa6a1d493..1ed170fef 100644 --- a/libguile/stackchk.h +++ b/libguile/stackchk.h @@ -3,7 +3,7 @@ #ifndef SCM_STACKCHK_H #define SCM_STACKCHK_H -/* Copyright (C) 1995,1996,1998,2000, 2003, 2006, 2008, 2009, 2010 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1998,2000, 2003, 2006, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -34,7 +34,7 @@ */ #define SCM_STACK_CHECKING_P SCM_STACK_LIMIT -#if defined BUILDING_LIBGUILE && defined STACK_CHECKING +#if defined BUILDING_LIBGUILE #include "libguile/private-options.h" # if SCM_STACK_GROWS_UP # define SCM_STACK_OVERFLOW_P(s)\ diff --git a/libguile/stacks.c b/libguile/stacks.c index 37a9161cd..c3ea624ce 100644 --- a/libguile/stacks.c +++ b/libguile/stacks.c @@ -95,23 +95,21 @@ stack_depth (SCM frame) * encountered. */ -static SCM +static SCM* find_prompt (SCM key) { - SCM winds; - for (winds = scm_i_dynwinds (); scm_is_pair (winds); winds = scm_cdr (winds)) - { - SCM elt = scm_car (winds); - if (SCM_PROMPT_P (elt) && scm_is_eq (SCM_PROMPT_TAG (elt), key)) - return elt; - } - scm_misc_error ("make-stack", "Prompt tag not found while narrowing stack", - scm_list_1 (key)); - return SCM_BOOL_F; /* not reached */ + SCM *fp; + + if (!scm_dynstack_find_prompt (&SCM_I_CURRENT_THREAD->dynstack, key, + NULL, &fp, NULL, NULL, NULL)) + scm_misc_error ("make-stack", "Prompt tag not found while narrowing stack", + scm_list_1 (key)); + + return fp; } static void -narrow_stack (SCM stack, long inner, SCM inner_key, long outer, SCM outer_key) +narrow_stack (SCM stack, SCM inner_cut, SCM outer_cut) { unsigned long int len; SCM frame; @@ -120,75 +118,75 @@ narrow_stack (SCM stack, long inner, SCM inner_key, long outer, SCM outer_key) frame = SCM_STACK_FRAME (stack); /* Cut inner part. */ - if (scm_is_true (scm_procedure_p (inner_key))) + if (scm_is_true (scm_procedure_p (inner_cut))) { /* Cut until the given procedure is seen. */ - for (; inner && len ; --inner) + for (; len ;) { SCM proc = scm_frame_procedure (frame); len--; frame = scm_frame_previous (frame); - if (scm_is_eq (proc, inner_key)) + if (scm_is_eq (proc, inner_cut)) break; } } - else if (scm_is_symbol (inner_key)) - { - /* Cut until the given prompt tag is seen. FIXME, assumes prompt tags are - symbols. */ - SCM prompt = find_prompt (inner_key); - for (; len; len--, frame = scm_frame_previous (frame)) - if (SCM_PROMPT_REGISTERS (prompt)->fp - == SCM_VM_FRAME_FP (frame) - SCM_VM_FRAME_OFFSET (frame)) - break; - } - else + else if (scm_is_integer (inner_cut)) { /* Cut specified number of frames. */ + long inner = scm_to_int (inner_cut); + for (; inner && len; --inner) { len--; frame = scm_frame_previous (frame); } } + else + { + /* Cut until the given prompt tag is seen. */ + SCM *fp = find_prompt (inner_cut); + for (; len; len--, frame = scm_frame_previous (frame)) + if (fp == SCM_VM_FRAME_FP (frame) - SCM_VM_FRAME_OFFSET (frame)) + break; + } SCM_SET_STACK_LENGTH (stack, len); SCM_SET_STACK_FRAME (stack, frame); /* Cut outer part. */ - if (scm_is_true (scm_procedure_p (outer_key))) + if (scm_is_true (scm_procedure_p (outer_cut))) { /* Cut until the given procedure is seen. */ - for (; outer && len ; --outer) + for (; len ;) { frame = scm_stack_ref (stack, scm_from_long (len - 1)); len--; - if (scm_is_eq (scm_frame_procedure (frame), outer_key)) + if (scm_is_eq (scm_frame_procedure (frame), outer_cut)) break; } } - else if (scm_is_symbol (outer_key)) + else if (scm_is_integer (outer_cut)) + { + /* Cut specified number of frames. */ + long outer = scm_to_int (outer_cut); + + if (outer < len) + len -= outer; + else + len = 0; + } + else { - /* Cut until the given prompt tag is seen. FIXME, assumes prompt tags are - symbols. */ - SCM prompt = find_prompt (outer_key); + /* Cut until the given prompt tag is seen. */ + SCM *fp = find_prompt (outer_cut); while (len) { frame = scm_stack_ref (stack, scm_from_long (len - 1)); len--; - if (SCM_PROMPT_REGISTERS (prompt)->fp - == SCM_VM_FRAME_FP (frame) - SCM_VM_FRAME_OFFSET (frame)) + if (fp == SCM_VM_FRAME_FP (frame) - SCM_VM_FRAME_OFFSET (frame)) break; } } - else - { - /* Cut specified number of frames. */ - if (outer < len) - len -= outer; - else - len = 0; - } SCM_SET_STACK_LENGTH (stack, len); } @@ -257,7 +255,7 @@ SCM_DEFINE (scm_make_stack, "make-stack", 1, 0, 1, SCM cont; struct scm_vm_cont *c; - cont = scm_i_vm_capture_continuation (scm_the_vm ()); + cont = scm_i_capture_current_stack (); c = SCM_VM_CONT_DATA (cont); frame = scm_c_make_frame (cont, c->fp + c->reloc, @@ -313,10 +311,8 @@ SCM_DEFINE (scm_make_stack, "make-stack", 1, 0, 1, } narrow_stack (stack, - scm_is_integer (inner_cut) ? scm_to_int (inner_cut) : n, - scm_is_integer (inner_cut) ? SCM_BOOL_T : inner_cut, - scm_is_integer (outer_cut) ? scm_to_int (outer_cut) : n, - scm_is_integer (outer_cut) ? SCM_BOOL_T : outer_cut); + inner_cut, + outer_cut); n = SCM_STACK_LENGTH (stack); } diff --git a/libguile/strings.c b/libguile/strings.c index 5d0db2301..85a6c4839 100644 --- a/libguile/strings.c +++ b/libguile/strings.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995,1996,1998,2000,2001, 2004, 2006, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1998,2000,2001, 2004, 2006, 2008, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -126,7 +126,7 @@ make_stringbuf (size_t len) lenhist[1000]++; #endif - buf = PTR2SCM (scm_gc_malloc_pointerless (STRINGBUF_HEADER_BYTES + len + 1, + buf = SCM_PACK_POINTER (scm_gc_malloc_pointerless (STRINGBUF_HEADER_BYTES + len + 1, "string")); SCM_SET_CELL_TYPE (buf, STRINGBUF_TAG); @@ -153,7 +153,7 @@ make_wide_stringbuf (size_t len) #endif raw_len = (len + 1) * sizeof (scm_t_wchar); - buf = PTR2SCM (scm_gc_malloc_pointerless (STRINGBUF_HEADER_BYTES + raw_len, + buf = SCM_PACK_POINTER (scm_gc_malloc_pointerless (STRINGBUF_HEADER_BYTES + raw_len, "string")); SCM_SET_CELL_TYPE (buf, STRINGBUF_TAG | STRINGBUF_F_WIDE); @@ -240,7 +240,7 @@ scm_i_pthread_mutex_t stringbuf_write_mutex = SCM_I_PTHREAD_MUTEX_INITIALIZER; #define SET_STRING_STRINGBUF(str,buf) (SCM_SET_CELL_OBJECT_1(str,buf)) #define SET_STRING_START(str,start) (SCM_SET_CELL_WORD_2(str,start)) -#define IS_STRING(str) (SCM_NIMP(str) && SCM_TYP7(str) == STRING_TAG) +#define IS_STRING(str) (SCM_HAS_TYP7 (str, STRING_TAG)) /* Read-only strings. */ @@ -1492,6 +1492,23 @@ scm_decoding_error (const char *subr, int err, const char *message, SCM port) /* String conversion to/from C. */ +static void +decoding_error (const char *func_name, int errno_save, + const char *str, size_t len) +{ + /* Raise an error and pass the raw C string as a bytevector to the `throw' + handler. */ + SCM bv; + signed char *buf; + + buf = scm_gc_malloc_pointerless (len, "bytevector"); + memcpy (buf, str, len); + bv = scm_c_take_gc_bytevector (buf, len, SCM_BOOL_F); + + scm_decoding_error (func_name, errno_save, + "input locale conversion error", bv); +} + SCM scm_from_stringn (const char *str, size_t len, const char *encoding, scm_t_string_failed_conversion_handler handler) @@ -1507,14 +1524,11 @@ scm_from_stringn (const char *str, size_t len, const char *encoding, if (len == (size_t) -1) len = strlen (str); - if (encoding == NULL || len == 0) - { - /* If encoding is null (or the string is empty), use Latin-1. */ - char *buf; - res = scm_i_make_string (len, &buf, 0); - memcpy (buf, str, len); - return res; - } + if (strcmp (encoding, "ISO-8859-1") == 0 || len == 0) + return scm_from_latin1_stringn (str, len); + else if (strcmp (encoding, "UTF-8") == 0 + && handler == SCM_FAILED_CONVERSION_ERROR) + return scm_from_utf8_stringn (str, len); u32len = 0; u32 = (scm_t_wchar *) u32_conv_from_encoding (encoding, @@ -1525,19 +1539,7 @@ scm_from_stringn (const char *str, size_t len, const char *encoding, NULL, &u32len); if (SCM_UNLIKELY (u32 == NULL)) - { - /* Raise an error and pass the raw C string as a bytevector to the `throw' - handler. */ - SCM bv; - signed char *buf; - - buf = scm_gc_malloc_pointerless (len, "bytevector"); - memcpy (buf, str, len); - bv = scm_c_take_gc_bytevector (buf, len); - - scm_decoding_error (__func__, errno, - "input locale conversion error", bv); - } + decoding_error (__func__, errno, str, len); i = 0; while (i < u32len) @@ -1611,7 +1613,81 @@ scm_from_utf8_string (const char *str) SCM scm_from_utf8_stringn (const char *str, size_t len) { - return scm_from_stringn (str, len, "UTF-8", SCM_FAILED_CONVERSION_ERROR); + size_t i, char_len; + const scm_t_uint8 *ustr = (const scm_t_uint8 *) str; + int ascii = 1, narrow = 1; + SCM res; + + if (len == (size_t) -1) + len = strlen (str); + + i = 0; + char_len = 0; + + while (i < len) + { + if (ustr[i] <= 127) + { + char_len++; + i++; + } + else + { + ucs4_t c; + int nbytes; + + ascii = 0; + + nbytes = u8_mbtouc (&c, ustr + i, len - i); + + if (c == 0xfffd) + /* Bad UTF-8. */ + decoding_error (__func__, errno, str, len); + + if (c > 255) + narrow = 0; + + char_len++; + i += nbytes; + } + } + + if (ascii) + { + char *dst; + res = scm_i_make_string (char_len, &dst, 0); + memcpy (dst, str, len); + } + else if (narrow) + { + char *dst; + size_t j; + ucs4_t c; + + res = scm_i_make_string (char_len, &dst, 0); + + for (i = 0, j = 0; i < len; j++) + { + i += u8_mbtouc_unsafe (&c, ustr + i, len - i); + dst[j] = (signed char) c; + } + } + else + { + scm_t_wchar *dst; + size_t j; + ucs4_t c; + + res = scm_i_make_wide_string (char_len, &dst, 0); + + for (i = 0, j = 0; i < len; j++) + { + i += u8_mbtouc_unsafe (&c, ustr + i, len - i); + dst[j] = c; + } + } + + return res; } SCM @@ -1636,6 +1712,26 @@ scm_from_utf32_stringn (const scm_t_wchar *str, size_t len) return result; } +SCM +scm_from_port_string (const char *str, SCM port) +{ + return scm_from_port_stringn (str, -1, port); +} + +SCM +scm_from_port_stringn (const char *str, size_t len, SCM port) +{ + scm_t_port *pt = SCM_PTAB_ENTRY (port); + + if (pt->encoding_mode == SCM_PORT_ENCODING_MODE_LATIN1) + return scm_from_latin1_stringn (str, len); + else if (pt->encoding_mode == SCM_PORT_ENCODING_MODE_UTF8 + && pt->ilseq_handler == SCM_FAILED_CONVERSION_ERROR) + return scm_from_utf8_stringn (str, len); + else + return scm_from_stringn (str, len, pt->encoding, pt->ilseq_handler); +} + /* Create a new scheme string from the C string STR. The memory of STR may be used directly as storage for the new string. */ /* FIXME: GC-wise, the only way to use the memory area pointed to by STR @@ -2021,6 +2117,26 @@ scm_to_utf32_stringn (SCM str, size_t *lenp) } #undef FUNC_NAME +char * +scm_to_port_string (SCM str, SCM port) +{ + return scm_to_port_stringn (str, NULL, port); +} + +char * +scm_to_port_stringn (SCM str, size_t *lenp, SCM port) +{ + scm_t_port *pt = SCM_PTAB_ENTRY (port); + + if (pt->encoding_mode == SCM_PORT_ENCODING_MODE_LATIN1 + && pt->ilseq_handler == SCM_FAILED_CONVERSION_ERROR) + return scm_to_latin1_stringn (str, lenp); + else if (pt->encoding_mode == SCM_PORT_ENCODING_MODE_UTF8) + return scm_to_utf8_stringn (str, lenp); + else + return scm_to_stringn (str, lenp, pt->encoding, pt->ilseq_handler); +} + /* Return a malloc(3)-allocated buffer containing the contents of STR encoded according to ENCODING. If LENP is non-NULL, set it to the size in bytes of the returned buffer. If the conversion to ENCODING fails, apply the strategy @@ -2054,7 +2170,7 @@ scm_to_stringn (SCM str, size_t *lenp, const char *encoding, "string contains #\\nul character: ~S", scm_list_1 (str)); - if (scm_i_is_narrow_string (str) && (encoding == NULL)) + if (scm_i_is_narrow_string (str) && strcmp (encoding, "ISO-8859-1") == 0) { /* If using native Latin-1 encoding, just copy the string contents. */ @@ -2310,66 +2426,6 @@ scm_i_get_substring_spec (size_t len, *cend = scm_to_unsigned_integer (end, *cstart, len); } -#if SCM_ENABLE_DEPRECATED - -/* When these definitions are removed, it becomes reasonable to use - read-only strings for string literals. For that, change the reader - to create string literals with scm_c_substring_read_only instead of - with scm_c_substring_copy. -*/ - -int -scm_i_deprecated_stringp (SCM str) -{ - scm_c_issue_deprecation_warning - ("SCM_STRINGP is deprecated. Use scm_is_string instead."); - - return scm_is_string (str); -} - -char * -scm_i_deprecated_string_chars (SCM str) -{ - char *chars; - - scm_c_issue_deprecation_warning - ("SCM_STRING_CHARS is deprecated. See the manual for alternatives."); - - /* We don't accept shared substrings here since they are not - null-terminated. - */ - if (IS_SH_STRING (str)) - scm_misc_error (NULL, - "SCM_STRING_CHARS does not work with shared substrings", - SCM_EOL); - - /* We explicitly test for read-only strings to produce a better - error message. - */ - - if (IS_RO_STRING (str)) - scm_misc_error (NULL, - "SCM_STRING_CHARS does not work with read-only strings", - SCM_EOL); - - /* The following is still wrong, of course... - */ - str = scm_i_string_start_writing (str); - chars = scm_i_string_writable_chars (str); - scm_i_string_stop_writing (); - return chars; -} - -size_t -scm_i_deprecated_string_length (SCM str) -{ - scm_c_issue_deprecation_warning - ("SCM_STRING_LENGTH is deprecated. Use scm_c_string_length instead."); - return scm_c_string_length (str); -} - -#endif - static SCM string_handle_ref (scm_t_array_handle *h, size_t index) { diff --git a/libguile/strings.h b/libguile/strings.h index 42e57ace3..445d9c878 100644 --- a/libguile/strings.h +++ b/libguile/strings.h @@ -3,7 +3,7 @@ #ifndef SCM_STRINGS_H #define SCM_STRINGS_H -/* Copyright (C) 1995,1996,1997,1998,2000,2001, 2004, 2005, 2006, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1997,1998,2000,2001, 2004, 2005, 2006, 2008, 2009, 2010, 2011, 2013 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -153,6 +153,11 @@ SCM_API scm_t_wchar *scm_to_utf32_stringn (SCM str, size_t *lenp); SCM_API SCM scm_from_utf32_string (const scm_t_wchar *str); SCM_API SCM scm_from_utf32_stringn (const scm_t_wchar *str, size_t len); +SCM_API char *scm_to_port_string (SCM str, SCM port); +SCM_API char *scm_to_port_stringn (SCM str, size_t *lenp, SCM port); +SCM_API SCM scm_from_port_string (const char *str, SCM port); +SCM_API SCM scm_from_port_stringn (const char *str, size_t len, SCM port); + SCM_API char *scm_to_stringn (SCM str, size_t *lenp, const char *encoding, scm_t_string_failed_conversion_handler handler); SCM_API size_t scm_to_locale_stringbuf (SCM str, char *buf, size_t max_len); @@ -235,21 +240,6 @@ SCM_API SCM scm_sys_stringbuf_hist (void); -/* deprecated stuff */ - -#if SCM_ENABLE_DEPRECATED - -SCM_DEPRECATED int scm_i_deprecated_stringp (SCM obj); -SCM_DEPRECATED char *scm_i_deprecated_string_chars (SCM str); -SCM_DEPRECATED size_t scm_i_deprecated_string_length (SCM str); - -#define SCM_STRINGP(x) scm_i_deprecated_stringp(x) -#define SCM_STRING_CHARS(x) scm_i_deprecated_string_chars(x) -#define SCM_STRING_LENGTH(x) scm_i_deprecated_string_length(x) -#define SCM_STRING_UCHARS(str) ((unsigned char *)SCM_STRING_CHARS (str)) - -#endif - SCM_INTERNAL void scm_init_strings (void); #endif /* SCM_STRINGS_H */ diff --git a/libguile/strports.c b/libguile/strports.c index 14cc93f81..425b08929 100644 --- a/libguile/strports.c +++ b/libguile/strports.c @@ -1,5 +1,5 @@ /* Copyright (C) 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, - * 2009, 2010, 2011, 2012 Free Software Foundation, Inc. + * 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -57,10 +57,8 @@ /* NOTES: write_buf/write_end point to the ends of the allocated bytevector. - read_buf/read_end in principle point to the part of the bytevector which - has been written to, but this is only updated after a flush. - read_pos and write_pos in principle should be equal, but this is only true - when rw_active is SCM_PORT_NEITHER. + read_buf/read_end point to the part of the bytevector which has been + written to. read_pos and write_pos are always equal. ENHANCE-ME - output blocks: @@ -90,14 +88,14 @@ scm_t_bits scm_tc16_strport; static int -stfill_buffer (SCM port) +st_fill_input (SCM port) { scm_t_port *pt = SCM_PTAB_ENTRY (port); if (pt->read_pos >= pt->read_end) return EOF; else - return scm_return_first_int (*pt->read_pos, port); + return *pt->read_pos; } /* Change the size of a port's bytevector to NEW_SIZE. This doesn't @@ -112,7 +110,7 @@ st_resize_port (scm_t_port *pt, scm_t_off new_size) unsigned long int old_size = SCM_BYTEVECTOR_LENGTH (old_stream); unsigned long int min_size = min (old_size, new_size); - scm_t_off index = pt->write_pos - pt->write_buf; + scm_t_off offset = pt->write_pos - pt->write_buf; pt->write_buf_size = new_size; @@ -124,50 +122,29 @@ st_resize_port (scm_t_port *pt, scm_t_off new_size) { pt->stream = SCM_UNPACK (new_stream); pt->read_buf = pt->write_buf = (unsigned char *)dst; - pt->read_pos = pt->write_pos = pt->write_buf + index; + pt->read_pos = pt->write_pos = pt->write_buf + offset; pt->write_end = pt->write_buf + pt->write_buf_size; pt->read_end = pt->read_buf + pt->read_buf_size; } } -/* Ensure that `write_pos' < `write_end' by enlarging the buffer when - necessary. Update `read_buf' to account for written chars. The - buffer is enlarged geometrically. */ static void -st_flush (SCM port) +st_write (SCM port, const void *data, size_t size) { scm_t_port *pt = SCM_PTAB_ENTRY (port); - if (pt->write_pos == pt->write_end) - st_resize_port (pt, pt->write_buf_size * 2); + if (size > pt->write_end - pt->write_pos) + st_resize_port (pt, max (pt->write_buf_size * 2, + pt->write_end - pt->write_pos + size)); + + memcpy ((char *) pt->write_pos, data, size); + pt->read_pos = (pt->write_pos += size); - pt->read_pos = pt->write_pos; if (pt->read_pos > pt->read_end) { pt->read_end = (unsigned char *) pt->read_pos; pt->read_buf_size = pt->read_end - pt->read_buf; } - pt->rw_active = SCM_PORT_NEITHER; -} - -static void -st_write (SCM port, const void *data, size_t size) -{ - scm_t_port *pt = SCM_PTAB_ENTRY (port); - const char *input = (char *) data; - - while (size > 0) - { - int space = pt->write_end - pt->write_pos; - int write_len = (size > space) ? space : size; - - memcpy ((char *) pt->write_pos, input, write_len); - pt->write_pos += write_len; - size -= write_len; - input += write_len; - if (write_len == space) - st_flush (port); - } } static void @@ -204,11 +181,10 @@ st_seek (SCM port, scm_t_off offset, int whence) else /* all other cases. */ { - if (pt->rw_active == SCM_PORT_WRITE) - st_flush (port); - if (pt->rw_active == SCM_PORT_READ) - scm_end_input (port); + scm_end_input_unlocked (port); + + pt->rw_active = SCM_PORT_NEITHER; switch (whence) { @@ -261,10 +237,7 @@ st_truncate (SCM port, scm_t_off length) pt->read_buf_size = length; pt->read_end = pt->read_buf + length; if (pt->read_pos > pt->read_end) - pt->read_pos = pt->read_end; - - if (pt->write_pos > pt->read_end) - pt->write_pos = pt->read_end; + pt->read_pos = pt->write_pos = pt->read_end; } /* The initial size in bytes of a string port's buffer. */ @@ -278,28 +251,14 @@ scm_mkstrport (SCM pos, SCM str, long modes, const char *caller) { SCM z, buf; scm_t_port *pt; - size_t str_len, c_pos; + const char *encoding; + size_t read_buf_size, str_len, c_pos; char *c_buf; if (!((modes & SCM_WRTNG) || (modes & SCM_RDNG))) scm_misc_error ("scm_mkstrport", "port must read or write", SCM_EOL); - scm_dynwind_begin (0); - scm_i_dynwind_pthread_mutex_lock (&scm_i_port_table_mutex); - - z = scm_new_port_table_entry (scm_tc16_strport); - SCM_SET_CELL_TYPE (z, scm_tc16_strport); - pt = SCM_PTAB_ENTRY (z); - - /* Make PT initially empty, and release the port-table mutex - immediately. This is so that if one of the function calls below - raises an exception, a pre-unwind catch handler can still create - new ports; for instance, `display-backtrace' needs to be able to - allocate a new string port. See <http://bugs.gnu.org/11197>. */ - scm_port_non_buffer (pt); - SCM_SETSTREAM (z, SCM_UNPACK (scm_null_bytevector)); - - scm_dynwind_end (); + encoding = scm_i_default_port_encoding (); if (scm_is_false (str)) { @@ -307,6 +266,10 @@ scm_mkstrport (SCM pos, SCM str, long modes, const char *caller) str_len = INITIAL_BUFFER_SIZE; buf = scm_c_make_bytevector (str_len); c_buf = (char *) SCM_BYTEVECTOR_CONTENTS (buf); + + /* Reset `read_buf_size'. It will contain the actual number of + bytes written to the port. */ + read_buf_size = 0; c_pos = 0; } else @@ -316,8 +279,8 @@ scm_mkstrport (SCM pos, SCM str, long modes, const char *caller) SCM_ASSERT (scm_is_string (str), str, SCM_ARG1, caller); - /* Create a copy of STR in the encoding of PT. */ - copy = scm_to_stringn (str, &str_len, pt->encoding, + /* Create a copy of STR in ENCODING. */ + copy = scm_to_stringn (str, &str_len, encoding, SCM_FAILED_CONVERSION_ERROR); buf = scm_c_make_bytevector (str_len); c_buf = (char *) SCM_BYTEVECTOR_CONTENTS (buf); @@ -325,34 +288,23 @@ scm_mkstrport (SCM pos, SCM str, long modes, const char *caller) free (copy); c_pos = scm_to_unsigned_integer (pos, 0, str_len); + read_buf_size = str_len; } - /* Now, finish up the port. */ - scm_i_pthread_mutex_lock (&scm_i_port_table_mutex); - - SCM_SETSTREAM (z, SCM_UNPACK (buf)); - SCM_SET_CELL_TYPE (z, scm_tc16_strport | modes); + z = scm_c_make_port_with_encoding (scm_tc16_strport, modes, + encoding, + scm_i_default_port_conversion_handler (), + (scm_t_bits)buf); - if (scm_is_false (str)) - /* Reset `read_buf_size'. It will contain the actual number of - bytes written to PT. */ - pt->read_buf_size = 0; - else - pt->read_buf_size = str_len; + pt = SCM_PTAB_ENTRY (z); pt->write_buf = pt->read_buf = (unsigned char *) c_buf; pt->read_pos = pt->write_pos = pt->read_buf + c_pos; + pt->read_buf_size = read_buf_size; pt->write_buf_size = str_len; pt->write_end = pt->read_end = pt->read_buf + pt->read_buf_size; - pt->rw_random = 1; - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); - - /* Ensure WRITE_POS is writable. */ - if ((modes & SCM_WRTNG) && pt->write_pos == pt->write_end) - st_flush (z); - return z; } @@ -361,26 +313,12 @@ scm_mkstrport (SCM pos, SCM str, long modes, const char *caller) SCM scm_strport_to_string (SCM port) { - SCM str; scm_t_port *pt = SCM_PTAB_ENTRY (port); - if (pt->rw_active == SCM_PORT_WRITE) - st_flush (port); - if (pt->read_buf_size == 0) return scm_nullstr; - if (pt->encoding == NULL) - { - char *buf; - str = scm_i_make_string (pt->read_buf_size, &buf, 0); - memcpy (buf, pt->read_buf, pt->read_buf_size); - } - else - str = scm_from_stringn ((char *)pt->read_buf, pt->read_buf_size, - pt->encoding, pt->ilseq_handler); - scm_remember_upto_here_1 (port); - return str; + return scm_from_port_stringn ((char *)pt->read_buf, pt->read_buf_size, port); } SCM_DEFINE (scm_object_to_string, "object->string", 1, 1, 0, @@ -417,35 +355,27 @@ SCM_DEFINE (scm_object_to_string, "object->string", 1, 1, 0, } #undef FUNC_NAME -SCM_DEFINE (scm_call_with_output_string, "call-with-output-string", 1, 0, 0, - (SCM proc), - "Calls the one-argument procedure @var{proc} with a newly created output\n" - "port. When the function returns, the string composed of the characters\n" - "written into the port is returned.") -#define FUNC_NAME s_scm_call_with_output_string +SCM +scm_call_with_output_string (SCM proc) { - SCM p; + static SCM var = SCM_BOOL_F; - p = scm_mkstrport (SCM_INUM0, SCM_BOOL_F, - SCM_OPN | SCM_WRTNG, - FUNC_NAME); - scm_call_1 (proc, p); + if (scm_is_false (var)) + var = scm_c_private_lookup ("guile", "call-with-output-string"); - return scm_get_output_string (p); + return scm_call_1 (scm_variable_ref (var), proc); } -#undef FUNC_NAME -SCM_DEFINE (scm_call_with_input_string, "call-with-input-string", 2, 0, 0, - (SCM string, SCM proc), - "Calls the one-argument procedure @var{proc} with a newly\n" - "created input port from which @var{string}'s contents may be\n" - "read. The value yielded by the @var{proc} is returned.") -#define FUNC_NAME s_scm_call_with_input_string +SCM +scm_call_with_input_string (SCM string, SCM proc) { - SCM p = scm_mkstrport(SCM_INUM0, string, SCM_OPN | SCM_RDNG, FUNC_NAME); - return scm_call_1 (proc, p); + static SCM var = SCM_BOOL_F; + + if (scm_is_false (var)) + var = scm_c_private_lookup ("guile", "call-with-input-string"); + + return scm_call_2 (scm_variable_ref (var), string, proc); } -#undef FUNC_NAME SCM_DEFINE (scm_open_input_string, "open-input-string", 1, 0, 0, (SCM str), @@ -560,10 +490,9 @@ scm_eval_string (SCM string) static scm_t_bits scm_make_stptob () { - scm_t_bits tc = scm_make_port_type ("string", stfill_buffer, st_write); + scm_t_bits tc = scm_make_port_type ("string", st_fill_input, st_write); scm_set_port_end_input (tc, st_end_input); - scm_set_port_flush (tc, st_flush); scm_set_port_seek (tc, st_seek); scm_set_port_truncate (tc, st_truncate); diff --git a/libguile/strports.h b/libguile/strports.h index 3a9c3ec01..b4bafdfc0 100644 --- a/libguile/strports.h +++ b/libguile/strports.h @@ -3,7 +3,7 @@ #ifndef SCM_STRPORTS_H #define SCM_STRPORTS_H -/* Copyright (C) 1995,1996,2000,2001,2002, 2006, 2008, 2010 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,2000,2001,2002, 2006, 2008, 2010, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -28,8 +28,7 @@ -#define SCM_STRPORTP(x) (!SCM_IMP (x) && \ - (SCM_TYP16 (x) == scm_tc16_strport)) +#define SCM_STRPORTP(x) (SCM_HAS_TYP16 (x, scm_tc16_strport)) #define SCM_OPSTRPORTP(x) (SCM_STRPORTP (x) && \ (SCM_CELL_WORD_0 (x) & SCM_OPN)) #define SCM_OPINSTRPORTP(x) (SCM_OPSTRPORTP (x) && \ diff --git a/libguile/struct.c b/libguile/struct.c index db1687ef8..db79e7974 100644 --- a/libguile/struct.c +++ b/libguile/struct.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1996,1997,1998,1999,2000,2001, 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. +/* Copyright (C) 1996,1997,1998,1999,2000,2001, 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -31,7 +31,6 @@ #include "libguile/chars.h" #include "libguile/eval.h" #include "libguile/alist.h" -#include "libguile/weaks.h" #include "libguile/hashtab.h" #include "libguile/ports.h" #include "libguile/strings.h" @@ -533,8 +532,7 @@ SCM_DEFINE (scm_make_struct, "make-struct", 2, 0, 1, "Scheme programs.\n\n" "If fewer optional arguments than initializable fields are supplied,\n" "fields of type 'p' get default value #f while fields of type 'u' are\n" - "initialized to 0.\n\n" - "For more information, see the documentation for @code{make-vtable-vtable}.") + "initialized to 0.") #define FUNC_NAME s_scm_make_struct { size_t i, n_init; @@ -562,61 +560,6 @@ SCM_DEFINE (scm_make_struct, "make-struct", 2, 0, 1, } #undef FUNC_NAME - - -#if SCM_ENABLE_DEPRECATED == 1 -SCM -scm_make_vtable_vtable (SCM user_fields, SCM tail_array_size, SCM init) -#define FUNC_NAME "make-vtable-vtable" -{ - SCM fields, layout, obj; - size_t basic_size, n_tail, i, n_init; - long ilen; - scm_t_bits *v; - - SCM_VALIDATE_STRING (1, user_fields); - ilen = scm_ilength (init); - if (ilen < 0) - SCM_MISC_ERROR ("Rest arguments do not form a proper list.", SCM_EOL); - - n_init = (size_t)ilen + 1; /* + 1 for the layout */ - - /* best to use alloca, but init could be big, so hack to avoid a possible - stack overflow */ - if (n_init < 64) - v = alloca (n_init * sizeof(scm_t_bits)); - else - v = scm_gc_malloc (n_init * sizeof(scm_t_bits), "struct"); - - fields = scm_string_append (scm_list_2 (required_vtable_fields, - user_fields)); - layout = scm_make_struct_layout (fields); - if (!scm_is_valid_vtable_layout (layout)) - SCM_MISC_ERROR ("invalid user fields", scm_list_1 (user_fields)); - - basic_size = scm_i_symbol_length (layout) / 2; - n_tail = scm_to_size_t (tail_array_size); - - i = 0; - v[i++] = SCM_UNPACK (layout); - for (; i < n_init; i++, init = SCM_CDR (init)) - v[i] = SCM_UNPACK (SCM_CAR (init)); - - SCM_CRITICAL_SECTION_START; - obj = scm_i_alloc_struct (NULL, basic_size + n_tail); - /* Make it so that the vtable of OBJ is itself. */ - SCM_SET_CELL_WORD_0 (obj, (scm_t_bits) SCM_STRUCT_DATA (obj) | scm_tc3_struct); - SCM_CRITICAL_SECTION_END; - - scm_struct_init (obj, layout, n_tail, n_init, v); - SCM_SET_VTABLE_FLAGS (obj, - SCM_VTABLE_FLAG_VTABLE | SCM_VTABLE_FLAG_VALIDATED); - - return obj; -} -#undef FUNC_NAME -#endif - SCM scm_i_make_vtable_vtable (SCM user_fields) #define FUNC_NAME "make-vtable-vtable" @@ -922,55 +865,6 @@ scm_struct_ihashq (SCM obj, unsigned long n, void *closure) return SCM_UNPACK (obj) % n; } -/* Return the hash of struct OBJ, modulo N. Traverse OBJ's fields to - compute the result, unless DEPTH is zero. */ -unsigned long -scm_i_struct_hash (SCM obj, unsigned long n, size_t depth) -#define FUNC_NAME "hash" -{ - SCM layout; - scm_t_bits *data; - size_t struct_size, field_num; - unsigned long hash; - - SCM_VALIDATE_STRUCT (1, obj); - - layout = SCM_STRUCT_LAYOUT (obj); - struct_size = scm_i_symbol_length (layout) / 2; - data = SCM_STRUCT_DATA (obj); - - hash = SCM_UNPACK (SCM_STRUCT_VTABLE (obj)) % n; - if (depth > 0) - for (field_num = 0; field_num < struct_size; field_num++) - { - int protection; - - protection = scm_i_symbol_ref (layout, field_num * 2 + 1); - if (protection != 'h' && protection != 'o') - { - int type; - type = scm_i_symbol_ref (layout, field_num * 2); - switch (type) - { - case 'p': - hash ^= scm_hasher (SCM_PACK (data[field_num]), n, - depth / 2); - break; - case 'u': - hash ^= data[field_num] % n; - break; - default: - /* Ignore 's' fields. */; - } - } - } - - /* FIXME: Tail elements should be taken into account. */ - - return hash % n; -} -#undef FUNC_NAME - SCM_DEFINE (scm_struct_vtable_name, "struct-vtable-name", 1, 0, 0, (SCM vtable), "Return the name of the vtable @var{vtable}.") @@ -1008,22 +902,22 @@ scm_print_struct (SCM exp, SCM port, scm_print_state *pstate) { SCM vtable = SCM_STRUCT_VTABLE (exp); SCM name = scm_struct_vtable_name (vtable); - scm_puts ("#<", port); + scm_puts_unlocked ("#<", port); if (scm_is_true (name)) { scm_display (name, port); - scm_putc (' ', port); + scm_putc_unlocked (' ', port); } else { if (SCM_VTABLE_FLAG_IS_SET (vtable, SCM_VTABLE_FLAG_VTABLE)) - scm_puts ("vtable:", port); + scm_puts_unlocked ("vtable:", port); else - scm_puts ("struct:", port); + scm_puts_unlocked ("struct:", port); scm_uintprint (SCM_UNPACK (vtable), 16, port); - scm_putc (' ', port); + scm_putc_unlocked (' ', port); scm_write (SCM_VTABLE_LAYOUT (vtable), port); - scm_putc (' ', port); + scm_putc_unlocked (' ', port); } scm_uintprint (SCM_UNPACK (exp), 16, port); /* hackety hack */ @@ -1031,19 +925,19 @@ scm_print_struct (SCM exp, SCM port, scm_print_state *pstate) { if (scm_is_true (SCM_STRUCT_PROCEDURE (exp))) { - scm_puts (" proc: ", port); + scm_puts_unlocked (" proc: ", port); if (scm_is_true (scm_procedure_p (SCM_STRUCT_PROCEDURE (exp)))) scm_write (SCM_STRUCT_PROCEDURE (exp), port); else - scm_puts ("(not a procedure?)", port); + scm_puts_unlocked ("(not a procedure?)", port); } if (SCM_STRUCT_SETTER_P (exp)) { - scm_puts (" setter: ", port); + scm_puts_unlocked (" setter: ", port); scm_write (SCM_STRUCT_SETTER (exp), port); } } - scm_putc ('>', port); + scm_putc_unlocked ('>', port); } } @@ -1095,9 +989,6 @@ scm_init_struct () scm_from_int (scm_vtable_index_instance_printer)); scm_c_define ("vtable-offset-user", scm_from_int (scm_vtable_offset_user)); #include "libguile/struct.x" -#if SCM_ENABLE_DEPRECATED - scm_c_define_gsubr ("make-vtable-vtable", 2, 0, 1, scm_make_vtable_vtable); -#endif } /* diff --git a/libguile/struct.h b/libguile/struct.h index 643fd9dc9..97b6768ad 100644 --- a/libguile/struct.h +++ b/libguile/struct.h @@ -181,9 +181,6 @@ SCM_API SCM scm_c_make_structv (SCM vtable, size_t n_tail, size_t n_inits, scm_t_bits init[]); SCM_API SCM scm_make_vtable (SCM fields, SCM printer); SCM_INTERNAL SCM scm_i_make_vtable_vtable (SCM extra_fields); -#if SCM_ENABLE_DEPRECATED == 1 -SCM_DEPRECATED SCM scm_make_vtable_vtable (SCM extra_fields, SCM tail_array_size, SCM init); -#endif SCM_API SCM scm_struct_ref (SCM handle, SCM pos); SCM_API SCM scm_struct_set_x (SCM handle, SCM pos, SCM val); SCM_API SCM scm_struct_vtable (SCM handle); @@ -193,8 +190,6 @@ SCM_API void scm_print_struct (SCM exp, SCM port, scm_print_state *); SCM_INTERNAL SCM scm_i_struct_equalp (SCM s1, SCM s2); SCM_INTERNAL unsigned long scm_struct_ihashq (SCM, unsigned long, void *); -SCM_INTERNAL unsigned long scm_i_struct_hash (SCM s, unsigned long n, - size_t depth); SCM_INTERNAL SCM scm_i_alloc_struct (scm_t_bits *vtable_data, int n_words); SCM_INTERNAL void scm_i_struct_inherit_vtable_magic (SCM vtable, SCM obj); SCM_INTERNAL void scm_init_struct (void); diff --git a/libguile/symbols.c b/libguile/symbols.c index 08512a63f..f93833b9d 100644 --- a/libguile/symbols.c +++ b/libguile/symbols.c @@ -1,5 +1,5 @@ /* Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001, 2003, 2004, - * 2006, 2009, 2011 Free Software Foundation, Inc. + * 2006, 2009, 2011, 2013 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -23,6 +23,8 @@ # include <config.h> #endif +#include <unistr.h> + #include "libguile/_scm.h" #include "libguile/chars.h" #include "libguile/eval.h" @@ -33,8 +35,7 @@ #include "libguile/fluids.h" #include "libguile/strings.h" #include "libguile/vectors.h" -#include "libguile/hashtab.h" -#include "libguile/weaks.h" +#include "libguile/weak-set.h" #include "libguile/modules.h" #include "libguile/read.h" #include "libguile/srfi-13.h" @@ -52,7 +53,6 @@ static SCM symbols; -static scm_i_pthread_mutex_t symbols_lock = SCM_I_PTHREAD_MUTEX_INITIALIZER; #ifdef GUILE_DEBUG SCM_DEFINE (scm_sys_symbols, "%symbols", 0, 0, 0, @@ -104,21 +104,13 @@ static SCM lookup_interned_symbol (SCM name, unsigned long raw_hash) { struct string_lookup_data data; - SCM handle; data.string = name; data.string_hash = raw_hash; - scm_i_pthread_mutex_lock (&symbols_lock); - handle = scm_hash_fn_get_handle_by_hash (symbols, raw_hash, - string_lookup_predicate_fn, - &data); - scm_i_pthread_mutex_unlock (&symbols_lock); - - if (scm_is_true (handle)) - return SCM_CAR (handle); - else - return SCM_BOOL_F; + return scm_c_weak_set_lookup (symbols, raw_hash, + string_lookup_predicate_fn, + &data, SCM_BOOL_F); } struct latin1_lookup_data @@ -144,63 +136,104 @@ lookup_interned_latin1_symbol (const char *str, size_t len, unsigned long raw_hash) { struct latin1_lookup_data data; - SCM handle; data.str = str; data.len = len; data.string_hash = raw_hash; - scm_i_pthread_mutex_lock (&symbols_lock); - handle = scm_hash_fn_get_handle_by_hash (symbols, raw_hash, - latin1_lookup_predicate_fn, - &data); - scm_i_pthread_mutex_unlock (&symbols_lock); - - if (scm_is_true (handle)) - return SCM_CAR (handle); - else - return SCM_BOOL_F; + return scm_c_weak_set_lookup (symbols, raw_hash, + latin1_lookup_predicate_fn, + &data, SCM_BOOL_F); } -static unsigned long -symbol_lookup_hash_fn (SCM obj, unsigned long max, void *closure) +struct utf8_lookup_data { - return scm_i_symbol_hash (obj) % max; -} + const char *str; + size_t len; + unsigned long string_hash; +}; -static SCM -symbol_lookup_assoc_fn (SCM obj, SCM alist, void *closure) +static int +utf8_string_equals_wide_string (const scm_t_uint8 *narrow, size_t nlen, + const scm_t_wchar *wide, size_t wlen) { - for (; !scm_is_null (alist); alist = SCM_CDR (alist)) + size_t byte_idx = 0, char_idx = 0; + + while (byte_idx < nlen && char_idx < wlen) { - SCM sym = SCM_CAAR (alist); - - if (scm_i_symbol_hash (sym) == scm_i_symbol_hash (obj) - && scm_is_true (scm_string_equal_p (scm_symbol_to_string (sym), - scm_symbol_to_string (obj)))) - return SCM_CAR (alist); + ucs4_t c; + int nbytes; + + nbytes = u8_mbtouc (&c, narrow + byte_idx, nlen - byte_idx); + if (nbytes == 0) + break; + else if (c == 0xfffd) + /* Bad UTF-8. */ + return 0; + else if (c != wide[char_idx]) + return 0; + + byte_idx += nbytes; + char_idx++; } - return SCM_BOOL_F; + return byte_idx == nlen && char_idx == wlen; } -/* Intern SYMBOL, an uninterned symbol. Might return a different - symbol, if another one was interned at the same time. */ -static SCM -intern_symbol (SCM symbol) +static int +utf8_lookup_predicate_fn (SCM sym, void *closure) { - SCM handle; + struct utf8_lookup_data *data = closure; - scm_i_pthread_mutex_lock (&symbols_lock); - handle = scm_hash_fn_create_handle_x (symbols, symbol, SCM_UNDEFINED, - symbol_lookup_hash_fn, - symbol_lookup_assoc_fn, - NULL); - scm_i_pthread_mutex_unlock (&symbols_lock); + if (scm_i_symbol_hash (sym) != data->string_hash) + return 0; + + if (scm_i_is_narrow_symbol (sym)) + return (scm_i_symbol_length (sym) == data->len + && strncmp (scm_i_symbol_chars (sym), data->str, data->len) == 0); + else + return utf8_string_equals_wide_string ((const scm_t_uint8 *) data->str, + data->len, + scm_i_symbol_wide_chars (sym), + scm_i_symbol_length (sym)); +} - return SCM_CAR (handle); +static SCM +lookup_interned_utf8_symbol (const char *str, size_t len, + unsigned long raw_hash) +{ + struct utf8_lookup_data data; + + data.str = str; + data.len = len; + data.string_hash = raw_hash; + + return scm_c_weak_set_lookup (symbols, raw_hash, + utf8_lookup_predicate_fn, + &data, SCM_BOOL_F); } +static int +symbol_lookup_predicate_fn (SCM sym, void *closure) +{ + SCM other = SCM_PACK_POINTER (closure); + + if (scm_i_symbol_hash (sym) == scm_i_symbol_hash (other) + && scm_i_symbol_length (sym) == scm_i_symbol_length (other)) + { + if (scm_i_is_narrow_symbol (sym)) + return scm_i_is_narrow_symbol (other) + && (strncmp (scm_i_symbol_chars (sym), + scm_i_symbol_chars (other), + scm_i_symbol_length (other)) == 0); + else + return scm_is_true + (scm_string_equal_p (scm_symbol_to_string (sym), + scm_symbol_to_string (other))); + } + return 0; +} + static SCM scm_i_str2symbol (SCM str) { @@ -215,7 +248,12 @@ scm_i_str2symbol (SCM str) /* The symbol was not found, create it. */ symbol = scm_i_make_symbol (str, 0, raw_hash, scm_cons (SCM_BOOL_F, SCM_EOL)); - return intern_symbol (symbol); + + /* Might return a different symbol, if another one was interned at + the same time. */ + return scm_c_weak_set_add_x (symbols, raw_hash, + symbol_lookup_predicate_fn, + SCM_UNPACK_POINTER (symbol), symbol); } } @@ -491,14 +529,27 @@ scm_from_utf8_symbol (const char *sym) SCM scm_from_utf8_symboln (const char *sym, size_t len) { - SCM str = scm_from_utf8_stringn (sym, len); - return scm_i_str2symbol (str); + unsigned long hash; + SCM ret; + + if (len == (size_t) -1) + len = strlen (sym); + hash = scm_i_utf8_string_hash (sym, len); + + ret = lookup_interned_utf8_symbol (sym, len, hash); + if (scm_is_false (ret)) + { + SCM str = scm_from_utf8_stringn (sym, len); + ret = scm_i_str2symbol (str); + } + + return ret; } void scm_symbols_prehistory () { - symbols = scm_make_weak_key_hash_table (scm_from_int (2139)); + symbols = scm_c_make_weak_set (5000); } diff --git a/libguile/symbols.h b/libguile/symbols.h index 6106f9ef1..f345e7033 100644 --- a/libguile/symbols.h +++ b/libguile/symbols.h @@ -3,7 +3,7 @@ #ifndef SCM_SYMBOLS_H #define SCM_SYMBOLS_H -/* Copyright (C) 1995,1996,1997,1998,2000,2001, 2003, 2004, 2006, 2008, 2010 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1997,1998,2000,2001, 2003, 2004, 2006, 2008, 2010, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -26,8 +26,7 @@ #include "libguile/__scm.h" -#define scm_is_symbol(x) (!SCM_IMP (x) \ - && (SCM_TYP7 (x) == scm_tc7_symbol)) +#define scm_is_symbol(x) (SCM_HAS_TYP7 (x, scm_tc7_symbol)) #define scm_i_symbol_hash(x) ((unsigned long) SCM_CELL_WORD_2 (x)) #define scm_i_symbol_is_interned(x) \ (!(SCM_CELL_WORD_0 (x) & SCM_I_F_SYMBOL_UNINTERNED)) @@ -91,7 +90,7 @@ SCM_API SCM scm_take_utf8_symboln (char *sym, size_t len); /* internal functions. */ SCM_INTERNAL unsigned long scm_i_hash_symbol (SCM obj, unsigned long n, - void *closure); + void *closure); SCM_INTERNAL void scm_symbols_prehistory (void); SCM_INTERNAL void scm_init_symbols (void); diff --git a/libguile/tags.h b/libguile/tags.h index a3032bfa9..a194ea0be 100644 --- a/libguile/tags.h +++ b/libguile/tags.h @@ -3,7 +3,7 @@ #ifndef SCM_TAGS_H #define SCM_TAGS_H -/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2008,2009,2010,2012 +/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2008,2009,2010,2011,2012 * Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or @@ -113,6 +113,11 @@ typedef union SCM { struct { scm_t_bits n; } n; } SCM; # define SCM_PACK(x) ((SCM) (x)) #endif +/* Packing SCM objects into and out of pointers. + */ +#define SCM_UNPACK_POINTER(x) ((scm_t_bits *) (SCM_UNPACK (x))) +#define SCM_PACK_POINTER(x) (SCM_PACK ((scm_t_bits) (x))) + /* SCM values can not be compared by using the operator ==. Use the following * macro instead, which is the equivalent of the scheme predicate 'eq?'. @@ -123,51 +128,57 @@ typedef union SCM { struct { scm_t_bits n; } n; } SCM; /* Representation of scheme objects: * - * Guile's type system is designed to work on systems where scm_t_bits and SCM - * variables consist of at least 32 bits. The objects that a SCM variable can - * represent belong to one of the following two major categories: - * - * - Immediates -- meaning that the SCM variable contains an entire Scheme - * object. That means, all the object's data (including the type tagging - * information that is required to identify the object's type) must fit into - * 32 bits. - * - * - Non-immediates -- meaning that the SCM variable holds a pointer into the - * heap of cells (see below). On systems where a pointer needs more than 32 - * bits this means that scm_t_bits and SCM variables need to be large enough - * to hold such pointers. In contrast to immediates, the object's data of - * a non-immediate can consume arbitrary amounts of memory: The heap cell - * being pointed to consists of at least two scm_t_bits variables and thus - * can be used to hold pointers to malloc'ed memory of any size. - * - * The 'heap' is the memory area that is under control of Guile's garbage - * collector. It holds 'single-cells' or 'double-cells', which consist of - * either two or four scm_t_bits variables, respectively. It is guaranteed - * that the address of a cell on the heap is 8-byte aligned. That is, since - * non-immediates hold a cell address, the three least significant bits of a - * non-immediate can be used to store additional information. The bits are - * used to store information about the object's type and thus are called - * tc3-bits, where tc stands for type-code. - * - * For a given SCM value, the distinction whether it holds an immediate or - * non-immediate object is based on the tc3-bits (see above) of its scm_t_bits + * Guile's type system is designed to work on systems where scm_t_bits + * and SCM variables consist of at least 32 bits. The objects that a + * SCM variable can represent belong to one of the following two major + * categories: + * + * - Immediates -- meaning that the SCM variable contains an entire + * Scheme object. That means, all the object's data (including the + * type tagging information that is required to identify the object's + * type) must fit into 32 bits. + * + * - Heap objects -- meaning that the SCM variable holds a pointer into + * the heap. On systems where a pointer needs more than 32 bits this + * means that scm_t_bits and SCM variables need to be large enough to + * hold such pointers. In contrast to immediates, the data associated + * with a heap object can consume arbitrary amounts of memory. + * + * The 'heap' is the memory area that is under control of Guile's + * garbage collector. It holds allocated memory of various sizes. The + * impact on the runtime type system is that Guile needs to be able to + * determine the type of an object given the pointer. Usually the way + * that Guile does this is by storing a "type tag" in the first word of + * the object. + * + * Some objects are common enough that they get special treatment. + * Since Guile guarantees that the address of a GC-allocated object on + * the heap is 8-byte aligned, Guile can play tricks with the lower 3 + * bits. That is, since heap objects encode a pointer to an + * 8-byte-aligned pointer, the three least significant bits of a SCM can + * be used to store additional information. The bits are used to store + * information about the object's type and thus are called tc3-bits, + * where tc stands for type-code. + * + * For a given SCM value, the distinction whether it holds an immediate + * or heap object is based on the tc3-bits (see above) of its scm_t_bits * equivalent: If the tc3-bits equal #b000, then the SCM value holds a - * non-immediate, and the scm_t_bits variable's value is just the pointer to - * the heap cell. + * heap object, and the scm_t_bits variable's value is just the pointer + * to the heap cell. * * Summarized, the data of a scheme object that is represented by a SCM - * variable consists of a) the SCM variable itself, b) in case of - * non-immediates the data of the single-cell or double-cell the SCM object - * points to, c) in case of non-immediates potentially additional data outside - * of the heap (like for example malloc'ed data), and d) in case of - * non-immediates potentially additional data inside of the heap, since data - * stored in b) and c) may hold references to other cells. + * variable consists of a) the SCM variable itself, b) in case of heap + * objects memory that the SCM object points to, c) in case of heap + * objects potentially additional data outside of the heap (like for + * example malloc'ed data), and d) in case of heap objects potentially + * additional data inside of the heap, since data stored in b) and c) + * may hold references to other cells. * * * Immediates * * Operations on immediate objects can typically be processed faster than on - * non-immediates. The reason is that the object's data can be extracted + * heap objects. The reason is that the object's data can be extracted * directly from the SCM variable (or rather a corresponding scm_t_bits * variable), instead of having to perform additional memory accesses to * obtain the object's data from the heap. In order to get the best possible @@ -201,69 +212,56 @@ typedef union SCM { struct { scm_t_bits n; } n; } SCM; * special objects listed above. * * - * Non-Immediates - * - * All object types not mentioned above in the list of immedate objects are - * represented as non-immediates. Whether a non-immediate scheme object is - * represented by a single-cell or a double-cell depends on the object's type, - * namely on the set of attributes that have to be stored with objects of that - * type. Every non-immediate type is allowed to define its own layout and - * interpretation of the data stored in its cell (with some restrictions, see - * below). - * - * One of the design goals of guile's type system is to make it possible to - * store a scheme pair with as little memory usage as possible. The minimum - * amount of memory that is required to store two scheme objects (car and cdr - * of a pair) is the amount of memory required by two scm_t_bits or SCM - * variables. Therefore pairs in guile are stored in single-cells. - * - * Another design goal for the type system is to store procedure objects - * created by lambda expresssions (closures) and class instances (goops - * objects) with as little memory usage as possible. Closures are represented - * by a reference to the function code and a reference to the closure's - * environment. Class instances are represented by a reference to the - * instance's class definition and a reference to the instance's data. Thus, - * closures as well as class instances also can be stored in single-cells. - * - * Certain other non-immediate types also store their data in single-cells. - * By design decision, the heap is split into areas for single-cells and - * double-cells, but not into areas for single-cells-holding-pairs and areas - * for single-cells-holding-non-pairs. Any single-cell on the heap therefore - * can hold pairs (consisting of two scm_t_bits variables representing two - * scheme objects - the car and cdr of the pair) and non-pairs (consisting of - * two scm_t_bits variables that hold bit patterns as defined by the layout of - * the corresponding object's type). + * Heap Objects + * + * All object types not mentioned above in the list of immedate objects + * are represented as heap objects. The amount of memory referenced by + * a heap object depends on the object's type, namely on the set of + * attributes that have to be stored with objects of that type. Every + * heap object type is allowed to define its own layout and + * interpretation of the data stored in its cell (with some + * restrictions, see below). + * + * One of the design goals of guile's type system is to make it possible + * to store a scheme pair with as little memory usage as possible. The + * minimum amount of memory that is required to store two scheme objects + * (car and cdr of a pair) is the amount of memory required by two + * scm_t_bits or SCM variables. Therefore pairs in guile are stored in + * two words, and are tagged with a bit pattern in the SCM value, not + * with a type tag on the heap. * * * Garbage collection * - * During garbage collection, unreachable cells on the heap will be freed. - * That is, the garbage collector will detect cells which have no SCM variable - * pointing towards them. In order to properly release all memory belonging - * to the object to which a cell belongs, the gc needs to be able to interpret - * the cell contents in the correct way. That means that the gc needs to be - * able to determine the object type associated with a cell only from the cell - * itself. - * - * Consequently, if the gc detects an unreachable single-cell, those two - * scm_t_bits variables must provide enough information to determine whether - * they belong to a pair (i. e. both scm_t_bits variables represent valid - * scheme objects), to a closure, a class instance or if they belong to any - * other non-immediate. Guile's type system is designed to make it possible - * to determine a the type to which a cell belongs in the majority of cases - * from the cell's first scm_t_bits variable. (Given a SCM variable X holding - * a non-immediate object, the macro SCM_CELL_TYPE(X) will deliver the - * corresponding cell's first scm_t_bits variable.) - * - * If the cell holds a scheme pair, then we already know that the first - * scm_t_bits variable of the cell will hold a scheme object with one of the - * following tc3-codes: #b000 (non-immediate), #b010 (small integer), #b110 - * (small integer), #b100 (non-integer immediate). All these tc3-codes have - * in common, that their least significant bit is #b0. This fact is used by - * the garbage collector to identify cells that hold pairs. The remaining - * tc3-codes are assigned as follows: #b001 (class instance or, more - * precisely, a struct, of which a class instance is a special case), #b011 - * (closure), #b101/#b111 (all remaining non-immediate types). + * During garbage collection, unreachable objects on the heap will be + * freed. To determine the set of reachable objects, by default, the GC + * just traces all words in all heap objects. It is possible to + * register custom tracing ("marking") procedures. + * + * If an object is unreachable, by default, the GC just notes this fact + * and moves on. Later allocations will clear out the memory associated + * with the object, and re-use it. It is possible to register custom + * finalizers, however. + * + * + * Run-time type introspection + * + * Guile's type system is designed to make it possible to determine a + * the type of a heap object from the object's first scm_t_bits + * variable. (Given a SCM variable X holding a heap object, the macro + * SCM_CELL_TYPE(X) will deliver the corresponding object's first + * scm_t_bits variable.) + * + * If the object holds a scheme pair, then we already know that the + * first scm_t_bits variable of the cell will hold a scheme object with + * one of the following tc3-codes: #b000 (heap object), #b010 (small + * integer), #b110 (small integer), #b100 (non-integer immediate). All + * these tc3-codes have in common, that their least significant bit is + * #b0. This fact is used by the garbage collector to identify cells + * that hold pairs. The remaining tc3-codes are assigned as follows: + * #b001 (class instance or, more precisely, a struct, of which a class + * instance is a special case), #b011 (closure), #b101/#b111 (all + * remaining heap object types). * * * Summary of type codes of scheme objects (SCM variables) @@ -274,7 +272,7 @@ typedef union SCM { struct { scm_t_bits n; } n; } SCM; * of the SCM variables corresponding scm_t_bits value. * * Note that (as has been explained above) tc1==1 can only occur in the first - * scm_t_bits variable of a cell belonging to a non-immediate object that is + * scm_t_bits variable of a cell belonging to a heap object that is * not a pair. For an explanation of the tc tags with tc1==1, see the next * section with the summary of the type codes on the heap. * @@ -283,13 +281,13 @@ typedef union SCM { struct { scm_t_bits n; } n; } SCM; * (1: This can never be the case for a scheme object.) * * tc2: - * 00: Either a non-immediate or some non-integer immediate + * 00: Either a heap object or some non-integer immediate * (01: This can never be the case for a scheme object.) * 10: Small integer * (11: This can never be the case for a scheme object.) * * tc3: - * 000: a non-immediate object (pair, closure, class instance etc.) + * 000: a heap object (pair, closure, class instance etc.) * (001: This can never be the case for a scheme object.) * 010: an even small integer (least significant bit is 0). * (011: This can never be the case for a scheme object.) @@ -298,8 +296,8 @@ typedef union SCM { struct { scm_t_bits n; } n; } SCM; * 110: an odd small integer (least significant bit is 1). * (111: This can never be the case for a scheme object.) * - * The remaining bits of the non-immediate objects form the pointer to the - * heap cell. The remaining bits of the small integers form the integer's + * The remaining bits of the heap objects form the pointer to the heap + * cell. The remaining bits of the small integers form the integer's * value and sign. Thus, the only scheme objects for which a further * subdivision is of interest are the ones with tc3==100. * @@ -321,19 +319,19 @@ typedef union SCM { struct { scm_t_bits n; } n; } SCM; * * tc2: * 00: the cell belongs to a pair with no short integer in its car. - * 01: the cell belongs to a non-pair (struct or some other non-immediate). + * 01: the cell belongs to a non-pair (struct or some other heap object). * 10: the cell belongs to a pair with a short integer in its car. - * 11: the cell belongs to a non-pair (closure or some other non-immediate). + * 11: the cell belongs to a non-pair (closure or some other heap object). * * tc3: - * 000: the cell belongs to a pair with a non-immediate in its car. + * 000: the cell belongs to a pair with a heap object in its car. * 001: the cell belongs to a struct * 010: the cell belongs to a pair with an even short integer in its car. * 011: the cell belongs to a closure * 100: the cell belongs to a pair with a non-integer immediate in its car. - * 101: the cell belongs to some other non-immediate. + * 101: the cell belongs to some other heap object. * 110: the cell belongs to a pair with an odd short integer in its car. - * 111: the cell belongs to some other non-immediate. + * 111: the cell belongs to some other heap object. * * tc7 (for tc3==1x1): * See below for the list of types. Note the special case of scm_tc7_vector @@ -352,11 +350,12 @@ typedef union SCM { struct { scm_t_bits n; } n; } SCM; -/* Checking if a SCM variable holds an immediate or a non-immediate object: +/* Checking if a SCM variable holds an immediate or a heap object: * This check can either be performed by checking for tc3==000 or tc3==00x, * since for a SCM variable it is known that tc1==0. */ #define SCM_IMP(x) (6 & SCM_UNPACK (x)) #define SCM_NIMP(x) (!SCM_IMP (x)) +#define SCM_HEAP_OBJECT_P(x) (SCM_NIMP (x)) /* Checking if a SCM variable holds an immediate integer: See numbers.h for * the definition of the following macros: SCM_I_FIXNUM_BIT, @@ -364,7 +363,7 @@ typedef union SCM { struct { scm_t_bits n; } n; } SCM; /* Checking if a SCM variable holds a pair (for historical reasons, in Guile * also known as a cons-cell): This is done by first checking that the SCM - * variable holds a non-immediate, and second, by checking that tc1==0 holds + * variable holds a heap object, and second, by checking that tc1==0 holds * for the SCM_CELL_TYPE of the SCM variable. */ @@ -397,6 +396,10 @@ typedef union SCM { struct { scm_t_bits n; } n; } SCM; #define SCM_ITAG7(x) (127 & SCM_UNPACK (x)) #define SCM_TYP7(x) (0x7f & SCM_CELL_TYPE (x)) #define SCM_TYP7S(x) ((0x7f & ~2) & SCM_CELL_TYPE (x)) +#define SCM_HAS_HEAP_TYPE(x, type, tag) \ + (SCM_NIMP (x) && type (x) == (tag)) +#define SCM_HAS_TYP7(x, tag) (SCM_HAS_HEAP_TYPE (x, SCM_TYP7, tag)) +#define SCM_HAS_TYP7S(x, tag) (SCM_HAS_HEAP_TYPE (x, SCM_TYP7S, tag)) #define scm_tc7_symbol 5 #define scm_tc7_variable 7 @@ -420,14 +423,14 @@ typedef union SCM { struct { scm_t_bits n; } n; } SCM; #define scm_tc7_vm 55 #define scm_tc7_vm_cont 71 -#define scm_tc7_prompt 61 -#define scm_tc7_with_fluids 63 +#define scm_tc7_unused_17 61 +#define scm_tc7_unused_21 63 #define scm_tc7_unused_19 69 #define scm_tc7_program 79 -#define scm_tc7_array 85 -#define scm_tc7_bitvector 87 -#define scm_tc7_unused_20 93 -#define scm_tc7_unused_11 95 +#define scm_tc7_weak_set 85 +#define scm_tc7_weak_table 87 +#define scm_tc7_array 93 +#define scm_tc7_bitvector 95 #define scm_tc7_unused_12 101 #define scm_tc7_unused_18 103 #define scm_tc7_unused_13 109 @@ -447,7 +450,8 @@ typedef union SCM { struct { scm_t_bits n; } n; } SCM; /* Definitions for tc16: */ #define SCM_TYP16(x) (0xffff & SCM_CELL_TYPE (x)) -#define SCM_TYP16_PREDICATE(tag, x) (!SCM_IMP (x) && SCM_TYP16 (x) == (tag)) +#define SCM_HAS_TYP16(x, tag) (SCM_HAS_HEAP_TYPE (x, SCM_TYP16, tag)) +#define SCM_TYP16_PREDICATE(tag, x) (SCM_HAS_TYP16 (x, tag)) @@ -621,7 +625,7 @@ enum scm_tc8_tags case scm_tc2_int + 112: case scm_tc2_int + 116: case scm_tc3_imm24 + 112:\ case scm_tc2_int + 120: case scm_tc2_int + 124: case scm_tc3_imm24 + 120 -/* For cons pairs with non-immediate values in the SCM_CAR +/* For cons pairs with heap objects in the SCM_CAR */ #define scm_tcs_cons_nimcar \ scm_tc3_cons + 0:\ @@ -663,13 +667,6 @@ enum scm_tc8_tags -#if (SCM_ENABLE_DEPRECATED == 1) - -#define SCM_CELLP(x) (((sizeof (scm_t_cell) - 1) & SCM_UNPACK (x)) == 0) -#define SCM_NCELLP(x) (!SCM_CELLP (x)) - -#endif - #endif /* SCM_TAGS_H */ /* diff --git a/libguile/threads.c b/libguile/threads.c index a3aee0f17..61fc43e7f 100644 --- a/libguile/threads.c +++ b/libguile/threads.c @@ -63,7 +63,6 @@ #include "libguile/init.h" #include "libguile/scmsigs.h" #include "libguile/strings.h" -#include "libguile/weaks.h" #include <full-read.h> @@ -398,11 +397,11 @@ thread_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED) else id = u.um; - scm_puts ("#<thread ", port); + scm_puts_unlocked ("#<thread ", port); scm_uintprint (id, 10, port); - scm_puts (" (", port); + scm_puts_unlocked (" (", port); scm_uintprint ((scm_t_bits)t, 16, port); - scm_puts (")>", port); + scm_puts_unlocked (")>", port); return 1; } @@ -544,7 +543,9 @@ guilify_self_1 (struct GC_stack_base *base) t.held_mutex = NULL; t.join_queue = SCM_EOL; t.dynamic_state = SCM_BOOL_F; - t.dynwinds = SCM_EOL; + t.dynstack.base = NULL; + t.dynstack.top = NULL; + t.dynstack.limit = NULL; t.active_asyncs = SCM_EOL; t.block_asyncs = 1; t.pending_asyncs = 1; @@ -618,6 +619,10 @@ guilify_self_2 (SCM parent) else t->dynamic_state = scm_i_make_initial_dynamic_state (); + t->dynstack.base = scm_gc_malloc (16 * sizeof (scm_t_bits), "dynstack"); + t->dynstack.limit = t->dynstack.base + 16; + t->dynstack.top = t->dynstack.base + SCM_DYNSTACK_HEADER_LEN; + t->join_queue = make_queue (); t->block_asyncs = 0; @@ -664,10 +669,6 @@ do_thread_exit (void *v) { scm_i_thread *t = (scm_i_thread *) v; - /* Ensure the signal handling thread has been launched, because we might be - shutting it down. This needs to be done in Guile mode. */ - scm_i_ensure_signal_delivery_thread (); - if (!scm_is_false (t->cleanup_handler)) { SCM ptr = t->cleanup_handler; @@ -688,9 +689,9 @@ do_thread_exit (void *v) while (!scm_is_null (t->mutexes)) { - SCM mutex = SCM_WEAK_PAIR_CAR (t->mutexes); + SCM mutex = scm_c_weak_vector_ref (scm_car (t->mutexes), 0); - if (!SCM_UNBNDP (mutex)) + if (scm_is_true (mutex)) { fat_mutex *m = SCM_MUTEX_DATA (mutex); @@ -705,7 +706,7 @@ do_thread_exit (void *v) scm_i_pthread_mutex_unlock (&m->lock); } - t->mutexes = SCM_WEAK_PAIR_CDR (t->mutexes); + t->mutexes = scm_cdr (t->mutexes); } scm_i_pthread_mutex_unlock (&t->admin_mutex); @@ -1300,21 +1301,13 @@ SCM_DEFINE (scm_thread_p, "thread?", 1, 0, 0, #undef FUNC_NAME -static size_t -fat_mutex_free (SCM mx) -{ - fat_mutex *m = SCM_MUTEX_DATA (mx); - scm_i_pthread_mutex_destroy (&m->lock); - return 0; -} - static int fat_mutex_print (SCM mx, SCM port, scm_print_state *pstate SCM_UNUSED) { fat_mutex *m = SCM_MUTEX_DATA (mx); - scm_puts ("#<mutex ", port); + scm_puts_unlocked ("#<mutex ", port); scm_uintprint ((scm_t_bits)m, 16, port); - scm_puts (">", port); + scm_puts_unlocked (">", port); return 1; } @@ -1323,9 +1316,12 @@ make_fat_mutex (int recursive, int unchecked_unlock, int external_unlock) { fat_mutex *m; SCM mx; + scm_i_pthread_mutex_t lock = SCM_I_PTHREAD_MUTEX_INITIALIZER; m = scm_gc_malloc (sizeof (fat_mutex), "mutex"); - scm_i_pthread_mutex_init (&m->lock, NULL); + /* Because PTHREAD_MUTEX_INITIALIZER is static, it's plain old data, + and so we can just copy it. */ + memcpy (&m->lock, &lock, sizeof (m->lock)); m->owner = SCM_BOOL_F; m->level = 0; @@ -1417,7 +1413,8 @@ fat_mutex_lock (SCM mutex, scm_t_timespec *timeout, SCM owner, int *ret) The weak pair itself is eventually removed when MUTEX is unlocked. Note that `t->mutexes' lists mutexes currently held by T, so it should be small. */ - t->mutexes = scm_weak_car_pair (mutex, t->mutexes); + t->mutexes = scm_cons (scm_make_weak_vector (SCM_INUM1, mutex), + t->mutexes); scm_i_pthread_mutex_unlock (&t->admin_mutex); } @@ -1562,6 +1559,25 @@ typedef struct { #define SCM_CONDVARP(x) SCM_SMOB_PREDICATE (scm_tc16_condvar, x) #define SCM_CONDVAR_DATA(x) ((fat_cond *) SCM_SMOB_DATA (x)) +static void +remove_mutex_from_thread (SCM mutex, scm_i_thread *t) +{ + SCM walk, prev; + + for (prev = SCM_BOOL_F, walk = t->mutexes; scm_is_pair (walk); + walk = SCM_CDR (walk)) + { + if (scm_is_eq (mutex, scm_c_weak_vector_ref (SCM_CAR (walk), 0))) + { + if (scm_is_pair (prev)) + SCM_SETCDR (prev, SCM_CDR (walk)); + else + t->mutexes = SCM_CDR (walk); + break; + } + } +} + static int fat_mutex_unlock (SCM mutex, SCM cond, const scm_t_timespec *waittime, int relock) @@ -1606,7 +1622,7 @@ fat_mutex_unlock (SCM mutex, SCM cond, if (m->level == 0) { /* Change the owner of MUTEX. */ - t->mutexes = scm_delq_x (mutex, t->mutexes); + remove_mutex_from_thread (mutex, t); m->owner = unblock_from_queue (m->waiting); } @@ -1640,7 +1656,7 @@ fat_mutex_unlock (SCM mutex, SCM cond, } t->block_asyncs--; - scm_async_click (); + scm_async_tick (); scm_remember_upto_here_2 (cond, mutex); @@ -1654,7 +1670,7 @@ fat_mutex_unlock (SCM mutex, SCM cond, if (m->level == 0) { /* Change the owner of MUTEX. */ - t->mutexes = scm_delq_x (mutex, t->mutexes); + remove_mutex_from_thread (mutex, t); m->owner = unblock_from_queue (m->waiting); } @@ -1750,9 +1766,9 @@ static int fat_cond_print (SCM cv, SCM port, scm_print_state *pstate SCM_UNUSED) { fat_cond *c = SCM_CONDVAR_DATA (cv); - scm_puts ("#<condition-variable ", port); + scm_puts_unlocked ("#<condition-variable ", port); scm_uintprint ((scm_t_bits)c, 16, port); - scm_puts (">", port); + scm_puts_unlocked (">", port); return 1; } @@ -2172,7 +2188,6 @@ scm_init_threads () scm_tc16_mutex = scm_make_smob_type ("mutex", sizeof (fat_mutex)); scm_set_smob_print (scm_tc16_mutex, fat_mutex_print); - scm_set_smob_free (scm_tc16_mutex, fat_mutex_free); scm_tc16_condvar = scm_make_smob_type ("condition-variable", sizeof (fat_cond)); diff --git a/libguile/threads.h b/libguile/threads.h index ec129bc72..3030f6fdc 100644 --- a/libguile/threads.h +++ b/libguile/threads.h @@ -3,7 +3,7 @@ #ifndef SCM_THREADS_H #define SCM_THREADS_H -/* Copyright (C) 1996,1997,1998,2000,2001, 2002, 2003, 2004, 2006, 2007, 2008, 2009, 2011 Free Software Foundation, Inc. +/* Copyright (C) 1996,1997,1998,2000,2001, 2002, 2003, 2004, 2006, 2007, 2008, 2009, 2011, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -27,8 +27,8 @@ #include "libguile/procs.h" #include "libguile/throw.h" #include "libguile/root.h" +#include "libguile/dynstack.h" #include "libguile/iselect.h" -#include "libguile/dynwind.h" #include "libguile/continuations.h" #if SCM_USE_PTHREAD_THREADS @@ -79,7 +79,9 @@ typedef struct scm_i_thread { /* Other thread local things. */ SCM dynamic_state; - SCM dynwinds; + + /* The dynamic stack. */ + scm_t_dynstack dynstack; /* For system asyncs. */ @@ -143,9 +145,6 @@ SCM_INTERNAL void scm_init_thread_procs (void); SCM_INTERNAL void scm_init_threads_default_dynamic_state (void); -#define SCM_THREAD_SWITCHING_CODE \ - do { } while (0) - SCM_API SCM scm_call_with_new_thread (SCM thunk, SCM handler); SCM_API SCM scm_yield (void); SCM_API SCM scm_cancel_thread (SCM t); @@ -203,12 +202,8 @@ SCM_INTERNAL SCM_THREAD_LOCAL scm_i_thread *scm_i_current_thread; # endif /* !SCM_HAVE_THREAD_STORAGE_CLASS */ -# define scm_i_dynwinds() (SCM_I_CURRENT_THREAD->dynwinds) -# define scm_i_set_dynwinds(w) (SCM_I_CURRENT_THREAD->dynwinds = (w)) - #endif /* BUILDING_LIBGUILE */ - SCM_INTERNAL scm_i_pthread_mutex_t scm_i_misc_mutex; /* Convenience functions for working with the pthread API in guile diff --git a/libguile/throw.c b/libguile/throw.c index 9c293516d..ae131d0ad 100644 --- a/libguile/throw.c +++ b/libguile/throw.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995,1996,1997,1998,2000,2001, 2003, 2004, 2006, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1997,1998,2000,2001, 2003, 2004, 2006, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -322,16 +322,22 @@ scm_handle_by_proc_catching_all (void *handler_data, SCM tag, SCM throw_args) int scm_exit_status (SCM args) { - if (!SCM_NULL_OR_NIL_P (args)) + if (scm_is_pair (args)) { SCM cqa = SCM_CAR (args); if (scm_is_integer (cqa)) return (scm_to_int (cqa)); else if (scm_is_false (cqa)) - return 1; + return EXIT_FAILURE; + else + return EXIT_SUCCESS; } - return 0; + else if (scm_is_null (args)) + return EXIT_SUCCESS; + else + /* A type error. Strictly speaking we shouldn't get here. */ + return EXIT_FAILURE; } @@ -364,7 +370,7 @@ handler_message (void *handler_data, SCM tag, SCM args) if (should_print_backtrace (tag, stack)) { - scm_puts ("Backtrace:\n", p); + scm_puts_unlocked ("Backtrace:\n", p); scm_display_backtrace_with_highlights (stack, p, SCM_BOOL_F, SCM_BOOL_F, SCM_EOL); @@ -450,7 +456,10 @@ SCM_SYMBOL (sym_pre_init_catch_tag, "%pre-init-catch-tag"); static SCM pre_init_catch (SCM tag, SCM thunk, SCM handler, SCM pre_unwind_handler) { - SCM vm, prompt, res; + volatile SCM vm, v_handler; + SCM res; + scm_t_dynstack *dynstack = &SCM_I_CURRENT_THREAD->dynstack; + scm_i_jmp_buf registers; /* Only handle catch-alls without pre-unwind handlers */ if (!SCM_UNBNDP (pre_unwind_handler)) @@ -458,22 +467,30 @@ pre_init_catch (SCM tag, SCM thunk, SCM handler, SCM pre_unwind_handler) if (scm_is_false (scm_eqv_p (tag, SCM_BOOL_T))) abort (); + /* These two are volatile, so we know we can access them after a + nonlocal return to the setjmp. */ vm = scm_the_vm (); - prompt = scm_c_make_prompt (sym_pre_init_catch_tag, - SCM_VM_DATA (vm)->fp, SCM_VM_DATA (vm)->sp, - SCM_VM_DATA (vm)->ip, 1, -1, scm_i_dynwinds ()); - scm_i_set_dynwinds (scm_cons (prompt, SCM_PROMPT_DYNWINDS (prompt))); - - if (SCM_PROMPT_SETJMP (prompt)) + v_handler = handler; + + /* Push the prompt onto the dynamic stack. */ + scm_dynstack_push_prompt (dynstack, + SCM_F_DYNSTACK_PROMPT_ESCAPE_ONLY, + sym_pre_init_catch_tag, + SCM_VM_DATA (vm)->fp, + SCM_VM_DATA (vm)->sp, + SCM_VM_DATA (vm)->ip, + ®isters); + + if (SCM_I_SETJMP (registers)) { /* nonlocal exit */ SCM args = scm_i_prompt_pop_abort_args_x (vm); /* cdr past the continuation */ - return scm_apply_0 (handler, scm_cdr (args)); + return scm_apply_0 (v_handler, scm_cdr (args)); } res = scm_call_0 (thunk); - scm_i_set_dynwinds (scm_cdr (scm_i_dynwinds ())); + scm_dynstack_pop (dynstack); return res; } @@ -481,14 +498,10 @@ pre_init_catch (SCM tag, SCM thunk, SCM handler, SCM pre_unwind_handler) static int find_pre_init_catch (void) { - SCM winds; - - /* Search the wind list for an appropriate prompt. - "Waiter, please bring us the wind list." */ - for (winds = scm_i_dynwinds (); scm_is_pair (winds); winds = SCM_CDR (winds)) - if (SCM_PROMPT_P (SCM_CAR (winds)) - && scm_is_eq (SCM_PROMPT_TAG (SCM_CAR (winds)), sym_pre_init_catch_tag)) - return 1; + if (scm_dynstack_find_prompt (&SCM_I_CURRENT_THREAD->dynstack, + sym_pre_init_catch_tag, + NULL, NULL, NULL, NULL, NULL)) + return 1; return 0; } diff --git a/libguile/validate.h b/libguile/validate.h index 0bdc057f9..b4d544151 100644 --- a/libguile/validate.h +++ b/libguile/validate.h @@ -4,7 +4,7 @@ #define SCM_VALIDATE_H /* Copyright (C) 1999, 2000, 2001, 2002, 2004, 2006, 2007, 2009, - * 2012 Free Software Foundation, Inc. + * 2011, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -353,7 +353,7 @@ #define SCM_VALIDATE_ARRAY(pos, v) \ do { \ - SCM_ASSERT (!SCM_IMP (v) \ + SCM_ASSERT (SCM_HEAP_OBJECT_P (v) \ && scm_is_true (scm_array_p (v, SCM_UNDEFINED)), \ v, pos, FUNC_NAME); \ } while (0) diff --git a/libguile/values.c b/libguile/values.c index ef27cadd1..670e22294 100644 --- a/libguile/values.c +++ b/libguile/values.c @@ -60,9 +60,9 @@ print_values (SCM obj, SCM pwps) SCM port = SCM_PORT_WITH_PS_PORT (pwps); scm_print_state *ps = SCM_PRINT_STATE (SCM_PORT_WITH_PS_PS (pwps)); - scm_puts ("#<values ", port); + scm_puts_unlocked ("#<values ", port); scm_iprin1 (values, port, ps); - scm_puts (">", port); + scm_puts_unlocked (">", port); return SCM_UNSPECIFIED; } diff --git a/libguile/variable.c b/libguile/variable.c index a9cc60e20..7b3f3356c 100644 --- a/libguile/variable.c +++ b/libguile/variable.c @@ -36,11 +36,11 @@ void scm_i_variable_print (SCM exp, SCM port, scm_print_state *pstate) { - scm_puts ("#<variable ", port); + scm_puts_unlocked ("#<variable ", port); scm_uintprint (SCM_UNPACK (exp), 16, port); - scm_puts (" value: ", port); + scm_puts_unlocked (" value: ", port); scm_iprin1 (SCM_VARIABLE_REF (exp), port, pstate); - scm_putc('>', port); + scm_putc_unlocked('>', port); } diff --git a/libguile/variable.h b/libguile/variable.h index 20daf853f..c024c8519 100644 --- a/libguile/variable.h +++ b/libguile/variable.h @@ -3,7 +3,7 @@ #ifndef SCM_VARIABLE_H #define SCM_VARIABLE_H -/* Copyright (C) 1995,1996,2000,2001, 2006, 2008 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,2000,2001, 2006, 2008, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -30,7 +30,7 @@ /* Variables */ -#define SCM_VARIABLEP(X) (!SCM_IMP (X) && SCM_TYP7(X) == scm_tc7_variable) +#define SCM_VARIABLEP(X) (SCM_HAS_TYP7 (X, scm_tc7_variable)) #define SCM_VARIABLE_REF(V) SCM_CELL_OBJECT_1 (V) #define SCM_VARIABLE_SET(V, X) SCM_SET_CELL_OBJECT_1 (V, X) #define SCM_VARIABLE_LOC(V) (SCM_CELL_OBJECT_LOC ((V), 1)) diff --git a/libguile/vectors.c b/libguile/vectors.c index b386debf4..920ead10e 100644 --- a/libguile/vectors.c +++ b/libguile/vectors.c @@ -68,9 +68,7 @@ scm_vector_elements (SCM vec, scm_t_array_handle *h, size_t *lenp, ssize_t *incp) { if (SCM_I_WVECTP (vec)) - /* FIXME: We should check each (weak) element of the vector for NULL and - convert it to SCM_BOOL_F. */ - abort (); + scm_wrong_type_arg_msg (NULL, 0, vec, "non-weak vector"); scm_generalized_vector_get_handle (vec, h); if (lenp) @@ -87,9 +85,7 @@ scm_vector_writable_elements (SCM vec, scm_t_array_handle *h, size_t *lenp, ssize_t *incp) { if (SCM_I_WVECTP (vec)) - /* FIXME: We should check each (weak) element of the vector for NULL and - convert it to SCM_BOOL_F. */ - abort (); + scm_wrong_type_arg_msg (NULL, 0, vec, "non-weak vector"); scm_generalized_vector_get_handle (vec, h); if (lenp) @@ -124,7 +120,7 @@ scm_vector_length (SCM v) return scm_from_size_t (dim->ubnd - dim->lbnd + 1); } else - SCM_WTA_DISPATCH_1 (g_vector_length, v, 1, NULL); + return scm_wta_dispatch_1 (g_vector_length, v, 1, "vector-length"); } size_t @@ -206,43 +202,33 @@ scm_vector_ref (SCM v, SCM k) SCM scm_c_vector_ref (SCM v, size_t k) { - if (SCM_I_IS_VECTOR (v)) + if (SCM_I_IS_NONWEAK_VECTOR (v)) { - register SCM elt; - if (k >= SCM_I_VECTOR_LENGTH (v)) scm_out_of_range (NULL, scm_from_size_t (k)); - elt = (SCM_I_VECTOR_ELTS(v))[k]; - - if (SCM_UNPACK (elt) == 0 && SCM_I_WVECTP (v)) - /* ELT was a weak pointer and got nullified by the GC. */ - return SCM_BOOL_F; - - return elt; + return SCM_SIMPLE_VECTOR_REF (v, k); } + else if (SCM_I_WVECTP (v)) + return scm_c_weak_vector_ref (v, k); else if (SCM_I_ARRAYP (v) && SCM_I_ARRAY_NDIM (v) == 1) { scm_t_array_dim *dim = SCM_I_ARRAY_DIMS (v); SCM vv = SCM_I_ARRAY_V (v); - if (SCM_I_IS_VECTOR (vv)) - { - register SCM elt; - - if (k >= dim->ubnd - dim->lbnd + 1) - scm_out_of_range (NULL, scm_from_size_t (k)); - k = SCM_I_ARRAY_BASE (v) + k*dim->inc; - elt = (SCM_I_VECTOR_ELTS (vv))[k]; - - if (SCM_UNPACK (elt) == 0 && (SCM_I_WVECTP (vv))) - /* ELT was a weak pointer and got nullified by the GC. */ - return SCM_BOOL_F; - - return elt; - } - scm_wrong_type_arg_msg (NULL, 0, v, "non-uniform vector"); + + k = SCM_I_ARRAY_BASE (v) + k*dim->inc; + if (k >= dim->ubnd - dim->lbnd + 1) + scm_out_of_range (NULL, scm_from_size_t (k)); + + if (SCM_I_IS_NONWEAK_VECTOR (vv)) + return SCM_SIMPLE_VECTOR_REF (vv, k); + else if (SCM_I_WVECTP (vv)) + return scm_c_weak_vector_ref (vv, k); + else + scm_wrong_type_arg_msg (NULL, 0, v, "non-uniform vector"); } else - SCM_WTA_DISPATCH_2 (g_vector_ref, v, scm_from_size_t (k), 2, NULL); + return scm_wta_dispatch_2 (g_vector_ref, v, scm_from_size_t (k), 2, + "vector-ref"); } SCM_GPROC (s_vector_set_x, "vector-set!", 3, 0, 0, scm_vector_set_x, g_vector_set_x); @@ -270,44 +256,37 @@ scm_vector_set_x (SCM v, SCM k, SCM obj) void scm_c_vector_set_x (SCM v, size_t k, SCM obj) { - if (SCM_I_IS_VECTOR (v)) + if (SCM_I_IS_NONWEAK_VECTOR (v)) { if (k >= SCM_I_VECTOR_LENGTH (v)) - scm_out_of_range (NULL, scm_from_size_t (k)); - (SCM_I_VECTOR_WELTS(v))[k] = obj; - if (SCM_I_WVECTP (v)) - { - /* Make it a weak pointer. */ - SCM *link = & SCM_I_VECTOR_WELTS (v)[k]; - SCM_I_REGISTER_DISAPPEARING_LINK ((void **) link, SCM2PTR (obj)); - } + scm_out_of_range (NULL, scm_from_size_t (k)); + SCM_SIMPLE_VECTOR_SET (v, k, obj); } + else if (SCM_I_WVECTP (v)) + scm_c_weak_vector_set_x (v, k, obj); else if (SCM_I_ARRAYP (v) && SCM_I_ARRAY_NDIM (v) == 1) { scm_t_array_dim *dim = SCM_I_ARRAY_DIMS (v); SCM vv = SCM_I_ARRAY_V (v); - if (SCM_I_IS_VECTOR (vv)) - { - if (k >= dim->ubnd - dim->lbnd + 1) - scm_out_of_range (NULL, scm_from_size_t (k)); - k = SCM_I_ARRAY_BASE (v) + k*dim->inc; - (SCM_I_VECTOR_WELTS (vv))[k] = obj; - - if (SCM_I_WVECTP (vv)) - { - /* Make it a weak pointer. */ - SCM *link = & SCM_I_VECTOR_WELTS (vv)[k]; - SCM_I_REGISTER_DISAPPEARING_LINK ((void **) link, SCM2PTR (obj)); - } - } + + k = SCM_I_ARRAY_BASE (v) + k*dim->inc; + if (k >= dim->ubnd - dim->lbnd + 1) + scm_out_of_range (NULL, scm_from_size_t (k)); + + if (SCM_I_IS_NONWEAK_VECTOR (vv)) + SCM_SIMPLE_VECTOR_SET (vv, k, obj); + else if (SCM_I_WVECTP (vv)) + scm_c_weak_vector_set_x (vv, k, obj); else scm_wrong_type_arg_msg (NULL, 0, v, "non-uniform vector"); } else { if (SCM_UNPACK (g_vector_set_x)) - scm_apply_generic (g_vector_set_x, - scm_list_3 (v, scm_from_size_t (k), obj)); + scm_wta_dispatch_n (g_vector_set_x, + scm_list_3 (v, scm_from_size_t (k), obj), + 0, + "vector-set!"); else scm_wrong_type_arg_msg (NULL, 0, v, "vector"); } @@ -335,28 +314,17 @@ SCM scm_c_make_vector (size_t k, SCM fill) #define FUNC_NAME s_scm_make_vector { - SCM *vector; - - vector = (SCM *) - scm_gc_malloc ((k + SCM_I_VECTOR_HEADER_SIZE) * sizeof (SCM), - "vector"); + SCM vector; + unsigned long int j; - if (k > 0) - { - SCM *base; - unsigned long int j; - - SCM_ASSERT_RANGE (1, scm_from_ulong (k), k <= VECTOR_MAX_LENGTH); + SCM_ASSERT_RANGE (1, scm_from_size_t (k), k <= VECTOR_MAX_LENGTH); - base = vector + SCM_I_VECTOR_HEADER_SIZE; - for (j = 0; j != k; ++j) - base[j] = fill; - } + vector = scm_words ((k << 8) | scm_tc7_vector, k + 1); - ((scm_t_bits *) vector)[0] = (k << 8) | scm_tc7_vector; - ((scm_t_bits *) vector)[1] = 0; + for (j = 0; j < k; ++j) + SCM_SIMPLE_VECTOR_SET (vector, j, fill); - return PTR2SCM (vector); + return vector; } #undef FUNC_NAME @@ -385,72 +353,6 @@ SCM_DEFINE (scm_vector_copy, "vector-copy", 1, 0, 0, #undef FUNC_NAME -/* Weak vectors. */ - -/* Allocate memory for the elements of a weak vector on behalf of the - caller. */ -static SCM -make_weak_vector (scm_t_bits type, size_t c_size) -{ - SCM *vector; - size_t total_size; - - total_size = (c_size + SCM_I_VECTOR_HEADER_SIZE) * sizeof (SCM); - vector = (SCM *) scm_gc_malloc_pointerless (total_size, "weak vector"); - - ((scm_t_bits *) vector)[0] = (c_size << 8) | scm_tc7_wvect; - ((scm_t_bits *) vector)[1] = type; - - return PTR2SCM (vector); -} - -/* Return a new weak vector. The allocated vector will be of the given weak - vector subtype. It will contain SIZE elements which are initialized with - the FILL object, or, if FILL is undefined, with an unspecified object. */ -SCM -scm_i_make_weak_vector (scm_t_bits type, SCM size, SCM fill) -{ - SCM wv, *base; - size_t c_size, j; - - if (SCM_UNBNDP (fill)) - fill = SCM_UNSPECIFIED; - - c_size = scm_to_unsigned_integer (size, 0, VECTOR_MAX_LENGTH); - wv = make_weak_vector (type, c_size); - base = SCM_I_WVECT_GC_WVELTS (wv); - - for (j = 0; j != c_size; ++j) - base[j] = fill; - - return wv; -} - -/* Return a new weak vector with type TYPE and whose content are taken from - list LST. */ -SCM -scm_i_make_weak_vector_from_list (scm_t_bits type, SCM lst) -{ - SCM wv, *elt; - long c_size; - - c_size = scm_ilength (lst); - SCM_ASSERT (c_size >= 0, lst, SCM_ARG2, "scm_i_make_weak_vector_from_list"); - - wv = make_weak_vector(type, (size_t) c_size); - - for (elt = SCM_I_WVECT_GC_WVELTS (wv); - scm_is_pair (lst); - lst = SCM_CDR (lst), elt++) - { - *elt = SCM_CAR (lst); - } - - return wv; -} - - - SCM_DEFINE (scm_vector_to_list, "vector->list", 1, 0, 0, (SCM v), "Return a newly allocated list composed of the elements of @var{v}.\n" diff --git a/libguile/vectors.h b/libguile/vectors.h index 3746e9026..4fe72b0a4 100644 --- a/libguile/vectors.h +++ b/libguile/vectors.h @@ -3,7 +3,7 @@ #ifndef SCM_VECTORS_H #define SCM_VECTORS_H -/* Copyright (C) 1995,1996,1998,2000,2001,2002,2004,2005, 2006, 2008, 2009 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1998,2000,2001,2002,2004,2005, 2006, 2008, 2009, 2011 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -63,31 +63,14 @@ SCM_API SCM *scm_vector_writable_elements (SCM vec, /* Internals */ -/* Vectors have a 2-word header: 1 for the type tag, and 1 for the weak - vector extra data (see below.) */ -#define SCM_I_VECTOR_HEADER_SIZE 2U - -#define SCM_I_IS_VECTOR(x) (!SCM_IMP(x) && (SCM_TYP7S(x)==scm_tc7_vector)) -#define SCM_I_IS_NONWEAK_VECTOR(x) (!SCM_IMP(x) && (SCM_TYP7(x)==scm_tc7_vector)) +#define SCM_I_IS_VECTOR(x) (SCM_HAS_TYP7S (x, scm_tc7_vector)) +#define SCM_I_IS_NONWEAK_VECTOR(x) (SCM_HAS_TYP7 (x, scm_tc7_vector)) #define SCM_I_VECTOR_ELTS(x) ((const SCM *) SCM_I_VECTOR_WELTS (x)) -#define SCM_I_VECTOR_WELTS(x) (SCM_CELL_OBJECT_LOC (x, SCM_I_VECTOR_HEADER_SIZE)) +#define SCM_I_VECTOR_WELTS(x) (SCM_CELL_OBJECT_LOC (x, 1)) #define SCM_I_VECTOR_LENGTH(x) (((size_t) SCM_CELL_WORD_0 (x)) >> 8) SCM_INTERNAL SCM scm_i_vector_equal_p (SCM x, SCM y); -/* Weak vectors share implementation details with ordinary vectors, - but no one else should. */ - -#define SCM_I_WVECTP(x) (!SCM_IMP (x) && \ - SCM_TYP7 (x) == scm_tc7_wvect) -#define SCM_I_WVECT_LENGTH SCM_I_VECTOR_LENGTH -#define SCM_I_WVECT_VELTS SCM_I_VECTOR_ELTS -#define SCM_I_WVECT_GC_WVELTS SCM_I_VECTOR_WELTS -#define SCM_I_WVECT_EXTRA(x) (SCM_CELL_WORD_1 (x)) -#define SCM_I_SET_WVECT_EXTRA(x, t) (SCM_SET_CELL_WORD_1 ((x),(t))) - -SCM_INTERNAL SCM scm_i_make_weak_vector (scm_t_bits type, SCM size, SCM fill); -SCM_INTERNAL SCM scm_i_make_weak_vector_from_list (scm_t_bits type, SCM lst); SCM_INTERNAL void scm_init_vectors (void); diff --git a/libguile/vm-engine.c b/libguile/vm-engine.c index 12e62d52d..159310250 100644 --- a/libguile/vm-engine.c +++ b/libguile/vm-engine.c @@ -53,10 +53,10 @@ VM_NAME (SCM vm, SCM program, SCM *argv, int nargs) SCM *stack_limit = vp->stack_limit; /* stack limit address */ scm_i_thread *current_thread = SCM_I_CURRENT_THREAD; - scm_t_int64 vm_cookie = vp->cookie++; /* Internal variables */ int nvalues = 0; + scm_i_jmp_buf registers; /* used for prompts */ #ifdef HAVE_LABELS_AS_VALUES static const void **jump_table_pointer = NULL; @@ -86,6 +86,24 @@ VM_NAME (SCM vm, SCM program, SCM *argv, int nargs) jump_table = jump_table_pointer; #endif + if (SCM_I_SETJMP (registers)) + { + /* Non-local return. Cache the VM registers back from the vp, and + go to the handler. + + Note, at this point, we must assume that any variable local to + vm_engine that can be assigned *has* been assigned. So we need to pull + all our state back from the ip/fp/sp. + */ + CACHE_REGISTER (); + program = SCM_FRAME_PROGRAM (fp); + CACHE_PROGRAM (); + /* The stack contains the values returned to this continuation, + along with a number-of-values marker -- like an MV return. */ + ABORT_CONTINUATION_HOOK (); + NEXT; + } + /* Initial frame */ CACHE_REGISTER (); PUSH (SCM_PACK (fp)); /* dynamic link */ @@ -113,7 +131,7 @@ VM_NAME (SCM vm, SCM program, SCM *argv, int nargs) { if (SCM_STRUCTP (program) && SCM_STRUCT_APPLICABLE_P (program)) fp[-1] = SCM_STRUCT_PROCEDURE (program); - else if (SCM_NIMP (program) && SCM_TYP7 (program) == scm_tc7_smob + else if (SCM_HAS_TYP7 (program, scm_tc7_smob) && SCM_SMOB_APPLICABLE_P (program)) { /* (smob arg0 ... argN) => (apply-smob smob arg0 ... argN) */ @@ -121,7 +139,7 @@ VM_NAME (SCM vm, SCM program, SCM *argv, int nargs) PUSH (SCM_BOOL_F); for (i = sp - fp; i >= 0; i--) fp[i] = fp[i - 1]; - fp[-1] = SCM_SMOB_DESCRIPTOR (program).apply_trampoline_objcode; + fp[-1] = SCM_SMOB_DESCRIPTOR (program).apply_trampoline; } else { diff --git a/libguile/vm-engine.h b/libguile/vm-engine.h index 46d4cfff0..5a4bf40f3 100644 --- a/libguile/vm-engine.h +++ b/libguile/vm-engine.h @@ -283,7 +283,6 @@ #define CHECK_OVERFLOW() \ do { if (SCM_UNLIKELY (sp >= stack_limit)) goto handle_overflow; } while (0) - #ifdef VM_CHECK_UNDERFLOW #define PRE_CHECK_UNDERFLOW(N) \ VM_ASSERT (sp - (N) > SCM_FRAME_UPPER_ADDRESS (fp), vm_error_stack_underflow ()) diff --git a/libguile/vm-i-scheme.c b/libguile/vm-i-scheme.c index b85d980fd..dce90e326 100644 --- a/libguile/vm-i-scheme.c +++ b/libguile/vm-i-scheme.c @@ -65,7 +65,19 @@ VM_DEFINE_FUNCTION (133, not_nullp, "not-null?", 1) RETURN (scm_from_bool (!scm_is_null (x))); } -VM_DEFINE_FUNCTION (134, eqv, "eqv?", 2) +VM_DEFINE_FUNCTION (134, nilp, "nil?", 1) +{ + ARGS1 (x); + RETURN (scm_from_bool (scm_is_lisp_false (x))); +} + +VM_DEFINE_FUNCTION (135, not_nilp, "not-nil?", 1) +{ + ARGS1 (x); + RETURN (scm_from_bool (!scm_is_lisp_false (x))); +} + +VM_DEFINE_FUNCTION (136, eqv, "eqv?", 2) { ARGS2 (x, y); if (scm_is_eq (x, y)) @@ -76,7 +88,7 @@ VM_DEFINE_FUNCTION (134, eqv, "eqv?", 2) RETURN (scm_eqv_p (x, y)); } -VM_DEFINE_FUNCTION (135, equal, "equal?", 2) +VM_DEFINE_FUNCTION (137, equal, "equal?", 2) { ARGS2 (x, y); if (scm_is_eq (x, y)) @@ -87,25 +99,25 @@ VM_DEFINE_FUNCTION (135, equal, "equal?", 2) RETURN (scm_equal_p (x, y)); } -VM_DEFINE_FUNCTION (136, pairp, "pair?", 1) +VM_DEFINE_FUNCTION (138, pairp, "pair?", 1) { ARGS1 (x); RETURN (scm_from_bool (scm_is_pair (x))); } -VM_DEFINE_FUNCTION (137, listp, "list?", 1) +VM_DEFINE_FUNCTION (139, listp, "list?", 1) { ARGS1 (x); RETURN (scm_from_bool (scm_ilength (x) >= 0)); } -VM_DEFINE_FUNCTION (138, symbolp, "symbol?", 1) +VM_DEFINE_FUNCTION (140, symbolp, "symbol?", 1) { ARGS1 (x); RETURN (scm_from_bool (scm_is_symbol (x))); } -VM_DEFINE_FUNCTION (139, vectorp, "vector?", 1) +VM_DEFINE_FUNCTION (141, vectorp, "vector?", 1) { ARGS1 (x); RETURN (scm_from_bool (SCM_I_IS_VECTOR (x))); @@ -116,7 +128,7 @@ VM_DEFINE_FUNCTION (139, vectorp, "vector?", 1) * Basic data */ -VM_DEFINE_FUNCTION (140, cons, "cons", 2) +VM_DEFINE_FUNCTION (142, cons, "cons", 2) { ARGS2 (x, y); CONS (x, x, y); @@ -126,21 +138,21 @@ VM_DEFINE_FUNCTION (140, cons, "cons", 2) #define VM_VALIDATE_CONS(x, proc) \ VM_ASSERT (scm_is_pair (x), vm_error_not_a_pair (proc, x)) -VM_DEFINE_FUNCTION (141, car, "car", 1) +VM_DEFINE_FUNCTION (143, car, "car", 1) { ARGS1 (x); VM_VALIDATE_CONS (x, "car"); RETURN (SCM_CAR (x)); } -VM_DEFINE_FUNCTION (142, cdr, "cdr", 1) +VM_DEFINE_FUNCTION (144, cdr, "cdr", 1) { ARGS1 (x); VM_VALIDATE_CONS (x, "cdr"); RETURN (SCM_CDR (x)); } -VM_DEFINE_INSTRUCTION (143, set_car, "set-car!", 0, 2, 0) +VM_DEFINE_INSTRUCTION (145, set_car, "set-car!", 0, 2, 0) { SCM x, y; POP2 (y, x); @@ -149,7 +161,7 @@ VM_DEFINE_INSTRUCTION (143, set_car, "set-car!", 0, 2, 0) NEXT; } -VM_DEFINE_INSTRUCTION (144, set_cdr, "set-cdr!", 0, 2, 0) +VM_DEFINE_INSTRUCTION (146, set_cdr, "set-cdr!", 0, 2, 0) { SCM x, y; POP2 (y, x); @@ -174,27 +186,27 @@ VM_DEFINE_INSTRUCTION (144, set_cdr, "set-cdr!", 0, 2, 0) RETURN (srel (x, y)); \ } -VM_DEFINE_FUNCTION (145, ee, "ee?", 2) +VM_DEFINE_FUNCTION (147, ee, "ee?", 2) { REL (==, scm_num_eq_p); } -VM_DEFINE_FUNCTION (146, lt, "lt?", 2) +VM_DEFINE_FUNCTION (148, lt, "lt?", 2) { REL (<, scm_less_p); } -VM_DEFINE_FUNCTION (147, le, "le?", 2) +VM_DEFINE_FUNCTION (149, le, "le?", 2) { REL (<=, scm_leq_p); } -VM_DEFINE_FUNCTION (148, gt, "gt?", 2) +VM_DEFINE_FUNCTION (150, gt, "gt?", 2) { REL (>, scm_gr_p); } -VM_DEFINE_FUNCTION (149, ge, "ge?", 2) +VM_DEFINE_FUNCTION (151, ge, "ge?", 2) { REL (>=, scm_geq_p); } @@ -276,7 +288,7 @@ VM_DEFINE_FUNCTION (149, ge, "ge?", 2) #endif -VM_DEFINE_FUNCTION (150, add, "add", 2) +VM_DEFINE_FUNCTION (152, add, "add", 2) { #ifndef ASM_ADD FUNC2 (+, scm_sum); @@ -288,7 +300,7 @@ VM_DEFINE_FUNCTION (150, add, "add", 2) #endif } -VM_DEFINE_FUNCTION (151, add1, "add1", 1) +VM_DEFINE_FUNCTION (153, add1, "add1", 1) { ARGS1 (x); @@ -310,7 +322,7 @@ VM_DEFINE_FUNCTION (151, add1, "add1", 1) RETURN (scm_sum (x, SCM_I_MAKINUM (1))); } -VM_DEFINE_FUNCTION (152, sub, "sub", 2) +VM_DEFINE_FUNCTION (154, sub, "sub", 2) { #ifndef ASM_SUB FUNC2 (-, scm_difference); @@ -322,7 +334,7 @@ VM_DEFINE_FUNCTION (152, sub, "sub", 2) #endif } -VM_DEFINE_FUNCTION (153, sub1, "sub1", 1) +VM_DEFINE_FUNCTION (155, sub1, "sub1", 1) { ARGS1 (x); @@ -347,42 +359,42 @@ VM_DEFINE_FUNCTION (153, sub1, "sub1", 1) # undef ASM_ADD # undef ASM_SUB -VM_DEFINE_FUNCTION (154, mul, "mul", 2) +VM_DEFINE_FUNCTION (156, mul, "mul", 2) { ARGS2 (x, y); SYNC_REGISTER (); RETURN (scm_product (x, y)); } -VM_DEFINE_FUNCTION (155, div, "div", 2) +VM_DEFINE_FUNCTION (157, div, "div", 2) { ARGS2 (x, y); SYNC_REGISTER (); RETURN (scm_divide (x, y)); } -VM_DEFINE_FUNCTION (156, quo, "quo", 2) +VM_DEFINE_FUNCTION (158, quo, "quo", 2) { ARGS2 (x, y); SYNC_REGISTER (); RETURN (scm_quotient (x, y)); } -VM_DEFINE_FUNCTION (157, rem, "rem", 2) +VM_DEFINE_FUNCTION (159, rem, "rem", 2) { ARGS2 (x, y); SYNC_REGISTER (); RETURN (scm_remainder (x, y)); } -VM_DEFINE_FUNCTION (158, mod, "mod", 2) +VM_DEFINE_FUNCTION (160, mod, "mod", 2) { ARGS2 (x, y); SYNC_REGISTER (); RETURN (scm_modulo (x, y)); } -VM_DEFINE_FUNCTION (159, ash, "ash", 2) +VM_DEFINE_FUNCTION (161, ash, "ash", 2) { ARGS2 (x, y); if (SCM_I_INUMP (x) && SCM_I_INUMP (y)) @@ -411,7 +423,7 @@ VM_DEFINE_FUNCTION (159, ash, "ash", 2) RETURN (scm_ash (x, y)); } -VM_DEFINE_FUNCTION (160, logand, "logand", 2) +VM_DEFINE_FUNCTION (162, logand, "logand", 2) { ARGS2 (x, y); if (SCM_I_INUMP (x) && SCM_I_INUMP (y)) @@ -420,7 +432,7 @@ VM_DEFINE_FUNCTION (160, logand, "logand", 2) RETURN (scm_logand (x, y)); } -VM_DEFINE_FUNCTION (161, logior, "logior", 2) +VM_DEFINE_FUNCTION (163, logior, "logior", 2) { ARGS2 (x, y); if (SCM_I_INUMP (x) && SCM_I_INUMP (y)) @@ -429,7 +441,7 @@ VM_DEFINE_FUNCTION (161, logior, "logior", 2) RETURN (scm_logior (x, y)); } -VM_DEFINE_FUNCTION (162, logxor, "logxor", 2) +VM_DEFINE_FUNCTION (164, logxor, "logxor", 2) { ARGS2 (x, y); if (SCM_I_INUMP (x) && SCM_I_INUMP (y)) @@ -440,10 +452,57 @@ VM_DEFINE_FUNCTION (162, logxor, "logxor", 2) /* + * Strings + */ + +VM_DEFINE_FUNCTION (165, string_length, "string-length", 1) +{ + ARGS1 (str); + if (SCM_LIKELY (scm_is_string (str))) + RETURN (SCM_I_MAKINUM (scm_i_string_length (str))); + else + { + SYNC_REGISTER (); + RETURN (scm_string_length (str)); + } +} + +VM_DEFINE_FUNCTION (166, string_ref, "string-ref", 2) +{ + scm_t_signed_bits i = 0; + ARGS2 (str, idx); + if (SCM_LIKELY (scm_is_string (str) + && SCM_I_INUMP (idx) + && ((i = SCM_I_INUM (idx)) >= 0) + && i < scm_i_string_length (str))) + RETURN (SCM_MAKE_CHAR (scm_i_string_ref (str, i))); + else + { + SYNC_REGISTER (); + RETURN (scm_string_ref (str, idx)); + } +} + +/* No string-set! instruction, as there is no good fast path there. */ + + +/* * Vectors and arrays */ -VM_DEFINE_FUNCTION (163, vector_ref, "vector-ref", 2) +VM_DEFINE_FUNCTION (167, vector_length, "vector-length", 1) +{ + ARGS1 (vect); + if (SCM_LIKELY (SCM_I_IS_VECTOR (vect))) + RETURN (SCM_I_MAKINUM (SCM_I_VECTOR_LENGTH (vect))); + else + { + SYNC_REGISTER (); + RETURN (scm_vector_length (vect)); + } +} + +VM_DEFINE_FUNCTION (168, vector_ref, "vector-ref", 2) { scm_t_signed_bits i = 0; ARGS2 (vect, idx); @@ -459,7 +518,7 @@ VM_DEFINE_FUNCTION (163, vector_ref, "vector-ref", 2) } } -VM_DEFINE_INSTRUCTION (164, vector_set, "vector-set", 0, 3, 0) +VM_DEFINE_INSTRUCTION (169, vector_set, "vector-set", 0, 3, 0) { scm_t_signed_bits i = 0; SCM vect, idx, val; @@ -477,7 +536,7 @@ VM_DEFINE_INSTRUCTION (164, vector_set, "vector-set", 0, 3, 0) NEXT; } -VM_DEFINE_INSTRUCTION (165, make_array, "make-array", 3, -1, 1) +VM_DEFINE_INSTRUCTION (170, make_array, "make-array", 3, -1, 1) { scm_t_uint32 len; SCM shape, ret; @@ -501,20 +560,20 @@ VM_DEFINE_INSTRUCTION (165, make_array, "make-array", 3, -1, 1) #define VM_VALIDATE_STRUCT(obj, proc) \ VM_ASSERT (SCM_STRUCTP (obj), vm_error_not_a_struct (proc, obj)) -VM_DEFINE_FUNCTION (166, struct_p, "struct?", 1) +VM_DEFINE_FUNCTION (171, struct_p, "struct?", 1) { ARGS1 (obj); RETURN (scm_from_bool (SCM_STRUCTP (obj))); } -VM_DEFINE_FUNCTION (167, struct_vtable, "struct-vtable", 1) +VM_DEFINE_FUNCTION (172, struct_vtable, "struct-vtable", 1) { ARGS1 (obj); VM_VALIDATE_STRUCT (obj, "struct_vtable"); RETURN (SCM_STRUCT_VTABLE (obj)); } -VM_DEFINE_INSTRUCTION (168, make_struct, "make-struct", 2, -1, 1) +VM_DEFINE_INSTRUCTION (173, make_struct, "make-struct", 2, -1, 1) { unsigned h = FETCH (); unsigned l = FETCH (); @@ -547,7 +606,7 @@ VM_DEFINE_INSTRUCTION (168, make_struct, "make-struct", 2, -1, 1) NEXT; } -VM_DEFINE_FUNCTION (169, struct_ref, "struct-ref", 2) +VM_DEFINE_FUNCTION (174, struct_ref, "struct-ref", 2) { ARGS2 (obj, pos); @@ -577,7 +636,7 @@ VM_DEFINE_FUNCTION (169, struct_ref, "struct-ref", 2) RETURN (scm_struct_ref (obj, pos)); } -VM_DEFINE_FUNCTION (170, struct_set, "struct-set", 3) +VM_DEFINE_FUNCTION (175, struct_set, "struct-set", 3) { ARGS3 (obj, pos, val); @@ -611,7 +670,7 @@ VM_DEFINE_FUNCTION (170, struct_set, "struct-set", 3) /* * GOOPS support */ -VM_DEFINE_FUNCTION (171, class_of, "class-of", 1) +VM_DEFINE_FUNCTION (176, class_of, "class-of", 1) { ARGS1 (obj); if (SCM_INSTANCEP (obj)) @@ -621,7 +680,7 @@ VM_DEFINE_FUNCTION (171, class_of, "class-of", 1) } /* FIXME: No checking whatsoever. */ -VM_DEFINE_FUNCTION (172, slot_ref, "slot-ref", 2) +VM_DEFINE_FUNCTION (177, slot_ref, "slot-ref", 2) { size_t slot; ARGS2 (instance, idx); @@ -630,7 +689,7 @@ VM_DEFINE_FUNCTION (172, slot_ref, "slot-ref", 2) } /* FIXME: No checking whatsoever. */ -VM_DEFINE_INSTRUCTION (173, slot_set, "slot-set", 0, 3, 0) +VM_DEFINE_INSTRUCTION (178, slot_set, "slot-set", 0, 3, 0) { SCM instance, idx, val; size_t slot; @@ -664,21 +723,21 @@ VM_DEFINE_INSTRUCTION (173, slot_set, "slot-set", 0, 3, 0) #define ALIGNED_P(ptr, type) \ ((scm_t_uintptr) (ptr) % alignof_type (type) == 0) -VM_DEFINE_FUNCTION (174, bv_u16_ref, "bv-u16-ref", 3) +VM_DEFINE_FUNCTION (179, bv_u16_ref, "bv-u16-ref", 3) BV_REF_WITH_ENDIANNESS (u16, u16) -VM_DEFINE_FUNCTION (175, bv_s16_ref, "bv-s16-ref", 3) +VM_DEFINE_FUNCTION (180, bv_s16_ref, "bv-s16-ref", 3) BV_REF_WITH_ENDIANNESS (s16, s16) -VM_DEFINE_FUNCTION (176, bv_u32_ref, "bv-u32-ref", 3) +VM_DEFINE_FUNCTION (181, bv_u32_ref, "bv-u32-ref", 3) BV_REF_WITH_ENDIANNESS (u32, u32) -VM_DEFINE_FUNCTION (177, bv_s32_ref, "bv-s32-ref", 3) +VM_DEFINE_FUNCTION (182, bv_s32_ref, "bv-s32-ref", 3) BV_REF_WITH_ENDIANNESS (s32, s32) -VM_DEFINE_FUNCTION (178, bv_u64_ref, "bv-u64-ref", 3) +VM_DEFINE_FUNCTION (183, bv_u64_ref, "bv-u64-ref", 3) BV_REF_WITH_ENDIANNESS (u64, u64) -VM_DEFINE_FUNCTION (179, bv_s64_ref, "bv-s64-ref", 3) +VM_DEFINE_FUNCTION (184, bv_s64_ref, "bv-s64-ref", 3) BV_REF_WITH_ENDIANNESS (s64, s64) -VM_DEFINE_FUNCTION (180, bv_f32_ref, "bv-f32-ref", 3) +VM_DEFINE_FUNCTION (185, bv_f32_ref, "bv-f32-ref", 3) BV_REF_WITH_ENDIANNESS (f32, ieee_single) -VM_DEFINE_FUNCTION (181, bv_f64_ref, "bv-f64-ref", 3) +VM_DEFINE_FUNCTION (186, bv_f64_ref, "bv-f64-ref", 3) BV_REF_WITH_ENDIANNESS (f64, ieee_double) #undef BV_REF_WITH_ENDIANNESS @@ -756,33 +815,33 @@ BV_REF_WITH_ENDIANNESS (f64, ieee_double) RETURN (scm_bytevector_ ## fn_stem ## _native_ref (bv, idx)); \ } -VM_DEFINE_FUNCTION (182, bv_u8_ref, "bv-u8-ref", 2) +VM_DEFINE_FUNCTION (187, bv_u8_ref, "bv-u8-ref", 2) BV_FIXABLE_INT_REF (u8, u8, uint8, 1) -VM_DEFINE_FUNCTION (183, bv_s8_ref, "bv-s8-ref", 2) +VM_DEFINE_FUNCTION (188, bv_s8_ref, "bv-s8-ref", 2) BV_FIXABLE_INT_REF (s8, s8, int8, 1) -VM_DEFINE_FUNCTION (184, bv_u16_native_ref, "bv-u16-native-ref", 2) +VM_DEFINE_FUNCTION (189, bv_u16_native_ref, "bv-u16-native-ref", 2) BV_FIXABLE_INT_REF (u16, u16_native, uint16, 2) -VM_DEFINE_FUNCTION (185, bv_s16_native_ref, "bv-s16-native-ref", 2) +VM_DEFINE_FUNCTION (190, bv_s16_native_ref, "bv-s16-native-ref", 2) BV_FIXABLE_INT_REF (s16, s16_native, int16, 2) -VM_DEFINE_FUNCTION (186, bv_u32_native_ref, "bv-u32-native-ref", 2) +VM_DEFINE_FUNCTION (191, bv_u32_native_ref, "bv-u32-native-ref", 2) #if SIZEOF_VOID_P > 4 BV_FIXABLE_INT_REF (u32, u32_native, uint32, 4) #else BV_INT_REF (u32, uint32, 4) #endif -VM_DEFINE_FUNCTION (187, bv_s32_native_ref, "bv-s32-native-ref", 2) +VM_DEFINE_FUNCTION (192, bv_s32_native_ref, "bv-s32-native-ref", 2) #if SIZEOF_VOID_P > 4 BV_FIXABLE_INT_REF (s32, s32_native, int32, 4) #else BV_INT_REF (s32, int32, 4) #endif -VM_DEFINE_FUNCTION (188, bv_u64_native_ref, "bv-u64-native-ref", 2) +VM_DEFINE_FUNCTION (193, bv_u64_native_ref, "bv-u64-native-ref", 2) BV_INT_REF (u64, uint64, 8) -VM_DEFINE_FUNCTION (189, bv_s64_native_ref, "bv-s64-native-ref", 2) +VM_DEFINE_FUNCTION (194, bv_s64_native_ref, "bv-s64-native-ref", 2) BV_INT_REF (s64, int64, 8) -VM_DEFINE_FUNCTION (190, bv_f32_native_ref, "bv-f32-native-ref", 2) +VM_DEFINE_FUNCTION (195, bv_f32_native_ref, "bv-f32-native-ref", 2) BV_FLOAT_REF (f32, ieee_single, float, 4) -VM_DEFINE_FUNCTION (191, bv_f64_native_ref, "bv-f64-native-ref", 2) +VM_DEFINE_FUNCTION (196, bv_f64_native_ref, "bv-f64-native-ref", 2) BV_FLOAT_REF (f64, ieee_double, double, 8) #undef BV_FIXABLE_INT_REF @@ -805,21 +864,21 @@ BV_FLOAT_REF (f64, ieee_double, double, 8) } \ } -VM_DEFINE_INSTRUCTION (192, bv_u16_set, "bv-u16-set", 0, 4, 0) +VM_DEFINE_INSTRUCTION (197, bv_u16_set, "bv-u16-set", 0, 4, 0) BV_SET_WITH_ENDIANNESS (u16, u16) -VM_DEFINE_INSTRUCTION (193, bv_s16_set, "bv-s16-set", 0, 4, 0) +VM_DEFINE_INSTRUCTION (198, bv_s16_set, "bv-s16-set", 0, 4, 0) BV_SET_WITH_ENDIANNESS (s16, s16) -VM_DEFINE_INSTRUCTION (194, bv_u32_set, "bv-u32-set", 0, 4, 0) +VM_DEFINE_INSTRUCTION (199, bv_u32_set, "bv-u32-set", 0, 4, 0) BV_SET_WITH_ENDIANNESS (u32, u32) -VM_DEFINE_INSTRUCTION (195, bv_s32_set, "bv-s32-set", 0, 4, 0) +VM_DEFINE_INSTRUCTION (200, bv_s32_set, "bv-s32-set", 0, 4, 0) BV_SET_WITH_ENDIANNESS (s32, s32) -VM_DEFINE_INSTRUCTION (196, bv_u64_set, "bv-u64-set", 0, 4, 0) +VM_DEFINE_INSTRUCTION (201, bv_u64_set, "bv-u64-set", 0, 4, 0) BV_SET_WITH_ENDIANNESS (u64, u64) -VM_DEFINE_INSTRUCTION (197, bv_s64_set, "bv-s64-set", 0, 4, 0) +VM_DEFINE_INSTRUCTION (202, bv_s64_set, "bv-s64-set", 0, 4, 0) BV_SET_WITH_ENDIANNESS (s64, s64) -VM_DEFINE_INSTRUCTION (198, bv_f32_set, "bv-f32-set", 0, 4, 0) +VM_DEFINE_INSTRUCTION (203, bv_f32_set, "bv-f32-set", 0, 4, 0) BV_SET_WITH_ENDIANNESS (f32, ieee_single) -VM_DEFINE_INSTRUCTION (199, bv_f64_set, "bv-f64-set", 0, 4, 0) +VM_DEFINE_INSTRUCTION (204, bv_f64_set, "bv-f64-set", 0, 4, 0) BV_SET_WITH_ENDIANNESS (f64, ieee_double) #undef BV_SET_WITH_ENDIANNESS @@ -899,33 +958,33 @@ BV_SET_WITH_ENDIANNESS (f64, ieee_double) NEXT; \ } -VM_DEFINE_INSTRUCTION (200, bv_u8_set, "bv-u8-set", 0, 3, 0) +VM_DEFINE_INSTRUCTION (205, bv_u8_set, "bv-u8-set", 0, 3, 0) BV_FIXABLE_INT_SET (u8, u8, uint8, 0, SCM_T_UINT8_MAX, 1) -VM_DEFINE_INSTRUCTION (201, bv_s8_set, "bv-s8-set", 0, 3, 0) +VM_DEFINE_INSTRUCTION (206, bv_s8_set, "bv-s8-set", 0, 3, 0) BV_FIXABLE_INT_SET (s8, s8, int8, SCM_T_INT8_MIN, SCM_T_INT8_MAX, 1) -VM_DEFINE_INSTRUCTION (202, bv_u16_native_set, "bv-u16-native-set", 0, 3, 0) +VM_DEFINE_INSTRUCTION (207, bv_u16_native_set, "bv-u16-native-set", 0, 3, 0) BV_FIXABLE_INT_SET (u16, u16_native, uint16, 0, SCM_T_UINT16_MAX, 2) -VM_DEFINE_INSTRUCTION (203, bv_s16_native_set, "bv-s16-native-set", 0, 3, 0) +VM_DEFINE_INSTRUCTION (208, bv_s16_native_set, "bv-s16-native-set", 0, 3, 0) BV_FIXABLE_INT_SET (s16, s16_native, int16, SCM_T_INT16_MIN, SCM_T_INT16_MAX, 2) -VM_DEFINE_INSTRUCTION (204, bv_u32_native_set, "bv-u32-native-set", 0, 3, 0) +VM_DEFINE_INSTRUCTION (209, bv_u32_native_set, "bv-u32-native-set", 0, 3, 0) #if SIZEOF_VOID_P > 4 BV_FIXABLE_INT_SET (u32, u32_native, uint32, 0, SCM_T_UINT32_MAX, 4) #else BV_INT_SET (u32, uint32, 4) #endif -VM_DEFINE_INSTRUCTION (205, bv_s32_native_set, "bv-s32-native-set", 0, 3, 0) +VM_DEFINE_INSTRUCTION (210, bv_s32_native_set, "bv-s32-native-set", 0, 3, 0) #if SIZEOF_VOID_P > 4 BV_FIXABLE_INT_SET (s32, s32_native, int32, SCM_T_INT32_MIN, SCM_T_INT32_MAX, 4) #else BV_INT_SET (s32, int32, 4) #endif -VM_DEFINE_INSTRUCTION (206, bv_u64_native_set, "bv-u64-native-set", 0, 3, 0) +VM_DEFINE_INSTRUCTION (211, bv_u64_native_set, "bv-u64-native-set", 0, 3, 0) BV_INT_SET (u64, uint64, 8) -VM_DEFINE_INSTRUCTION (207, bv_s64_native_set, "bv-s64-native-set", 0, 3, 0) +VM_DEFINE_INSTRUCTION (212, bv_s64_native_set, "bv-s64-native-set", 0, 3, 0) BV_INT_SET (s64, int64, 8) -VM_DEFINE_INSTRUCTION (208, bv_f32_native_set, "bv-f32-native-set", 0, 3, 0) +VM_DEFINE_INSTRUCTION (213, bv_f32_native_set, "bv-f32-native-set", 0, 3, 0) BV_FLOAT_SET (f32, ieee_single, float, 4) -VM_DEFINE_INSTRUCTION (209, bv_f64_native_set, "bv-f64-native-set", 0, 3, 0) +VM_DEFINE_INSTRUCTION (214, bv_f64_native_set, "bv-f64-native-set", 0, 3, 0) BV_FLOAT_SET (f64, ieee_double, double, 8) #undef BV_FIXABLE_INT_SET diff --git a/libguile/vm-i-system.c b/libguile/vm-i-system.c index 34545ddf4..ac1d4a61a 100644 --- a/libguile/vm-i-system.c +++ b/libguile/vm-i-system.c @@ -525,12 +525,25 @@ VM_DEFINE_INSTRUCTION (40, br_if_not_null, "br-if-not-null", 3, 0, 0) BR (!scm_is_null (x)); } +VM_DEFINE_INSTRUCTION (41, br_if_nil, "br-if-nil", 3, 0, 0) +{ + SCM x; + POP (x); + BR (scm_is_lisp_false (x)); +} + +VM_DEFINE_INSTRUCTION (42, br_if_not_nil, "br-if-not-nil", 3, 0, 0) +{ + SCM x; + POP (x); + BR (!scm_is_lisp_false (x)); +} /* * Subprogram call */ -VM_DEFINE_INSTRUCTION (41, br_if_nargs_ne, "br-if-nargs-ne", 5, 0, 0) +VM_DEFINE_INSTRUCTION (43, br_if_nargs_ne, "br-if-nargs-ne", 5, 0, 0) { scm_t_ptrdiff n; scm_t_int32 offset; @@ -542,7 +555,7 @@ VM_DEFINE_INSTRUCTION (41, br_if_nargs_ne, "br-if-nargs-ne", 5, 0, 0) NEXT; } -VM_DEFINE_INSTRUCTION (42, br_if_nargs_lt, "br-if-nargs-lt", 5, 0, 0) +VM_DEFINE_INSTRUCTION (44, br_if_nargs_lt, "br-if-nargs-lt", 5, 0, 0) { scm_t_ptrdiff n; scm_t_int32 offset; @@ -554,7 +567,7 @@ VM_DEFINE_INSTRUCTION (42, br_if_nargs_lt, "br-if-nargs-lt", 5, 0, 0) NEXT; } -VM_DEFINE_INSTRUCTION (43, br_if_nargs_gt, "br-if-nargs-gt", 5, 0, 0) +VM_DEFINE_INSTRUCTION (45, br_if_nargs_gt, "br-if-nargs-gt", 5, 0, 0) { scm_t_ptrdiff n; scm_t_int32 offset; @@ -567,7 +580,7 @@ VM_DEFINE_INSTRUCTION (43, br_if_nargs_gt, "br-if-nargs-gt", 5, 0, 0) NEXT; } -VM_DEFINE_INSTRUCTION (44, assert_nargs_ee, "assert-nargs-ee", 2, 0, 0) +VM_DEFINE_INSTRUCTION (46, assert_nargs_ee, "assert-nargs-ee", 2, 0, 0) { scm_t_ptrdiff n; n = FETCH () << 8; @@ -577,7 +590,7 @@ VM_DEFINE_INSTRUCTION (44, assert_nargs_ee, "assert-nargs-ee", 2, 0, 0) NEXT; } -VM_DEFINE_INSTRUCTION (45, assert_nargs_ge, "assert-nargs-ge", 2, 0, 0) +VM_DEFINE_INSTRUCTION (47, assert_nargs_ge, "assert-nargs-ge", 2, 0, 0) { scm_t_ptrdiff n; n = FETCH () << 8; @@ -587,7 +600,7 @@ VM_DEFINE_INSTRUCTION (45, assert_nargs_ge, "assert-nargs-ge", 2, 0, 0) NEXT; } -VM_DEFINE_INSTRUCTION (46, bind_optionals, "bind-optionals", 2, -1, -1) +VM_DEFINE_INSTRUCTION (48, bind_optionals, "bind-optionals", 2, -1, -1) { scm_t_ptrdiff n; n = FETCH () << 8; @@ -597,7 +610,7 @@ VM_DEFINE_INSTRUCTION (46, bind_optionals, "bind-optionals", 2, -1, -1) NEXT; } -VM_DEFINE_INSTRUCTION (47, bind_optionals_shuffle, "bind-optionals/shuffle", 6, -1, -1) +VM_DEFINE_INSTRUCTION (49, bind_optionals_shuffle, "bind-optionals/shuffle", 6, -1, -1) { SCM *walk; scm_t_ptrdiff nreq, nreq_and_opt, ntotal; @@ -642,7 +655,7 @@ VM_DEFINE_INSTRUCTION (47, bind_optionals_shuffle, "bind-optionals/shuffle", 6, #define F_ALLOW_OTHER_KEYS 1 #define F_REST 2 -VM_DEFINE_INSTRUCTION (48, bind_kwargs, "bind-kwargs", 5, 0, 0) +VM_DEFINE_INSTRUCTION (50, bind_kwargs, "bind-kwargs", 5, 0, 0) { scm_t_uint16 idx; scm_t_ptrdiff nkw; @@ -696,7 +709,7 @@ VM_DEFINE_INSTRUCTION (48, bind_kwargs, "bind-kwargs", 5, 0, 0) #undef F_REST -VM_DEFINE_INSTRUCTION (49, push_rest, "push-rest", 2, -1, -1) +VM_DEFINE_INSTRUCTION (51, push_rest, "push-rest", 2, -1, -1) { scm_t_ptrdiff n; SCM rest = SCM_EOL; @@ -709,7 +722,7 @@ VM_DEFINE_INSTRUCTION (49, push_rest, "push-rest", 2, -1, -1) NEXT; } -VM_DEFINE_INSTRUCTION (50, bind_rest, "bind-rest", 4, -1, -1) +VM_DEFINE_INSTRUCTION (52, bind_rest, "bind-rest", 4, -1, -1) { scm_t_ptrdiff n; scm_t_uint32 i; @@ -725,7 +738,7 @@ VM_DEFINE_INSTRUCTION (50, bind_rest, "bind-rest", 4, -1, -1) NEXT; } -VM_DEFINE_INSTRUCTION (51, reserve_locals, "reserve-locals", 2, -1, -1) +VM_DEFINE_INSTRUCTION (53, reserve_locals, "reserve-locals", 2, -1, -1) { SCM *old_sp; scm_t_int32 n; @@ -746,7 +759,7 @@ VM_DEFINE_INSTRUCTION (51, reserve_locals, "reserve-locals", 2, -1, -1) NEXT; } -VM_DEFINE_INSTRUCTION (52, new_frame, "new-frame", 0, 0, 3) +VM_DEFINE_INSTRUCTION (54, new_frame, "new-frame", 0, 0, 3) { /* NB: if you change this, see frames.c:vm-frame-num-locals */ /* and frames.h, vm-engine.c, etc of course */ @@ -761,7 +774,7 @@ VM_DEFINE_INSTRUCTION (52, new_frame, "new-frame", 0, 0, 3) NEXT; } -VM_DEFINE_INSTRUCTION (53, call, "call", 1, -1, 1) +VM_DEFINE_INSTRUCTION (55, call, "call", 1, -1, 1) { nargs = FETCH (); @@ -795,7 +808,7 @@ VM_DEFINE_INSTRUCTION (53, call, "call", 1, -1, 1) NEXT; } -VM_DEFINE_INSTRUCTION (54, tail_call, "tail-call", 1, -1, 1) +VM_DEFINE_INSTRUCTION (56, tail_call, "tail-call", 1, -1, 1) { nargs = FETCH (); @@ -830,7 +843,7 @@ VM_DEFINE_INSTRUCTION (54, tail_call, "tail-call", 1, -1, 1) NEXT; } -VM_DEFINE_INSTRUCTION (55, subr_call, "subr-call", 1, -1, -1) +VM_DEFINE_INSTRUCTION (57, subr_call, "subr-call", 1, -1, -1) { SCM pointer, ret; SCM (*subr)(); @@ -899,54 +912,9 @@ VM_DEFINE_INSTRUCTION (55, subr_call, "subr-call", 1, -1, -1) } } -VM_DEFINE_INSTRUCTION (56, smob_call, "smob-call", 1, -1, -1) -{ - SCM smob, ret; - SCM (*subr)(); - nargs = FETCH (); - POP (smob); - - subr = SCM_SMOB_DESCRIPTOR (smob).apply; - - VM_HANDLE_INTERRUPTS; - SYNC_REGISTER (); +/* Instruction 58 used to be smob-call. */ - switch (nargs) - { - case 0: - ret = subr (smob); - break; - case 1: - ret = subr (smob, sp[0]); - break; - case 2: - ret = subr (smob, sp[-1], sp[0]); - break; - case 3: - ret = subr (smob, sp[-2], sp[-1], sp[0]); - break; - default: - abort (); - } - - NULLSTACK_FOR_NONLOCAL_EXIT (); - - if (SCM_UNLIKELY (SCM_VALUESP (ret))) - { - /* multiple values returned to continuation */ - ret = scm_struct_ref (ret, SCM_INUM0); - nvalues = scm_ilength (ret); - PUSH_LIST (ret, scm_is_null); - goto vm_return_values; - } - else - { - PUSH (ret); - goto vm_return; - } -} - -VM_DEFINE_INSTRUCTION (57, foreign_call, "foreign-call", 1, -1, -1) +VM_DEFINE_INSTRUCTION (59, foreign_call, "foreign-call", 1, -1, -1) { SCM foreign, ret; nargs = FETCH (); @@ -974,7 +942,7 @@ VM_DEFINE_INSTRUCTION (57, foreign_call, "foreign-call", 1, -1, -1) } } -VM_DEFINE_INSTRUCTION (58, continuation_call, "continuation-call", 0, -1, 0) +VM_DEFINE_INSTRUCTION (60, continuation_call, "continuation-call", 0, -1, 0) { SCM contregs; POP (contregs); @@ -990,32 +958,24 @@ VM_DEFINE_INSTRUCTION (58, continuation_call, "continuation-call", 0, -1, 0) abort (); } -VM_DEFINE_INSTRUCTION (59, partial_cont_call, "partial-cont-call", 0, -1, 0) +VM_DEFINE_INSTRUCTION (61, partial_cont_call, "partial-cont-call", 0, -1, 0) { - SCM vmcont, intwinds, prevwinds; - POP2 (intwinds, vmcont); + SCM vmcont; + POP (vmcont); SYNC_REGISTER (); VM_ASSERT (SCM_VM_CONT_REWINDABLE_P (vmcont), vm_error_continuation_not_rewindable (vmcont)); - prevwinds = scm_i_dynwinds (); - vm_reinstate_partial_continuation (vm, vmcont, intwinds, sp + 1 - fp, fp, - vm_cookie); + vm_reinstate_partial_continuation (vm, vmcont, sp + 1 - fp, fp, + ¤t_thread->dynstack, + ®isters); - /* Rewind prompt jmpbuffers, if any. */ - { - SCM winds = scm_i_dynwinds (); - for (; !scm_is_eq (winds, prevwinds); winds = scm_cdr (winds)) - if (SCM_PROMPT_P (scm_car (winds)) && SCM_PROMPT_SETJMP (scm_car (winds))) - break; - } - CACHE_REGISTER (); program = SCM_FRAME_PROGRAM (fp); CACHE_PROGRAM (); NEXT; } -VM_DEFINE_INSTRUCTION (60, tail_call_nargs, "tail-call/nargs", 0, 0, 1) +VM_DEFINE_INSTRUCTION (62, tail_call_nargs, "tail-call/nargs", 0, 0, 1) { SCM x; POP (x); @@ -1024,7 +984,7 @@ VM_DEFINE_INSTRUCTION (60, tail_call_nargs, "tail-call/nargs", 0, 0, 1) goto vm_tail_call; } -VM_DEFINE_INSTRUCTION (61, call_nargs, "call/nargs", 0, 0, 1) +VM_DEFINE_INSTRUCTION (63, call_nargs, "call/nargs", 0, 0, 1) { SCM x; POP (x); @@ -1033,7 +993,7 @@ VM_DEFINE_INSTRUCTION (61, call_nargs, "call/nargs", 0, 0, 1) goto vm_call; } -VM_DEFINE_INSTRUCTION (62, mv_call, "mv-call", 4, -1, 1) +VM_DEFINE_INSTRUCTION (64, mv_call, "mv-call", 4, -1, 1) { scm_t_int32 offset; scm_t_uint8 *mvra; @@ -1068,7 +1028,7 @@ VM_DEFINE_INSTRUCTION (62, mv_call, "mv-call", 4, -1, 1) NEXT; } -VM_DEFINE_INSTRUCTION (63, apply, "apply", 1, -1, 1) +VM_DEFINE_INSTRUCTION (65, apply, "apply", 1, -1, 1) { int len; SCM ls; @@ -1086,7 +1046,7 @@ VM_DEFINE_INSTRUCTION (63, apply, "apply", 1, -1, 1) goto vm_call; } -VM_DEFINE_INSTRUCTION (64, tail_apply, "tail-apply", 1, -1, 1) +VM_DEFINE_INSTRUCTION (66, tail_apply, "tail-apply", 1, -1, 1) { int len; SCM ls; @@ -1104,13 +1064,16 @@ VM_DEFINE_INSTRUCTION (64, tail_apply, "tail-apply", 1, -1, 1) goto vm_tail_call; } -VM_DEFINE_INSTRUCTION (65, call_cc, "call/cc", 0, 1, 1) +VM_DEFINE_INSTRUCTION (67, call_cc, "call/cc", 0, 1, 1) { int first; SCM proc, vm_cont, cont; + scm_t_dynstack *dynstack; POP (proc); SYNC_ALL (); - vm_cont = scm_i_vm_capture_stack (vp->stack_base, fp, sp, ip, NULL, 0); + dynstack = scm_dynstack_capture_all (¤t_thread->dynstack); + vm_cont = scm_i_vm_capture_stack (vp->stack_base, fp, sp, ip, NULL, + dynstack, 0); cont = scm_i_make_continuation (&first, vm, vm_cont); if (first) { @@ -1139,19 +1102,22 @@ VM_DEFINE_INSTRUCTION (65, call_cc, "call/cc", 0, 1, 1) } } -VM_DEFINE_INSTRUCTION (66, tail_call_cc, "tail-call/cc", 0, 1, 1) +VM_DEFINE_INSTRUCTION (68, tail_call_cc, "tail-call/cc", 0, 1, 1) { int first; SCM proc, vm_cont, cont; + scm_t_dynstack *dynstack; POP (proc); SYNC_ALL (); /* In contrast to call/cc, tail-call/cc captures the continuation without the stack frame. */ + dynstack = scm_dynstack_capture_all (¤t_thread->dynstack); vm_cont = scm_i_vm_capture_stack (vp->stack_base, SCM_FRAME_DYNAMIC_LINK (fp), SCM_FRAME_LOWER_ADDRESS (fp) - 1, SCM_FRAME_RETURN_ADDRESS (fp), SCM_FRAME_MV_RETURN_ADDRESS (fp), + dynstack, 0); cont = scm_i_make_continuation (&first, vm, vm_cont); if (first) @@ -1179,7 +1145,7 @@ VM_DEFINE_INSTRUCTION (66, tail_call_cc, "tail-call/cc", 0, 1, 1) } } -VM_DEFINE_INSTRUCTION (67, return, "return", 0, 1, 1) +VM_DEFINE_INSTRUCTION (69, return, "return", 0, 1, 1) { vm_return: POP_CONTINUATION_HOOK (1); @@ -1215,7 +1181,7 @@ VM_DEFINE_INSTRUCTION (67, return, "return", 0, 1, 1) NEXT; } -VM_DEFINE_INSTRUCTION (68, return_values, "return/values", 1, -1, -1) +VM_DEFINE_INSTRUCTION (70, return_values, "return/values", 1, -1, -1) { /* nvalues declared at top level, because for some reason gcc seems to think that perhaps it might be used without declaration. Fooey to that, I say. */ @@ -1274,7 +1240,7 @@ VM_DEFINE_INSTRUCTION (68, return_values, "return/values", 1, -1, -1) NEXT; } -VM_DEFINE_INSTRUCTION (69, return_values_star, "return/values*", 1, -1, -1) +VM_DEFINE_INSTRUCTION (71, return_values_star, "return/values*", 1, -1, -1) { SCM l; @@ -1294,7 +1260,7 @@ VM_DEFINE_INSTRUCTION (69, return_values_star, "return/values*", 1, -1, -1) goto vm_return_values; } -VM_DEFINE_INSTRUCTION (70, return_nvalues, "return/nvalues", 0, 1, -1) +VM_DEFINE_INSTRUCTION (72, return_nvalues, "return/nvalues", 0, 1, -1) { SCM n; POP (n); @@ -1303,7 +1269,7 @@ VM_DEFINE_INSTRUCTION (70, return_nvalues, "return/nvalues", 0, 1, -1) goto vm_return_values; } -VM_DEFINE_INSTRUCTION (71, truncate_values, "truncate-values", 2, -1, -1) +VM_DEFINE_INSTRUCTION (73, truncate_values, "truncate-values", 2, -1, -1) { SCM x; int nbinds, rest; @@ -1325,7 +1291,7 @@ VM_DEFINE_INSTRUCTION (71, truncate_values, "truncate-values", 2, -1, -1) NEXT; } -VM_DEFINE_INSTRUCTION (72, box, "box", 1, 1, 0) +VM_DEFINE_INSTRUCTION (74, box, "box", 1, 1, 0) { SCM val; POP (val); @@ -1339,7 +1305,7 @@ VM_DEFINE_INSTRUCTION (72, box, "box", 1, 1, 0) (set! a (lambda () (b ...))) ...) */ -VM_DEFINE_INSTRUCTION (73, empty_box, "empty-box", 1, 0, 0) +VM_DEFINE_INSTRUCTION (75, empty_box, "empty-box", 1, 0, 0) { SYNC_BEFORE_GC (); LOCAL_SET (FETCH (), @@ -1347,7 +1313,7 @@ VM_DEFINE_INSTRUCTION (73, empty_box, "empty-box", 1, 0, 0) NEXT; } -VM_DEFINE_INSTRUCTION (74, local_boxed_ref, "local-boxed-ref", 1, 0, 1) +VM_DEFINE_INSTRUCTION (76, local_boxed_ref, "local-boxed-ref", 1, 0, 1) { SCM v = LOCAL_REF (FETCH ()); ASSERT_BOUND_VARIABLE (v); @@ -1355,7 +1321,7 @@ VM_DEFINE_INSTRUCTION (74, local_boxed_ref, "local-boxed-ref", 1, 0, 1) NEXT; } -VM_DEFINE_INSTRUCTION (75, local_boxed_set, "local-boxed-set", 1, 1, 0) +VM_DEFINE_INSTRUCTION (77, local_boxed_set, "local-boxed-set", 1, 1, 0) { SCM v, val; v = LOCAL_REF (FETCH ()); @@ -1365,7 +1331,7 @@ VM_DEFINE_INSTRUCTION (75, local_boxed_set, "local-boxed-set", 1, 1, 0) NEXT; } -VM_DEFINE_INSTRUCTION (76, free_ref, "free-ref", 1, 0, 1) +VM_DEFINE_INSTRUCTION (78, free_ref, "free-ref", 1, 0, 1) { scm_t_uint8 idx = FETCH (); @@ -1376,7 +1342,7 @@ VM_DEFINE_INSTRUCTION (76, free_ref, "free-ref", 1, 0, 1) /* no free-set -- if a var is assigned, it should be in a box */ -VM_DEFINE_INSTRUCTION (77, free_boxed_ref, "free-boxed-ref", 1, 0, 1) +VM_DEFINE_INSTRUCTION (79, free_boxed_ref, "free-boxed-ref", 1, 0, 1) { SCM v; scm_t_uint8 idx = FETCH (); @@ -1387,7 +1353,7 @@ VM_DEFINE_INSTRUCTION (77, free_boxed_ref, "free-boxed-ref", 1, 0, 1) NEXT; } -VM_DEFINE_INSTRUCTION (78, free_boxed_set, "free-boxed-set", 1, 1, 0) +VM_DEFINE_INSTRUCTION (80, free_boxed_set, "free-boxed-set", 1, 1, 0) { SCM v, val; scm_t_uint8 idx = FETCH (); @@ -1399,7 +1365,7 @@ VM_DEFINE_INSTRUCTION (78, free_boxed_set, "free-boxed-set", 1, 1, 0) NEXT; } -VM_DEFINE_INSTRUCTION (79, make_closure, "make-closure", 2, -1, 1) +VM_DEFINE_INSTRUCTION (81, make_closure, "make-closure", 2, -1, 1) { size_t n, len; SCM closure; @@ -1418,7 +1384,7 @@ VM_DEFINE_INSTRUCTION (79, make_closure, "make-closure", 2, -1, 1) NEXT; } -VM_DEFINE_INSTRUCTION (80, make_variable, "make-variable", 0, 0, 1) +VM_DEFINE_INSTRUCTION (82, make_variable, "make-variable", 0, 0, 1) { SYNC_BEFORE_GC (); /* fixme underflow */ @@ -1426,7 +1392,7 @@ VM_DEFINE_INSTRUCTION (80, make_variable, "make-variable", 0, 0, 1) NEXT; } -VM_DEFINE_INSTRUCTION (81, fix_closure, "fix-closure", 2, -1, 0) +VM_DEFINE_INSTRUCTION (83, fix_closure, "fix-closure", 2, -1, 0) { SCM x; unsigned int i = FETCH (); @@ -1443,7 +1409,7 @@ VM_DEFINE_INSTRUCTION (81, fix_closure, "fix-closure", 2, -1, 0) NEXT; } -VM_DEFINE_INSTRUCTION (82, define, "define", 0, 0, 2) +VM_DEFINE_INSTRUCTION (84, define, "define", 0, 0, 2) { SCM sym, val; POP2 (sym, val); @@ -1452,7 +1418,7 @@ VM_DEFINE_INSTRUCTION (82, define, "define", 0, 0, 2) NEXT; } -VM_DEFINE_INSTRUCTION (83, make_keyword, "make-keyword", 0, 1, 1) +VM_DEFINE_INSTRUCTION (85, make_keyword, "make-keyword", 0, 1, 1) { CHECK_UNDERFLOW (); SYNC_REGISTER (); @@ -1460,7 +1426,7 @@ VM_DEFINE_INSTRUCTION (83, make_keyword, "make-keyword", 0, 1, 1) NEXT; } -VM_DEFINE_INSTRUCTION (84, make_symbol, "make-symbol", 0, 1, 1) +VM_DEFINE_INSTRUCTION (86, make_symbol, "make-symbol", 0, 1, 1) { CHECK_UNDERFLOW (); SYNC_REGISTER (); @@ -1468,11 +1434,12 @@ VM_DEFINE_INSTRUCTION (84, make_symbol, "make-symbol", 0, 1, 1) NEXT; } -VM_DEFINE_INSTRUCTION (85, prompt, "prompt", 4, 2, 0) +VM_DEFINE_INSTRUCTION (87, prompt, "prompt", 4, 2, 0) { scm_t_int32 offset; scm_t_uint8 escape_only_p; - SCM k, prompt; + SCM k; + scm_t_dynstack_prompt_flags flags; escape_only_p = FETCH (); FETCH_OFFSET (offset); @@ -1480,92 +1447,66 @@ VM_DEFINE_INSTRUCTION (85, prompt, "prompt", 4, 2, 0) SYNC_REGISTER (); /* Push the prompt onto the dynamic stack. */ - prompt = scm_c_make_prompt (k, fp, sp, ip + offset, escape_only_p, vm_cookie, - scm_i_dynwinds ()); - scm_i_set_dynwinds (scm_cons (prompt, SCM_PROMPT_DYNWINDS (prompt))); - if (SCM_PROMPT_SETJMP (prompt)) - { - /* The prompt exited nonlocally. Cache the regs back from the vp, and go - to the handler. - - Note, at this point, we must assume that any variable local to - vm_engine that can be assigned *has* been assigned. So we need to pull - all our state back from the ip/fp/sp. - */ - CACHE_REGISTER (); - program = SCM_FRAME_PROGRAM (fp); - CACHE_PROGRAM (); - /* The stack contains the values returned to this prompt, along - with a number-of-values marker -- like an MV return. */ - ABORT_CONTINUATION_HOOK (); - NEXT; - } - - /* Otherwise setjmp returned for the first time, so we go to execute the - prompt's body. */ + flags = escape_only_p ? SCM_F_DYNSTACK_PROMPT_ESCAPE_ONLY : 0; + scm_dynstack_push_prompt (¤t_thread->dynstack, flags, k, + fp, sp, ip + offset, ®isters); NEXT; } -VM_DEFINE_INSTRUCTION (86, wind, "wind", 0, 2, 0) +VM_DEFINE_INSTRUCTION (88, wind, "wind", 0, 2, 0) { SCM wind, unwind; POP2 (unwind, wind); SYNC_REGISTER (); /* Push wind and unwind procedures onto the dynamic stack. Note that neither are actually called; the compiler should emit calls to wind and unwind for - the normal dynamic-wind control flow. */ - VM_ASSERT (scm_to_bool (scm_thunk_p (wind)), - vm_error_not_a_thunk ("dynamic-wind", wind)); - VM_ASSERT (scm_to_bool (scm_thunk_p (unwind)), - vm_error_not_a_thunk ("dynamic-wind", unwind)); - scm_i_set_dynwinds (scm_cons (scm_cons (wind, unwind), scm_i_dynwinds ())); + the normal dynamic-wind control flow. Also note that the compiler + should have inserted checks that they wind and unwind procs are + thunks, if it could not prove that to be the case. */ + scm_dynstack_push_dynwind (¤t_thread->dynstack, wind, unwind); NEXT; } -VM_DEFINE_INSTRUCTION (87, abort, "abort", 1, -1, -1) +VM_DEFINE_INSTRUCTION (89, abort, "abort", 1, -1, -1) { unsigned n = FETCH (); SYNC_REGISTER (); PRE_CHECK_UNDERFLOW (n + 2); - vm_abort (vm, n, vm_cookie); + vm_abort (vm, n, ®isters); /* vm_abort should not return */ abort (); } -VM_DEFINE_INSTRUCTION (88, unwind, "unwind", 0, 0, 0) +VM_DEFINE_INSTRUCTION (90, unwind, "unwind", 0, 0, 0) { /* A normal exit from the dynamic extent of an expression. Pop the top entry off of the dynamic stack. */ - scm_i_set_dynwinds (scm_cdr (scm_i_dynwinds ())); + scm_dynstack_pop (¤t_thread->dynstack); NEXT; } -VM_DEFINE_INSTRUCTION (89, wind_fluids, "wind-fluids", 1, -1, 0) +VM_DEFINE_INSTRUCTION (91, wind_fluids, "wind-fluids", 1, -1, 0) { unsigned n = FETCH (); - SCM wf; SYNC_REGISTER (); sp -= 2 * n; CHECK_UNDERFLOW (); - wf = scm_i_make_with_fluids (n, sp + 1, sp + 1 + n); + scm_dynstack_push_fluids (¤t_thread->dynstack, n, sp + 1, sp + 1 + n, + current_thread->dynamic_state); NULLSTACK (2 * n); - - scm_i_swap_with_fluids (wf, current_thread->dynamic_state); - scm_i_set_dynwinds (scm_cons (wf, scm_i_dynwinds ())); NEXT; } -VM_DEFINE_INSTRUCTION (90, unwind_fluids, "unwind-fluids", 0, 0, 0) +VM_DEFINE_INSTRUCTION (92, unwind_fluids, "unwind-fluids", 0, 0, 0) { - SCM wf; - wf = scm_car (scm_i_dynwinds ()); - scm_i_set_dynwinds (scm_cdr (scm_i_dynwinds ())); - scm_i_swap_with_fluids (wf, current_thread->dynamic_state); + /* This function must not allocate. */ + scm_dynstack_unwind_fluids (¤t_thread->dynstack, + current_thread->dynamic_state); NEXT; } -VM_DEFINE_INSTRUCTION (91, fluid_ref, "fluid-ref", 0, 1, 1) +VM_DEFINE_INSTRUCTION (93, fluid_ref, "fluid-ref", 0, 1, 1) { size_t num; SCM fluids; @@ -1592,7 +1533,7 @@ VM_DEFINE_INSTRUCTION (91, fluid_ref, "fluid-ref", 0, 1, 1) NEXT; } -VM_DEFINE_INSTRUCTION (92, fluid_set, "fluid-set", 0, 2, 0) +VM_DEFINE_INSTRUCTION (94, fluid_set, "fluid-set", 0, 2, 0) { size_t num; SCM val, fluid, fluids; @@ -1612,7 +1553,7 @@ VM_DEFINE_INSTRUCTION (92, fluid_set, "fluid-set", 0, 2, 0) NEXT; } -VM_DEFINE_INSTRUCTION (93, assert_nargs_ee_locals, "assert-nargs-ee/locals", 1, 0, 0) +VM_DEFINE_INSTRUCTION (95, assert_nargs_ee_locals, "assert-nargs-ee/locals", 1, 0, 0) { scm_t_ptrdiff n; SCM *old_sp; @@ -1634,7 +1575,7 @@ VM_DEFINE_INSTRUCTION (93, assert_nargs_ee_locals, "assert-nargs-ee/locals", 1, /* Like bind-optionals/shuffle, but if there are too many positional arguments, jumps to the next case-lambda clause. */ -VM_DEFINE_INSTRUCTION (94, bind_optionals_shuffle_or_br, "bind-optionals/shuffle-or-br", 9, -1, -1) +VM_DEFINE_INSTRUCTION (96, bind_optionals_shuffle_or_br, "bind-optionals/shuffle-or-br", 9, -1, -1) { SCM *walk; scm_t_ptrdiff nreq, nreq_and_opt, ntotal; diff --git a/libguile/vm.c b/libguile/vm.c index 5dec106a5..c26447028 100644 --- a/libguile/vm.c +++ b/libguile/vm.c @@ -83,9 +83,9 @@ static SCM sym_debug; void scm_i_vm_cont_print (SCM x, SCM port, scm_print_state *pstate) { - scm_puts ("#<vm-continuation ", port); + scm_puts_unlocked ("#<vm-continuation ", port); scm_uintprint (SCM_UNPACK (x), 16, port); - scm_puts (">", port); + scm_puts_unlocked (">", port); } /* In theory, a number of vm instances can be active in the call trace, and we @@ -101,7 +101,8 @@ scm_i_vm_cont_print (SCM x, SCM port, scm_print_state *pstate) */ SCM scm_i_vm_capture_stack (SCM *stack_base, SCM *fp, SCM *sp, scm_t_uint8 *ra, - scm_t_uint8 *mvra, scm_t_uint32 flags) + scm_t_uint8 *mvra, scm_t_dynstack *dynstack, + scm_t_uint32 flags) { struct scm_vm_cont *p; @@ -124,6 +125,7 @@ scm_i_vm_capture_stack (SCM *stack_base, SCM *fp, SCM *sp, scm_t_uint8 *ra, p->fp = fp; memcpy (p->stack_base, stack_base, (sp + 1 - stack_base) * sizeof (SCM)); p->reloc = p->stack_base - stack_base; + p->dynstack = dynstack; p->flags = flags; return scm_cell (scm_tc7_vm_cont, (scm_t_bits)p); } @@ -183,10 +185,19 @@ vm_return_to_continuation (SCM vm, SCM cont, size_t n, SCM *argv) } SCM -scm_i_vm_capture_continuation (SCM vm) +scm_i_capture_current_stack (void) { - struct scm_vm *vp = SCM_VM_DATA (vm); - return scm_i_vm_capture_stack (vp->stack_base, vp->fp, vp->sp, vp->ip, NULL, 0); + scm_i_thread *thread; + SCM vm; + struct scm_vm *vp; + + thread = SCM_I_CURRENT_THREAD; + vm = scm_the_vm (); + vp = SCM_VM_DATA (vm); + + return scm_i_vm_capture_stack (vp->stack_base, vp->fp, vp->sp, vp->ip, NULL, + scm_dynstack_capture_all (&thread->dynstack), + 0); } static void @@ -228,17 +239,19 @@ vm_dispatch_hook (SCM vm, int hook_num) frame = (scm_t_cell *) ROUND_UP ((scm_t_uintptr) frame, 8UL); frame->word_0 = SCM_PACK (scm_tc7_frame); - frame->word_1 = PTR2SCM (&c_frame); - args[0] = PTR2SCM (frame); + frame->word_1 = SCM_PACK_POINTER (&c_frame); + args[0] = SCM_PACK_POINTER (frame); scm_c_run_hookn (hook, args, 1); vp->trace_level = saved_trace_level; } -static void vm_abort (SCM vm, size_t n, scm_t_int64 cookie) SCM_NORETURN; static void -vm_abort (SCM vm, size_t n, scm_t_int64 vm_cookie) +vm_abort (SCM vm, size_t n, scm_i_jmp_buf *current_registers) SCM_NORETURN; + +static void +vm_abort (SCM vm, size_t n, scm_i_jmp_buf *current_registers) { size_t i; ssize_t tail_len; @@ -261,16 +274,18 @@ vm_abort (SCM vm, size_t n, scm_t_int64 vm_cookie) /* NULLSTACK (n + 1) */ SCM_VM_DATA (vm)->sp -= n + 1; - scm_c_abort (vm, tag, n + tail_len, argv, vm_cookie); + scm_c_abort (vm, tag, n + tail_len, argv, current_registers); } static void -vm_reinstate_partial_continuation (SCM vm, SCM cont, SCM intwinds, - size_t n, SCM *argv, scm_t_int64 vm_cookie) +vm_reinstate_partial_continuation (SCM vm, SCM cont, size_t n, SCM *argv, + scm_t_dynstack *dynstack, + scm_i_jmp_buf *registers) { struct scm_vm *vp; struct scm_vm_cont *cp; SCM *argv_copy, *base; + scm_t_ptrdiff reloc; size_t i; argv_copy = alloca (n * sizeof(SCM)); @@ -279,9 +294,10 @@ vm_reinstate_partial_continuation (SCM vm, SCM cont, SCM intwinds, vp = SCM_VM_DATA (vm); cp = SCM_VM_CONT_DATA (cont); base = SCM_FRAME_UPPER_ADDRESS (vp->fp) + 1; + reloc = cp->reloc + (base - cp->stack_base); #define RELOC(scm_p) \ - (((SCM *) (scm_p)) + cp->reloc + (base - cp->stack_base)) + (((SCM *) (scm_p)) + reloc) if ((base - vp->stack_base) + cp->stack_size + n + 1 > vp->stack_size) scm_misc_error ("vm-engine", @@ -312,30 +328,23 @@ vm_reinstate_partial_continuation (SCM vm, SCM cont, SCM intwinds, vp->sp++; *vp->sp = scm_from_size_t (n); - /* Finally, rewind the dynamic state. - - We have to treat prompts specially, because we could be rewinding the - dynamic state from a different thread, or just a different position on the - C and/or VM stack -- so we need to reset the jump buffers so that an abort - comes back here, with appropriately adjusted sp and fp registers. */ + /* The prompt captured a slice of the dynamic stack. Here we wind + those entries onto the current thread's stack. We also have to + relocate any prompts that we see along the way. */ { - long delta = 0; - SCM newwinds = scm_i_dynwinds (); - for (; scm_is_pair (intwinds); intwinds = scm_cdr (intwinds), delta--) + scm_t_bits *walk; + + for (walk = SCM_DYNSTACK_FIRST (cp->dynstack); + SCM_DYNSTACK_TAG (walk); + walk = SCM_DYNSTACK_NEXT (walk)) { - SCM x = scm_car (intwinds); - if (SCM_PROMPT_P (x)) - /* the jmpbuf will be reset by our caller */ - x = scm_c_make_prompt (SCM_PROMPT_TAG (x), - RELOC (SCM_PROMPT_REGISTERS (x)->fp), - RELOC (SCM_PROMPT_REGISTERS (x)->sp), - SCM_PROMPT_REGISTERS (x)->ip, - SCM_PROMPT_ESCAPE_P (x), - vm_cookie, - newwinds); - newwinds = scm_cons (x, newwinds); + scm_t_bits tag = SCM_DYNSTACK_TAG (walk); + + if (SCM_DYNSTACK_TAG_TYPE (tag) == SCM_DYNSTACK_TYPE_PROMPT) + scm_dynstack_wind_prompt (dynstack, walk, reloc, registers); + else + scm_dynstack_wind_1 (dynstack, walk); } - scm_dowinds (newwinds, delta); } #undef RELOC } @@ -352,22 +361,22 @@ scm_i_vm_print (SCM x, SCM port, scm_print_state *pstate) vm = SCM_VM_DATA (x); - scm_puts ("#<vm ", port); + scm_puts_unlocked ("#<vm ", port); switch (vm->engine) { case SCM_VM_REGULAR_ENGINE: - scm_puts ("regular-engine ", port); + scm_puts_unlocked ("regular-engine ", port); break; case SCM_VM_DEBUG_ENGINE: - scm_puts ("debug-engine ", port); + scm_puts_unlocked ("debug-engine ", port); break; default: - scm_puts ("unknown-engine ", port); + scm_puts_unlocked ("unknown-engine ", port); } scm_uintprint (SCM_UNPACK (x), 16, port); - scm_puts (">", port); + scm_puts_unlocked (">", port); } @@ -376,36 +385,35 @@ scm_i_vm_print (SCM x, SCM port, scm_print_state *pstate) */ static void vm_error (const char *msg, SCM arg) SCM_NORETURN; -static void vm_error_bad_instruction (scm_t_uint32 inst) SCM_NORETURN; -static void vm_error_unbound (SCM proc, SCM sym) SCM_NORETURN; -static void vm_error_unbound_fluid (SCM proc, SCM fluid) SCM_NORETURN; -static void vm_error_not_a_variable (const char *func_name, SCM x) SCM_NORETURN; -static void vm_error_not_a_thunk (const char *func_name, SCM x) SCM_NORETURN; -static void vm_error_apply_to_non_list (SCM x) SCM_NORETURN; -static void vm_error_kwargs_length_not_even (SCM proc) SCM_NORETURN; -static void vm_error_kwargs_invalid_keyword (SCM proc) SCM_NORETURN; -static void vm_error_kwargs_unrecognized_keyword (SCM proc) SCM_NORETURN; -static void vm_error_too_many_args (int nargs) SCM_NORETURN; -static void vm_error_wrong_num_args (SCM proc) SCM_NORETURN; -static void vm_error_wrong_type_apply (SCM proc) SCM_NORETURN; -static void vm_error_stack_overflow (struct scm_vm *vp) SCM_NORETURN; -static void vm_error_stack_underflow (void) SCM_NORETURN; -static void vm_error_improper_list (SCM x) SCM_NORETURN; -static void vm_error_not_a_pair (const char *subr, SCM x) SCM_NORETURN; -static void vm_error_not_a_bytevector (const char *subr, SCM x) SCM_NORETURN; -static void vm_error_not_a_struct (const char *subr, SCM x) SCM_NORETURN; -static void vm_error_no_values (void) SCM_NORETURN; -static void vm_error_not_enough_values (void) SCM_NORETURN; -static void vm_error_continuation_not_rewindable (SCM cont) SCM_NORETURN; -static void vm_error_bad_wide_string_length (size_t len) SCM_NORETURN; +static void vm_error_bad_instruction (scm_t_uint32 inst) SCM_NORETURN SCM_NOINLINE; +static void vm_error_unbound (SCM proc, SCM sym) SCM_NORETURN SCM_NOINLINE; +static void vm_error_unbound_fluid (SCM proc, SCM fluid) SCM_NORETURN SCM_NOINLINE; +static void vm_error_not_a_variable (const char *func_name, SCM x) SCM_NORETURN SCM_NOINLINE; +static void vm_error_apply_to_non_list (SCM x) SCM_NORETURN SCM_NOINLINE; +static void vm_error_kwargs_length_not_even (SCM proc) SCM_NORETURN SCM_NOINLINE; +static void vm_error_kwargs_invalid_keyword (SCM proc) SCM_NORETURN SCM_NOINLINE; +static void vm_error_kwargs_unrecognized_keyword (SCM proc) SCM_NORETURN SCM_NOINLINE; +static void vm_error_too_many_args (int nargs) SCM_NORETURN SCM_NOINLINE; +static void vm_error_wrong_num_args (SCM proc) SCM_NORETURN SCM_NOINLINE; +static void vm_error_wrong_type_apply (SCM proc) SCM_NORETURN SCM_NOINLINE; +static void vm_error_stack_overflow (struct scm_vm *vp) SCM_NORETURN SCM_NOINLINE; +static void vm_error_stack_underflow (void) SCM_NORETURN SCM_NOINLINE; +static void vm_error_improper_list (SCM x) SCM_NORETURN SCM_NOINLINE; +static void vm_error_not_a_pair (const char *subr, SCM x) SCM_NORETURN SCM_NOINLINE; +static void vm_error_not_a_bytevector (const char *subr, SCM x) SCM_NORETURN SCM_NOINLINE; +static void vm_error_not_a_struct (const char *subr, SCM x) SCM_NORETURN SCM_NOINLINE; +static void vm_error_no_values (void) SCM_NORETURN SCM_NOINLINE; +static void vm_error_not_enough_values (void) SCM_NORETURN SCM_NOINLINE; +static void vm_error_continuation_not_rewindable (SCM cont) SCM_NORETURN SCM_NOINLINE; +static void vm_error_bad_wide_string_length (size_t len) SCM_NORETURN SCM_NOINLINE; #if VM_CHECK_IP -static void vm_error_invalid_address (void) SCM_NORETURN; +static void vm_error_invalid_address (void) SCM_NORETURN SCM_NOINLINE; #endif #if VM_CHECK_OBJECT -static void vm_error_object (void) SCM_NORETURN; +static void vm_error_object (void) SCM_NORETURN SCM_NOINLINE; #endif #if VM_CHECK_FREE_VARIABLES -static void vm_error_free_variable (void) SCM_NORETURN; +static void vm_error_free_variable (void) SCM_NORETURN SCM_NOINLINE; #endif static void @@ -447,13 +455,6 @@ vm_error_not_a_variable (const char *func_name, SCM x) } static void -vm_error_not_a_thunk (const char *func_name, SCM x) -{ - scm_error (scm_arg_type_key, func_name, "Not a thunk: ~S", - scm_list_1 (x), scm_list_1 (x)); -} - -static void vm_error_apply_to_non_list (SCM x) { scm_error (scm_arg_type_key, "apply", "Apply to non-list: ~S", @@ -678,7 +679,7 @@ make_vm (void) /* Keep a pointer to VP so that `vm_stack_mark ()' can know what the stack top is. */ - *vp->stack_base = PTR2SCM (vp); + *vp->stack_base = SCM_PACK_POINTER (vp); vp->stack_base++; vp->stack_size--; #else @@ -697,7 +698,6 @@ make_vm (void) vp->trace_level = 0; for (i = 0; i < SCM_VM_NUM_HOOKS; i++) vp->hooks[i] = SCM_BOOL_F; - vp->cookie = 0; return scm_cell (scm_tc7_vm, (scm_t_bits)vp); } #undef FUNC_NAME @@ -1046,9 +1046,8 @@ SCM_DEFINE (scm_call_with_vm, "call-with-vm", 2, 0, 1, SCM scm_load_compiled_with_vm (SCM file) { - SCM program = scm_make_program (scm_load_objcode (file), - SCM_BOOL_F, SCM_BOOL_F); - + SCM program = scm_load_thunk_from_file (file); + return scm_c_vm_run (scm_the_vm (), program, NULL, 0); } @@ -1059,8 +1058,8 @@ make_boot_program (void) struct scm_objcode *bp; size_t bp_size; SCM u8vec, ret; - - const scm_t_uint8 text[] = { + + const scm_t_uint8 text[] = { scm_op_make_int8_1, scm_op_halt }; @@ -1071,8 +1070,8 @@ make_boot_program (void) bp->len = sizeof(text); bp->metalen = 0; - u8vec = scm_c_take_gc_bytevector ((scm_t_int8*)bp, bp_size); - ret = scm_make_program (scm_bytecode_to_native_objcode (u8vec), + u8vec = scm_c_take_gc_bytevector ((scm_t_int8*)bp, bp_size, SCM_BOOL_F); + ret = scm_make_program (scm_bytecode_to_objcode (u8vec, SCM_UNDEFINED), SCM_BOOL_F, SCM_BOOL_F); SCM_SET_CELL_WORD_0 (ret, (SCM_CELL_WORD_0 (ret) | SCM_F_PROGRAM_IS_BOOT)); diff --git a/libguile/vm.h b/libguile/vm.h index d354a53c0..c45d17f10 100644 --- a/libguile/vm.h +++ b/libguile/vm.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2001, 2009, 2010, 2011 Free Software Foundation, Inc. +/* Copyright (C) 2001, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -50,12 +50,11 @@ struct scm_vm { int engine; /* which vm engine we're using */ SCM hooks[SCM_VM_NUM_HOOKS]; /* hooks */ int trace_level; /* traces enabled if trace_level > 0 */ - scm_t_int64 cookie; /* used to detect unrewindable continuations */ }; SCM_API SCM scm_the_vm_fluid; -#define SCM_VM_P(x) (SCM_NIMP (x) && SCM_TYP7 (x) == scm_tc7_vm) +#define SCM_VM_P(x) (SCM_HAS_TYP7 (x, scm_tc7_vm)) #define SCM_VM_DATA(vm) ((struct scm_vm *) SCM_CELL_WORD_1 (vm)) #define SCM_VALIDATE_VM(pos,x) SCM_MAKE_VALIDATE (pos, x, VM_P) @@ -93,10 +92,11 @@ struct scm_vm_cont { scm_t_ptrdiff stack_size; SCM *stack_base; scm_t_ptrdiff reloc; + scm_t_dynstack *dynstack; scm_t_uint32 flags; }; -#define SCM_VM_CONT_P(OBJ) (SCM_NIMP (OBJ) && SCM_TYP7 (OBJ) == scm_tc7_vm_cont) +#define SCM_VM_CONT_P(OBJ) (SCM_HAS_TYP7 (OBJ, scm_tc7_vm_cont)) #define SCM_VM_CONT_DATA(CONT) ((struct scm_vm_cont *) SCM_CELL_WORD_1 (CONT)) #define SCM_VM_CONT_PARTIAL_P(CONT) (SCM_VM_CONT_DATA (CONT)->flags & SCM_F_VM_CONT_PARTIAL) #define SCM_VM_CONT_REWINDABLE_P(CONT) (SCM_VM_CONT_DATA (CONT)->flags & SCM_F_VM_CONT_REWINDABLE) @@ -107,9 +107,10 @@ SCM_INTERNAL SCM scm_c_vm_run (SCM vm, SCM program, SCM *argv, int nargs); SCM_INTERNAL void scm_i_vm_print (SCM x, SCM port, scm_print_state *pstate); -SCM_INTERNAL SCM scm_i_vm_capture_continuation (SCM vm); +SCM_INTERNAL SCM scm_i_capture_current_stack (void); SCM_INTERNAL SCM scm_i_vm_capture_stack (SCM *stack_base, SCM *fp, SCM *sp, scm_t_uint8 *ra, scm_t_uint8 *mvra, + scm_t_dynstack *dynstack, scm_t_uint32 flags); SCM_INTERNAL void scm_i_vm_cont_print (SCM x, SCM port, scm_print_state *pstate); diff --git a/libguile/vports.c b/libguile/vports.c index 75e7df303..a886e362e 100644 --- a/libguile/vports.c +++ b/libguile/vports.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995,1996,1998,1999,2000,2001, 2002, 2003, 2006, 2009, 2010 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1998,1999,2000,2001, 2002, 2003, 2006, 2009, 2010, 2011, 2013 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -94,7 +94,7 @@ sf_fill_input (SCM port) SCM_ASSERT (SCM_CHARP (ans), ans, SCM_ARG1, "sf_fill_input"); pt = SCM_PTAB_ENTRY (port); - if (pt->encoding == NULL) + if (pt->encoding_mode == SCM_PORT_ENCODING_MODE_LATIN1) { scm_t_port *pt = SCM_PTAB_ENTRY (port); @@ -104,7 +104,7 @@ sf_fill_input (SCM port) return *pt->read_buf; } else - scm_ungetc (SCM_CHAR (ans), port); + scm_ungetc_unlocked (SCM_CHAR (ans), port); return SCM_CHAR (ans); } @@ -188,7 +188,6 @@ SCM_DEFINE (scm_make_soft_port, "make-soft-port", 2, 0, 0, #define FUNC_NAME s_scm_make_soft_port { int vlen; - scm_t_port *pt; SCM z; SCM_VALIDATE_VECTOR (1, pv); @@ -196,14 +195,10 @@ SCM_DEFINE (scm_make_soft_port, "make-soft-port", 2, 0, 0, SCM_ASSERT ((vlen == 5) || (vlen == 6), pv, 1, FUNC_NAME); SCM_VALIDATE_STRING (2, modes); - scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex); - z = scm_new_port_table_entry (scm_tc16_sfport); - pt = SCM_PTAB_ENTRY (z); - scm_port_non_buffer (pt); - SCM_SET_CELL_TYPE (z, scm_tc16_sfport | scm_i_mode_bits (modes)); - - SCM_SETSTREAM (z, SCM_UNPACK (pv)); - scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex); + z = scm_c_make_port (scm_tc16_sfport, scm_i_mode_bits (modes), + SCM_UNPACK (pv)); + scm_port_non_buffer (SCM_PTAB_ENTRY (z)); + return z; } #undef FUNC_NAME diff --git a/libguile/weak-set.c b/libguile/weak-set.c new file mode 100644 index 000000000..e8523ba62 --- /dev/null +++ b/libguile/weak-set.c @@ -0,0 +1,892 @@ +/* Copyright (C) 2011, 2012, 2013 Free Software Foundation, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 3 of + * the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + + + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#include <assert.h> + +#include "libguile/_scm.h" +#include "libguile/hash.h" +#include "libguile/eval.h" +#include "libguile/ports.h" +#include "libguile/bdw-gc.h" + +#include "libguile/validate.h" +#include "libguile/weak-set.h" + + +/* Weak Sets + + This file implements weak sets. One example of a weak set is the + symbol table, where you want all instances of the `foo' symbol to map + to one object. So when you load a file and it wants a symbol with + the characters "foo", you one up in the table, using custom hash and + equality predicates. Only if one is not found will you bother to + cons one up and intern it. + + Another use case for weak sets is the set of open ports. Guile needs + to be able to flush them all when the process exits, but the set + shouldn't prevent the GC from collecting the port (and thus closing + it). + + Weak sets are implemented using an open-addressed hash table. + Basically this means that there is an array of entries, and the item + is expected to be found the slot corresponding to its hash code, + modulo the length of the array. + + Collisions are handled using linear probing with the Robin Hood + technique. See Pedro Celis' paper, "Robin Hood Hashing": + + http://www.cs.uwaterloo.ca/research/tr/1986/CS-86-14.pdf + + The vector of entries is allocated as an "atomic" piece of memory, so + that the GC doesn't trace it. When an item is added to the set, a + disappearing link is registered to its location. If the item is + collected, then that link will be zeroed out. + + An entry is not just an item, though; the hash code is also stored in + the entry. We munge hash codes so that they are never 0. In this + way we can detect removed entries (key of zero but nonzero hash + code), and can then reshuffle elements as needed to maintain the + robin hood ordering. + + Compared to buckets-and-chains hash tables, open addressing has the + advantage that it is very cache-friendly. It also uses less memory. + + Implementation-wise, there are two things to note. + + 1. We assume that hash codes are evenly distributed across the + range of unsigned longs. The actual hash code stored in the + entry is left-shifted by 1 bit (losing 1 bit of hash precision), + and then or'd with 1. In this way we ensure that the hash field + of an occupied entry is nonzero. To map to an index, we + right-shift the hash by one, divide by the size, and take the + remainder. + + 2. Since the "keys" (the objects in the set) are stored in an + atomic region with disappearing links, they need to be accessed + with the GC alloc lock. `copy_weak_entry' will do that for + you. The hash code itself can be read outside the lock, + though. +*/ + + +typedef struct { + unsigned long hash; + scm_t_bits key; +} scm_t_weak_entry; + + +struct weak_entry_data { + scm_t_weak_entry *in; + scm_t_weak_entry *out; +}; + +static void* +do_copy_weak_entry (void *data) +{ + struct weak_entry_data *e = data; + + e->out->hash = e->in->hash; + e->out->key = e->in->key; + + return NULL; +} + +static void +copy_weak_entry (scm_t_weak_entry *src, scm_t_weak_entry *dst) +{ + struct weak_entry_data data; + + data.in = src; + data.out = dst; + + GC_call_with_alloc_lock (do_copy_weak_entry, &data); +} + + +typedef struct { + scm_t_weak_entry *entries; /* the data */ + scm_i_pthread_mutex_t lock; /* the lock */ + unsigned long size; /* total number of slots. */ + unsigned long n_items; /* number of items in set */ + unsigned long lower; /* when to shrink */ + unsigned long upper; /* when to grow */ + int size_index; /* index into hashset_size */ + int min_size_index; /* minimum size_index */ +} scm_t_weak_set; + + +#define SCM_WEAK_SET_P(x) (SCM_HAS_TYP7 (x, scm_tc7_weak_set)) +#define SCM_VALIDATE_WEAK_SET(pos, arg) \ + SCM_MAKE_VALIDATE_MSG (pos, arg, WEAK_SET_P, "weak-set") +#define SCM_WEAK_SET(x) ((scm_t_weak_set *) SCM_CELL_WORD_1 (x)) + + +static unsigned long +hash_to_index (unsigned long hash, unsigned long size) +{ + return (hash >> 1) % size; +} + +static unsigned long +entry_distance (unsigned long hash, unsigned long k, unsigned long size) +{ + unsigned long origin = hash_to_index (hash, size); + + if (k >= origin) + return k - origin; + else + /* The other key was displaced and wrapped around. */ + return size - origin + k; +} + +#ifndef HAVE_GC_MOVE_DISAPPEARING_LINK +static void +GC_move_disappearing_link (void **from, void **to) +{ + GC_unregister_disappearing_link (from); + SCM_I_REGISTER_DISAPPEARING_LINK (to, *to); +} +#endif + +static void +move_weak_entry (scm_t_weak_entry *from, scm_t_weak_entry *to) +{ + if (from->hash) + { + scm_t_weak_entry copy; + + copy_weak_entry (from, ©); + to->hash = copy.hash; + to->key = copy.key; + + if (copy.key && SCM_HEAP_OBJECT_P (SCM_PACK (copy.key))) + GC_move_disappearing_link ((void **) &from->key, (void **) &to->key); + } + else + { + to->hash = 0; + to->key = 0; + } +} + +static void +rob_from_rich (scm_t_weak_set *set, unsigned long k) +{ + unsigned long empty, size; + + size = set->size; + + /* If we are to free up slot K in the set, we need room to do so. */ + assert (set->n_items < size); + + empty = k; + do + empty = (empty + 1) % size; + /* Here we access key outside the lock. Is this a problem? At first + glance, I wouldn't think so. */ + while (set->entries[empty].key); + + do + { + unsigned long last = empty ? (empty - 1) : (size - 1); + move_weak_entry (&set->entries[last], &set->entries[empty]); + empty = last; + } + while (empty != k); + + /* Just for sanity. */ + set->entries[empty].hash = 0; + set->entries[empty].key = 0; +} + +static void +give_to_poor (scm_t_weak_set *set, unsigned long k) +{ + /* Slot K was just freed up; possibly shuffle others down. */ + unsigned long size = set->size; + + while (1) + { + unsigned long next = (k + 1) % size; + unsigned long hash; + scm_t_weak_entry copy; + + hash = set->entries[next].hash; + + if (!hash || hash_to_index (hash, size) == next) + break; + + copy_weak_entry (&set->entries[next], ©); + + if (!copy.key) + /* Lost weak reference. */ + { + give_to_poor (set, next); + set->n_items--; + continue; + } + + move_weak_entry (&set->entries[next], &set->entries[k]); + + k = next; + } + + /* We have shuffled down any entries that should be shuffled down; now + free the end. */ + set->entries[k].hash = 0; + set->entries[k].key = 0; +} + + + + +/* Growing or shrinking is triggered when the load factor + * + * L = N / S (N: number of items in set, S: bucket vector length) + * + * passes an upper limit of 0.9 or a lower limit of 0.2. + * + * The implementation stores the upper and lower number of items which + * trigger a resize in the hashset object. + * + * Possible hash set sizes (primes) are stored in the array + * hashset_size. + */ + +static unsigned long hashset_size[] = { + 31, 61, 113, 223, 443, 883, 1759, 3517, 7027, 14051, 28099, 56197, 112363, + 224717, 449419, 898823, 1797641, 3595271, 7190537, 14381041, 28762081, + 57524111, 115048217, 230096423 +}; + +#define HASHSET_SIZE_N (sizeof(hashset_size)/sizeof(unsigned long)) + +static int +compute_size_index (scm_t_weak_set *set) +{ + int i = set->size_index; + + if (set->n_items < set->lower) + { + /* rehashing is not triggered when i <= min_size */ + do + --i; + while (i > set->min_size_index + && set->n_items < hashset_size[i] / 5); + } + else if (set->n_items > set->upper) + { + ++i; + if (i >= HASHSET_SIZE_N) + /* The biggest size currently is 230096423, which for a 32-bit + machine will occupy 1.5GB of memory at a load of 80%. There + is probably something better to do here, but if you have a + weak map of that size, you are hosed in any case. */ + abort (); + } + + return i; +} + +static int +is_acceptable_size_index (scm_t_weak_set *set, int size_index) +{ + int computed = compute_size_index (set); + + if (size_index == computed) + /* We were going to grow or shrink, and allocating the new vector + didn't change the target size. */ + return 1; + + if (size_index == computed + 1) + { + /* We were going to enlarge the set, but allocating the new + vector finalized some objects, making an enlargement + unnecessary. It might still be a good idea to use the larger + set, though. (This branch also gets hit if, while allocating + the vector, some other thread was actively removing items from + the set. That is less likely, though.) */ + unsigned long new_lower = hashset_size[size_index] / 5; + + return set->size > new_lower; + } + + if (size_index == computed - 1) + { + /* We were going to shrink the set, but when we dropped the lock + to allocate the new vector, some other thread added elements to + the set. */ + return 0; + } + + /* The computed size differs from our newly allocated size by more + than one size index -- recalculate. */ + return 0; +} + +static void +resize_set (scm_t_weak_set *set) +{ + scm_t_weak_entry *old_entries, *new_entries; + int new_size_index; + unsigned long old_size, new_size, old_k; + + do + { + new_size_index = compute_size_index (set); + if (new_size_index == set->size_index) + return; + new_size = hashset_size[new_size_index]; + new_entries = scm_gc_malloc_pointerless (new_size * sizeof(scm_t_weak_entry), + "weak set"); + } + while (!is_acceptable_size_index (set, new_size_index)); + + old_entries = set->entries; + old_size = set->size; + + memset (new_entries, 0, new_size * sizeof(scm_t_weak_entry)); + + set->size_index = new_size_index; + set->size = new_size; + if (new_size_index <= set->min_size_index) + set->lower = 0; + else + set->lower = new_size / 5; + set->upper = 9 * new_size / 10; + set->n_items = 0; + set->entries = new_entries; + + for (old_k = 0; old_k < old_size; old_k++) + { + scm_t_weak_entry copy; + unsigned long new_k, distance; + + if (!old_entries[old_k].hash) + continue; + + copy_weak_entry (&old_entries[old_k], ©); + + if (!copy.key) + continue; + + new_k = hash_to_index (copy.hash, new_size); + + for (distance = 0; ; distance++, new_k = (new_k + 1) % new_size) + { + unsigned long other_hash = new_entries[new_k].hash; + + if (!other_hash) + /* Found an empty entry. */ + break; + + /* Displace the entry if our distance is less, otherwise keep + looking. */ + if (entry_distance (other_hash, new_k, new_size) < distance) + { + rob_from_rich (set, new_k); + break; + } + } + + set->n_items++; + new_entries[new_k].hash = copy.hash; + new_entries[new_k].key = copy.key; + + if (SCM_HEAP_OBJECT_P (SCM_PACK (copy.key))) + SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &new_entries[new_k].key, + (void *) new_entries[new_k].key); + } +} + +/* Run from a finalizer via do_vacuum_weak_set, this function runs over + the whole table, removing lost weak references, reshuffling the set + as it goes. It might resize the set if it reaps enough entries. */ +static void +vacuum_weak_set (scm_t_weak_set *set) +{ + scm_t_weak_entry *entries = set->entries; + unsigned long size = set->size; + unsigned long k; + + for (k = 0; k < size; k++) + { + unsigned long hash = entries[k].hash; + + if (hash) + { + scm_t_weak_entry copy; + + copy_weak_entry (&entries[k], ©); + + if (!copy.key) + /* Lost weak reference; reshuffle. */ + { + give_to_poor (set, k); + set->n_items--; + } + } + } + + if (set->n_items < set->lower) + resize_set (set); +} + + + + +static SCM +weak_set_lookup (scm_t_weak_set *set, unsigned long hash, + scm_t_set_predicate_fn pred, void *closure, + SCM dflt) +{ + unsigned long k, distance, size; + scm_t_weak_entry *entries; + + size = set->size; + entries = set->entries; + + hash = (hash << 1) | 0x1; + k = hash_to_index (hash, size); + + for (distance = 0; distance < size; distance++, k = (k + 1) % size) + { + unsigned long other_hash; + + retry: + other_hash = entries[k].hash; + + if (!other_hash) + /* Not found. */ + return dflt; + + if (hash == other_hash) + { + scm_t_weak_entry copy; + + copy_weak_entry (&entries[k], ©); + + if (!copy.key) + /* Lost weak reference; reshuffle. */ + { + give_to_poor (set, k); + set->n_items--; + goto retry; + } + + if (pred (SCM_PACK (copy.key), closure)) + /* Found. */ + return SCM_PACK (copy.key); + } + + /* If the entry's distance is less, our key is not in the set. */ + if (entry_distance (other_hash, k, size) < distance) + return dflt; + } + + /* If we got here, then we were unfortunate enough to loop through the + whole set. Shouldn't happen, but hey. */ + return dflt; +} + + +static SCM +weak_set_add_x (scm_t_weak_set *set, unsigned long hash, + scm_t_set_predicate_fn pred, void *closure, + SCM obj) +{ + unsigned long k, distance, size; + scm_t_weak_entry *entries; + + size = set->size; + entries = set->entries; + + hash = (hash << 1) | 0x1; + k = hash_to_index (hash, size); + + for (distance = 0; ; distance++, k = (k + 1) % size) + { + unsigned long other_hash; + + retry: + other_hash = entries[k].hash; + + if (!other_hash) + /* Found an empty entry. */ + break; + + if (other_hash == hash) + { + scm_t_weak_entry copy; + + copy_weak_entry (&entries[k], ©); + + if (!copy.key) + /* Lost weak reference; reshuffle. */ + { + give_to_poor (set, k); + set->n_items--; + goto retry; + } + + if (pred (SCM_PACK (copy.key), closure)) + /* Found an entry with this key. */ + return SCM_PACK (copy.key); + } + + if (set->n_items > set->upper) + /* Full set, time to resize. */ + { + resize_set (set); + return weak_set_add_x (set, hash >> 1, pred, closure, obj); + } + + /* Displace the entry if our distance is less, otherwise keep + looking. */ + if (entry_distance (other_hash, k, size) < distance) + { + rob_from_rich (set, k); + break; + } + } + + set->n_items++; + entries[k].hash = hash; + entries[k].key = SCM_UNPACK (obj); + + if (SCM_HEAP_OBJECT_P (obj)) + SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &entries[k].key, + (void *) SCM2PTR (obj)); + + return obj; +} + + +static void +weak_set_remove_x (scm_t_weak_set *set, unsigned long hash, + scm_t_set_predicate_fn pred, void *closure) +{ + unsigned long k, distance, size; + scm_t_weak_entry *entries; + + size = set->size; + entries = set->entries; + + hash = (hash << 1) | 0x1; + k = hash_to_index (hash, size); + + for (distance = 0; distance < size; distance++, k = (k + 1) % size) + { + unsigned long other_hash; + + retry: + other_hash = entries[k].hash; + + if (!other_hash) + /* Not found. */ + return; + + if (other_hash == hash) + { + scm_t_weak_entry copy; + + copy_weak_entry (&entries[k], ©); + + if (!copy.key) + /* Lost weak reference; reshuffle. */ + { + give_to_poor (set, k); + set->n_items--; + goto retry; + } + + if (pred (SCM_PACK (copy.key), closure)) + /* Found an entry with this key. */ + { + entries[k].hash = 0; + entries[k].key = 0; + + if (SCM_HEAP_OBJECT_P (SCM_PACK (copy.key))) + GC_unregister_disappearing_link ((void **) &entries[k].key); + + if (--set->n_items < set->lower) + resize_set (set); + else + give_to_poor (set, k); + + return; + } + } + + /* If the entry's distance is less, our key is not in the set. */ + if (entry_distance (other_hash, k, size) < distance) + return; + } +} + + + +static SCM +make_weak_set (unsigned long k) +{ + scm_t_weak_set *set; + + int i = 0, n = k ? k : 31; + while (i + 1 < HASHSET_SIZE_N && n > hashset_size[i]) + ++i; + n = hashset_size[i]; + + set = scm_gc_malloc (sizeof (*set), "weak-set"); + set->entries = scm_gc_malloc_pointerless (n * sizeof(scm_t_weak_entry), + "weak-set"); + memset (set->entries, 0, n * sizeof(scm_t_weak_entry)); + set->n_items = 0; + set->size = n; + set->lower = 0; + set->upper = 9 * n / 10; + set->size_index = i; + set->min_size_index = i; + scm_i_pthread_mutex_init (&set->lock, NULL); + + return scm_cell (scm_tc7_weak_set, (scm_t_bits)set); +} + +void +scm_i_weak_set_print (SCM exp, SCM port, scm_print_state *pstate) +{ + scm_puts_unlocked ("#<", port); + scm_puts_unlocked ("weak-set ", port); + scm_uintprint (SCM_WEAK_SET (exp)->n_items, 10, port); + scm_putc_unlocked ('/', port); + scm_uintprint (SCM_WEAK_SET (exp)->size, 10, port); + scm_puts_unlocked (">", port); +} + +static void +do_vacuum_weak_set (SCM set) +{ + scm_t_weak_set *s; + + s = SCM_WEAK_SET (set); + + /* We should always be able to grab this lock, because we are run from + a finalizer, which runs in another thread (or an async, which is + mostly equivalent). */ + scm_i_pthread_mutex_lock (&s->lock); + vacuum_weak_set (s); + scm_i_pthread_mutex_unlock (&s->lock); +} + +SCM +scm_c_make_weak_set (unsigned long k) +{ + SCM ret; + + ret = make_weak_set (k); + + scm_i_register_weak_gc_callback (ret, do_vacuum_weak_set); + + return ret; +} + +SCM +scm_weak_set_p (SCM obj) +{ + return scm_from_bool (SCM_WEAK_SET_P (obj)); +} + +SCM +scm_weak_set_clear_x (SCM set) +{ + scm_t_weak_set *s = SCM_WEAK_SET (set); + + scm_i_pthread_mutex_lock (&s->lock); + + memset (s->entries, 0, sizeof (scm_t_weak_entry) * s->size); + s->n_items = 0; + + scm_i_pthread_mutex_unlock (&s->lock); + + return SCM_UNSPECIFIED; +} + +SCM +scm_c_weak_set_lookup (SCM set, unsigned long raw_hash, + scm_t_set_predicate_fn pred, + void *closure, SCM dflt) +{ + SCM ret; + scm_t_weak_set *s = SCM_WEAK_SET (set); + + scm_i_pthread_mutex_lock (&s->lock); + + ret = weak_set_lookup (s, raw_hash, pred, closure, dflt); + + scm_i_pthread_mutex_unlock (&s->lock); + + return ret; +} + +SCM +scm_c_weak_set_add_x (SCM set, unsigned long raw_hash, + scm_t_set_predicate_fn pred, + void *closure, SCM obj) +{ + SCM ret; + scm_t_weak_set *s = SCM_WEAK_SET (set); + + scm_i_pthread_mutex_lock (&s->lock); + + ret = weak_set_add_x (s, raw_hash, pred, closure, obj); + + scm_i_pthread_mutex_unlock (&s->lock); + + return ret; +} + +void +scm_c_weak_set_remove_x (SCM set, unsigned long raw_hash, + scm_t_set_predicate_fn pred, + void *closure) +{ + scm_t_weak_set *s = SCM_WEAK_SET (set); + + scm_i_pthread_mutex_lock (&s->lock); + + weak_set_remove_x (s, raw_hash, pred, closure); + + scm_i_pthread_mutex_unlock (&s->lock); +} + +static int +eq_predicate (SCM x, void *closure) +{ + return scm_is_eq (x, SCM_PACK_POINTER (closure)); +} + +SCM +scm_weak_set_add_x (SCM set, SCM obj) +{ + return scm_c_weak_set_add_x (set, scm_ihashq (obj, -1), + eq_predicate, SCM_UNPACK_POINTER (obj), obj); +} + +SCM +scm_weak_set_remove_x (SCM set, SCM obj) +{ + scm_c_weak_set_remove_x (set, scm_ihashq (obj, -1), + eq_predicate, SCM_UNPACK_POINTER (obj)); + + return SCM_UNSPECIFIED; +} + +SCM +scm_c_weak_set_fold (scm_t_set_fold_fn proc, void *closure, + SCM init, SCM set) +{ + scm_t_weak_set *s; + scm_t_weak_entry *entries; + unsigned long k, size; + + s = SCM_WEAK_SET (set); + + scm_i_pthread_mutex_lock (&s->lock); + + size = s->size; + entries = s->entries; + + for (k = 0; k < size; k++) + { + if (entries[k].hash) + { + scm_t_weak_entry copy; + + copy_weak_entry (&entries[k], ©); + + if (copy.key) + { + /* Release set lock while we call the function. */ + scm_i_pthread_mutex_unlock (&s->lock); + init = proc (closure, SCM_PACK (copy.key), init); + scm_i_pthread_mutex_lock (&s->lock); + } + } + } + + scm_i_pthread_mutex_unlock (&s->lock); + + return init; +} + +static SCM +fold_trampoline (void *closure, SCM item, SCM init) +{ + return scm_call_2 (SCM_PACK_POINTER (closure), item, init); +} + +SCM +scm_weak_set_fold (SCM proc, SCM init, SCM set) +{ + return scm_c_weak_set_fold (fold_trampoline, SCM_UNPACK_POINTER (proc), init, set); +} + +static SCM +for_each_trampoline (void *closure, SCM item, SCM seed) +{ + scm_call_1 (SCM_PACK_POINTER (closure), item); + return seed; +} + +SCM +scm_weak_set_for_each (SCM proc, SCM set) +{ + scm_c_weak_set_fold (for_each_trampoline, SCM_UNPACK_POINTER (proc), SCM_BOOL_F, set); + + return SCM_UNSPECIFIED; +} + +static SCM +map_trampoline (void *closure, SCM item, SCM seed) +{ + return scm_cons (scm_call_1 (SCM_PACK_POINTER (closure), item), seed); +} + +SCM +scm_weak_set_map_to_list (SCM proc, SCM set) +{ + return scm_c_weak_set_fold (map_trampoline, SCM_UNPACK_POINTER (proc), SCM_EOL, set); +} + + +void +scm_init_weak_set () +{ +#include "libguile/weak-set.x" +} + +/* + Local Variables: + c-file-style: "gnu" + End: +*/ diff --git a/libguile/weak-set.h b/libguile/weak-set.h new file mode 100644 index 000000000..86781c78a --- /dev/null +++ b/libguile/weak-set.h @@ -0,0 +1,69 @@ +/* classes: h_files */ + +#ifndef SCM_WEAK_SET_H +#define SCM_WEAK_SET_H + +/* Copyright (C) 2011 Free Software Foundation, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 3 of + * the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + + + +#include "libguile/__scm.h" + + + +/* The weak set API is currently only used internally. We could make it + public later, after some API review. */ + +/* Function that returns nonzero if the given object is the one we are + looking for. */ +typedef int (*scm_t_set_predicate_fn) (SCM obj, void *closure); + +/* Function to fold over the elements of a set. */ +typedef SCM (*scm_t_set_fold_fn) (void *closure, SCM key, SCM result); + +SCM_INTERNAL SCM scm_c_make_weak_set (unsigned long k); +SCM_INTERNAL SCM scm_weak_set_p (SCM h); +SCM_INTERNAL SCM scm_c_weak_set_lookup (SCM set, unsigned long raw_hash, + scm_t_set_predicate_fn pred, + void *closure, SCM dflt); +SCM_INTERNAL SCM scm_c_weak_set_add_x (SCM set, unsigned long raw_hash, + scm_t_set_predicate_fn pred, + void *closure, SCM obj); +SCM_INTERNAL void scm_c_weak_set_remove_x (SCM set, unsigned long raw_hash, + scm_t_set_predicate_fn pred, + void *closure); +SCM_INTERNAL SCM scm_weak_set_add_x (SCM set, SCM obj); +SCM_INTERNAL SCM scm_weak_set_remove_x (SCM set, SCM obj); +SCM_INTERNAL SCM scm_weak_set_clear_x (SCM set); +SCM_INTERNAL SCM scm_c_weak_set_fold (scm_t_set_fold_fn proc, void *closure, + SCM init, SCM set); +SCM_INTERNAL SCM scm_weak_set_fold (SCM proc, SCM init, SCM set); +SCM_INTERNAL SCM scm_weak_set_for_each (SCM proc, SCM set); +SCM_INTERNAL SCM scm_weak_set_map_to_list (SCM proc, SCM set); + +SCM_INTERNAL void scm_i_weak_set_print (SCM exp, SCM port, scm_print_state *pstate); +SCM_INTERNAL void scm_init_weak_set (void); + +#endif /* SCM_WEAK_SET_H */ + +/* + Local Variables: + c-file-style: "gnu" + End: +*/ diff --git a/libguile/weak-table.c b/libguile/weak-table.c new file mode 100644 index 000000000..e91106988 --- /dev/null +++ b/libguile/weak-table.c @@ -0,0 +1,1157 @@ +/* Copyright (C) 2011, 2012, 2013 Free Software Foundation, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 3 of + * the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + + + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#include <assert.h> + +#include "libguile/bdw-gc.h" +#include <gc/gc_mark.h> + +#include "libguile/_scm.h" +#include "libguile/hash.h" +#include "libguile/eval.h" +#include "libguile/ports.h" + +#include "libguile/validate.h" +#include "libguile/weak-table.h" + + +/* Weak Tables + + This file implements weak hash tables. Weak hash tables are + generally used when you want to augment some object with additional + data, but when you don't have space to store the data in the object. + For example, procedure properties are implemented with weak tables. + + Weak tables are implemented using an open-addressed hash table. + Basically this means that there is an array of entries, and the item + is expected to be found the slot corresponding to its hash code, + modulo the length of the array. + + Collisions are handled using linear probing with the Robin Hood + technique. See Pedro Celis' paper, "Robin Hood Hashing": + + http://www.cs.uwaterloo.ca/research/tr/1986/CS-86-14.pdf + + The vector of entries is allocated in such a way that the GC doesn't + trace the weak values. For doubly-weak tables, this means that the + entries are allocated as an "atomic" piece of memory. Key-weak and + value-weak tables use a special GC kind with a custom mark procedure. + When items are added weakly into table, a disappearing link is + registered to their locations. If the referent is collected, then + that link will be zeroed out. + + An entry in the table consists of the key and the value, together + with the hash code of the key. We munge hash codes so that they are + never 0. In this way we can detect removed entries (key of zero but + nonzero hash code), and can then reshuffle elements as needed to + maintain the robin hood ordering. + + Compared to buckets-and-chains hash tables, open addressing has the + advantage that it is very cache-friendly. It also uses less memory. + + Implementation-wise, there are two things to note. + + 1. We assume that hash codes are evenly distributed across the + range of unsigned longs. The actual hash code stored in the + entry is left-shifted by 1 bit (losing 1 bit of hash precision), + and then or'd with 1. In this way we ensure that the hash field + of an occupied entry is nonzero. To map to an index, we + right-shift the hash by one, divide by the size, and take the + remainder. + + 2. Since the weak references are stored in an atomic region with + disappearing links, they need to be accessed with the GC alloc + lock. `copy_weak_entry' will do that for you. The hash code + itself can be read outside the lock, though. + */ + + +typedef struct { + unsigned long hash; + scm_t_bits key; + scm_t_bits value; +} scm_t_weak_entry; + + +struct weak_entry_data { + scm_t_weak_entry *in; + scm_t_weak_entry *out; +}; + +static void* +do_copy_weak_entry (void *data) +{ + struct weak_entry_data *e = data; + + e->out->hash = e->in->hash; + e->out->key = e->in->key; + e->out->value = e->in->value; + + return NULL; +} + +static void +copy_weak_entry (scm_t_weak_entry *src, scm_t_weak_entry *dst) +{ + struct weak_entry_data data; + + data.in = src; + data.out = dst; + + GC_call_with_alloc_lock (do_copy_weak_entry, &data); +} + +static void +register_disappearing_links (scm_t_weak_entry *entry, + SCM k, SCM v, + scm_t_weak_table_kind kind) +{ + if (SCM_UNPACK (k) && SCM_HEAP_OBJECT_P (k) + && (kind == SCM_WEAK_TABLE_KIND_KEY + || kind == SCM_WEAK_TABLE_KIND_BOTH)) + SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &entry->key, + SCM2PTR (k)); + + if (SCM_UNPACK (v) && SCM_HEAP_OBJECT_P (v) + && (kind == SCM_WEAK_TABLE_KIND_VALUE + || kind == SCM_WEAK_TABLE_KIND_BOTH)) + SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &entry->value, + SCM2PTR (v)); +} + +static void +unregister_disappearing_links (scm_t_weak_entry *entry, + scm_t_weak_table_kind kind) +{ + if (kind == SCM_WEAK_TABLE_KIND_KEY || kind == SCM_WEAK_TABLE_KIND_BOTH) + GC_unregister_disappearing_link ((void **) &entry->key); + + if (kind == SCM_WEAK_TABLE_KIND_VALUE || kind == SCM_WEAK_TABLE_KIND_BOTH) + GC_unregister_disappearing_link ((void **) &entry->value); +} + +#ifndef HAVE_GC_MOVE_DISAPPEARING_LINK +static void +GC_move_disappearing_link (void **from, void **to) +{ + GC_unregister_disappearing_link (from); + SCM_I_REGISTER_DISAPPEARING_LINK (to, *to); +} +#endif + +static void +move_disappearing_links (scm_t_weak_entry *from, scm_t_weak_entry *to, + SCM key, SCM value, scm_t_weak_table_kind kind) +{ + if ((kind == SCM_WEAK_TABLE_KIND_KEY || kind == SCM_WEAK_TABLE_KIND_BOTH) + && SCM_HEAP_OBJECT_P (key)) + GC_move_disappearing_link ((void **) &from->key, (void **) &to->key); + + if ((kind == SCM_WEAK_TABLE_KIND_VALUE || kind == SCM_WEAK_TABLE_KIND_BOTH) + && SCM_HEAP_OBJECT_P (value)) + GC_move_disappearing_link ((void **) &from->value, (void **) &to->value); +} + +static void +move_weak_entry (scm_t_weak_entry *from, scm_t_weak_entry *to, + scm_t_weak_table_kind kind) +{ + if (from->hash) + { + scm_t_weak_entry copy; + + copy_weak_entry (from, ©); + to->hash = copy.hash; + to->key = copy.key; + to->value = copy.value; + + move_disappearing_links (from, to, + SCM_PACK (copy.key), SCM_PACK (copy.value), + kind); + } + else + { + to->hash = 0; + to->key = 0; + to->value = 0; + } +} + + +typedef struct { + scm_t_weak_entry *entries; /* the data */ + scm_i_pthread_mutex_t lock; /* the lock */ + scm_t_weak_table_kind kind; /* what kind of table it is */ + unsigned long size; /* total number of slots. */ + unsigned long n_items; /* number of items in table */ + unsigned long lower; /* when to shrink */ + unsigned long upper; /* when to grow */ + int size_index; /* index into hashtable_size */ + int min_size_index; /* minimum size_index */ +} scm_t_weak_table; + + +#define SCM_WEAK_TABLE_P(x) (SCM_HAS_TYP7 (x, scm_tc7_weak_table)) +#define SCM_VALIDATE_WEAK_TABLE(pos, arg) \ + SCM_MAKE_VALIDATE_MSG (pos, arg, WEAK_TABLE_P, "weak-table") +#define SCM_WEAK_TABLE(x) ((scm_t_weak_table *) SCM_CELL_WORD_1 (x)) + + +static unsigned long +hash_to_index (unsigned long hash, unsigned long size) +{ + return (hash >> 1) % size; +} + +static unsigned long +entry_distance (unsigned long hash, unsigned long k, unsigned long size) +{ + unsigned long origin = hash_to_index (hash, size); + + if (k >= origin) + return k - origin; + else + /* The other key was displaced and wrapped around. */ + return size - origin + k; +} + +static void +rob_from_rich (scm_t_weak_table *table, unsigned long k) +{ + unsigned long empty, size; + + size = table->size; + + /* If we are to free up slot K in the table, we need room to do so. */ + assert (table->n_items < size); + + empty = k; + do + empty = (empty + 1) % size; + while (table->entries[empty].hash); + + do + { + unsigned long last = empty ? (empty - 1) : (size - 1); + move_weak_entry (&table->entries[last], &table->entries[empty], + table->kind); + empty = last; + } + while (empty != k); + + table->entries[empty].hash = 0; + table->entries[empty].key = 0; + table->entries[empty].value = 0; +} + +static void +give_to_poor (scm_t_weak_table *table, unsigned long k) +{ + /* Slot K was just freed up; possibly shuffle others down. */ + unsigned long size = table->size; + + while (1) + { + unsigned long next = (k + 1) % size; + unsigned long hash; + scm_t_weak_entry copy; + + hash = table->entries[next].hash; + + if (!hash || hash_to_index (hash, size) == next) + break; + + copy_weak_entry (&table->entries[next], ©); + + if (!copy.key || !copy.value) + /* Lost weak reference. */ + { + give_to_poor (table, next); + table->n_items--; + continue; + } + + move_weak_entry (&table->entries[next], &table->entries[k], + table->kind); + + k = next; + } + + /* We have shuffled down any entries that should be shuffled down; now + free the end. */ + table->entries[k].hash = 0; + table->entries[k].key = 0; + table->entries[k].value = 0; +} + + + + +/* The GC "kinds" for singly-weak tables. */ +static int weak_key_gc_kind; +static int weak_value_gc_kind; + +static struct GC_ms_entry * +mark_weak_key_table (GC_word *addr, struct GC_ms_entry *mark_stack_ptr, + struct GC_ms_entry *mark_stack_limit, GC_word env) +{ + scm_t_weak_entry *entries = (scm_t_weak_entry*) addr; + unsigned long k, size = GC_size (addr) / sizeof (scm_t_weak_entry); + + for (k = 0; k < size; k++) + if (entries[k].hash && entries[k].key) + { + SCM value = SCM_PACK (entries[k].value); + mark_stack_ptr = GC_MARK_AND_PUSH ((GC_word*) SCM2PTR (value), + mark_stack_ptr, mark_stack_limit, + NULL); + } + + return mark_stack_ptr; +} + +static struct GC_ms_entry * +mark_weak_value_table (GC_word *addr, struct GC_ms_entry *mark_stack_ptr, + struct GC_ms_entry *mark_stack_limit, GC_word env) +{ + scm_t_weak_entry *entries = (scm_t_weak_entry*) addr; + unsigned long k, size = GC_size (addr) / sizeof (scm_t_weak_entry); + + for (k = 0; k < size; k++) + if (entries[k].hash && entries[k].value) + { + SCM key = SCM_PACK (entries[k].key); + mark_stack_ptr = GC_MARK_AND_PUSH ((GC_word*) SCM2PTR (key), + mark_stack_ptr, mark_stack_limit, + NULL); + } + + return mark_stack_ptr; +} + +static scm_t_weak_entry * +allocate_entries (unsigned long size, scm_t_weak_table_kind kind) +{ + scm_t_weak_entry *ret; + size_t bytes = size * sizeof (*ret); + + switch (kind) + { + case SCM_WEAK_TABLE_KIND_KEY: + ret = GC_generic_malloc (bytes, weak_key_gc_kind); + break; + case SCM_WEAK_TABLE_KIND_VALUE: + ret = GC_generic_malloc (bytes, weak_value_gc_kind); + break; + case SCM_WEAK_TABLE_KIND_BOTH: + ret = scm_gc_malloc_pointerless (bytes, "weak-table"); + break; + default: + abort (); + } + + memset (ret, 0, bytes); + + return ret; +} + + + +/* Growing or shrinking is triggered when the load factor + * + * L = N / S (N: number of items in table, S: bucket vector length) + * + * passes an upper limit of 0.9 or a lower limit of 0.2. + * + * The implementation stores the upper and lower number of items which + * trigger a resize in the hashtable object. + * + * Possible hash table sizes (primes) are stored in the array + * hashtable_size. + */ + +static unsigned long hashtable_size[] = { + 31, 61, 113, 223, 443, 883, 1759, 3517, 7027, 14051, 28099, 56197, 112363, + 224717, 449419, 898823, 1797641, 3595271, 7190537, 14381041, 28762081, + 57524111, 115048217, 230096423 +}; + +#define HASHTABLE_SIZE_N (sizeof(hashtable_size)/sizeof(unsigned long)) + +static int +compute_size_index (scm_t_weak_table *table) +{ + int i = table->size_index; + + if (table->n_items < table->lower) + { + /* rehashing is not triggered when i <= min_size */ + do + --i; + while (i > table->min_size_index + && table->n_items < hashtable_size[i] / 5); + } + else if (table->n_items > table->upper) + { + ++i; + if (i >= HASHTABLE_SIZE_N) + /* The biggest size currently is 230096423, which for a 32-bit + machine will occupy 2.3GB of memory at a load of 80%. There + is probably something better to do here, but if you have a + weak map of that size, you are hosed in any case. */ + abort (); + } + + return i; +} + +static int +is_acceptable_size_index (scm_t_weak_table *table, int size_index) +{ + int computed = compute_size_index (table); + + if (size_index == computed) + /* We were going to grow or shrink, and allocating the new vector + didn't change the target size. */ + return 1; + + if (size_index == computed + 1) + { + /* We were going to enlarge the table, but allocating the new + vector finalized some objects, making an enlargement + unnecessary. It might still be a good idea to use the larger + table, though. (This branch also gets hit if, while allocating + the vector, some other thread was actively removing items from + the table. That is less likely, though.) */ + unsigned long new_lower = hashtable_size[size_index] / 5; + + return table->size > new_lower; + } + + if (size_index == computed - 1) + { + /* We were going to shrink the table, but when we dropped the lock + to allocate the new vector, some other thread added elements to + the table. */ + return 0; + } + + /* The computed size differs from our newly allocated size by more + than one size index -- recalculate. */ + return 0; +} + +static void +resize_table (scm_t_weak_table *table) +{ + scm_t_weak_entry *old_entries, *new_entries; + int new_size_index; + unsigned long old_size, new_size, old_k; + + do + { + new_size_index = compute_size_index (table); + if (new_size_index == table->size_index) + return; + new_size = hashtable_size[new_size_index]; + new_entries = allocate_entries (new_size, table->kind); + } + while (!is_acceptable_size_index (table, new_size_index)); + + old_entries = table->entries; + old_size = table->size; + + table->size_index = new_size_index; + table->size = new_size; + if (new_size_index <= table->min_size_index) + table->lower = 0; + else + table->lower = new_size / 5; + table->upper = 9 * new_size / 10; + table->n_items = 0; + table->entries = new_entries; + + for (old_k = 0; old_k < old_size; old_k++) + { + scm_t_weak_entry copy; + unsigned long new_k, distance; + + if (!old_entries[old_k].hash) + continue; + + copy_weak_entry (&old_entries[old_k], ©); + + if (!copy.key || !copy.value) + continue; + + new_k = hash_to_index (copy.hash, new_size); + + for (distance = 0; ; distance++, new_k = (new_k + 1) % new_size) + { + unsigned long other_hash = new_entries[new_k].hash; + + if (!other_hash) + /* Found an empty entry. */ + break; + + /* Displace the entry if our distance is less, otherwise keep + looking. */ + if (entry_distance (other_hash, new_k, new_size) < distance) + { + rob_from_rich (table, new_k); + break; + } + } + + table->n_items++; + new_entries[new_k].hash = copy.hash; + new_entries[new_k].key = copy.key; + new_entries[new_k].value = copy.value; + + register_disappearing_links (&new_entries[new_k], + SCM_PACK (copy.key), SCM_PACK (copy.value), + table->kind); + } +} + +/* Run after GC via do_vacuum_weak_table, this function runs over the + whole table, removing lost weak references, reshuffling the table as it + goes. It might resize the table if it reaps enough entries. */ +static void +vacuum_weak_table (scm_t_weak_table *table) +{ + scm_t_weak_entry *entries = table->entries; + unsigned long size = table->size; + unsigned long k; + + for (k = 0; k < size; k++) + { + unsigned long hash = entries[k].hash; + + if (hash) + { + scm_t_weak_entry copy; + + copy_weak_entry (&entries[k], ©); + + if (!copy.key || !copy.value) + /* Lost weak reference; reshuffle. */ + { + give_to_poor (table, k); + table->n_items--; + } + } + } + + if (table->n_items < table->lower) + resize_table (table); +} + + + + +static SCM +weak_table_ref (scm_t_weak_table *table, unsigned long hash, + scm_t_table_predicate_fn pred, void *closure, + SCM dflt) +{ + unsigned long k, distance, size; + scm_t_weak_entry *entries; + + size = table->size; + entries = table->entries; + + hash = (hash << 1) | 0x1; + k = hash_to_index (hash, size); + + for (distance = 0; distance < size; distance++, k = (k + 1) % size) + { + unsigned long other_hash; + + retry: + other_hash = entries[k].hash; + + if (!other_hash) + /* Not found. */ + return dflt; + + if (hash == other_hash) + { + scm_t_weak_entry copy; + + copy_weak_entry (&entries[k], ©); + + if (!copy.key || !copy.value) + /* Lost weak reference; reshuffle. */ + { + give_to_poor (table, k); + table->n_items--; + goto retry; + } + + if (pred (SCM_PACK (copy.key), SCM_PACK (copy.value), closure)) + /* Found. */ + return SCM_PACK (copy.value); + } + + /* If the entry's distance is less, our key is not in the table. */ + if (entry_distance (other_hash, k, size) < distance) + return dflt; + } + + /* If we got here, then we were unfortunate enough to loop through the + whole table. Shouldn't happen, but hey. */ + return dflt; +} + + +static void +weak_table_put_x (scm_t_weak_table *table, unsigned long hash, + scm_t_table_predicate_fn pred, void *closure, + SCM key, SCM value) +{ + unsigned long k, distance, size; + scm_t_weak_entry *entries; + + size = table->size; + entries = table->entries; + + hash = (hash << 1) | 0x1; + k = hash_to_index (hash, size); + + for (distance = 0; ; distance++, k = (k + 1) % size) + { + unsigned long other_hash; + + retry: + other_hash = entries[k].hash; + + if (!other_hash) + /* Found an empty entry. */ + break; + + if (other_hash == hash) + { + scm_t_weak_entry copy; + + copy_weak_entry (&entries[k], ©); + + if (!copy.key || !copy.value) + /* Lost weak reference; reshuffle. */ + { + give_to_poor (table, k); + table->n_items--; + goto retry; + } + + if (pred (SCM_PACK (copy.key), SCM_PACK (copy.value), closure)) + /* Found an entry with this key. */ + break; + } + + if (table->n_items > table->upper) + /* Full table, time to resize. */ + { + resize_table (table); + return weak_table_put_x (table, hash >> 1, pred, closure, key, value); + } + + /* Displace the entry if our distance is less, otherwise keep + looking. */ + if (entry_distance (other_hash, k, size) < distance) + { + rob_from_rich (table, k); + break; + } + } + + if (entries[k].hash) + unregister_disappearing_links (&entries[k], table->kind); + else + table->n_items++; + + entries[k].hash = hash; + entries[k].key = SCM_UNPACK (key); + entries[k].value = SCM_UNPACK (value); + + register_disappearing_links (&entries[k], key, value, table->kind); +} + + +static void +weak_table_remove_x (scm_t_weak_table *table, unsigned long hash, + scm_t_table_predicate_fn pred, void *closure) +{ + unsigned long k, distance, size; + scm_t_weak_entry *entries; + + size = table->size; + entries = table->entries; + + hash = (hash << 1) | 0x1; + k = hash_to_index (hash, size); + + for (distance = 0; distance < size; distance++, k = (k + 1) % size) + { + unsigned long other_hash; + + retry: + other_hash = entries[k].hash; + + if (!other_hash) + /* Not found. */ + return; + + if (other_hash == hash) + { + scm_t_weak_entry copy; + + copy_weak_entry (&entries[k], ©); + + if (!copy.key || !copy.value) + /* Lost weak reference; reshuffle. */ + { + give_to_poor (table, k); + table->n_items--; + goto retry; + } + + if (pred (SCM_PACK (copy.key), SCM_PACK (copy.value), closure)) + /* Found an entry with this key. */ + { + entries[k].hash = 0; + entries[k].key = 0; + entries[k].value = 0; + + unregister_disappearing_links (&entries[k], table->kind); + + if (--table->n_items < table->lower) + resize_table (table); + else + give_to_poor (table, k); + + return; + } + } + + /* If the entry's distance is less, our key is not in the table. */ + if (entry_distance (other_hash, k, size) < distance) + return; + } +} + + + +static SCM +make_weak_table (unsigned long k, scm_t_weak_table_kind kind) +{ + scm_t_weak_table *table; + + int i = 0, n = k ? k : 31; + while (i + 1 < HASHTABLE_SIZE_N && n > hashtable_size[i]) + ++i; + n = hashtable_size[i]; + + table = scm_gc_malloc (sizeof (*table), "weak-table"); + table->entries = allocate_entries (n, kind); + table->kind = kind; + table->n_items = 0; + table->size = n; + table->lower = 0; + table->upper = 9 * n / 10; + table->size_index = i; + table->min_size_index = i; + scm_i_pthread_mutex_init (&table->lock, NULL); + + return scm_cell (scm_tc7_weak_table, (scm_t_bits)table); +} + +void +scm_i_weak_table_print (SCM exp, SCM port, scm_print_state *pstate) +{ + scm_puts_unlocked ("#<", port); + scm_puts_unlocked ("weak-table ", port); + scm_uintprint (SCM_WEAK_TABLE (exp)->n_items, 10, port); + scm_putc_unlocked ('/', port); + scm_uintprint (SCM_WEAK_TABLE (exp)->size, 10, port); + scm_puts_unlocked (">", port); +} + +static void +do_vacuum_weak_table (SCM table) +{ + scm_t_weak_table *t; + + t = SCM_WEAK_TABLE (table); + + /* Unlike weak sets, the weak table interface allows custom predicates + to call out to arbitrary Scheme. There are two ways that this code + can be re-entrant, then: calling weak hash procedures while in a + custom predicate, or via finalizers run explicitly by (gc) or in an + async (for non-threaded Guile). We add a restriction that + prohibits the first case, by convention. But since we can't + prohibit the second case, here we trylock instead of lock. Not so + nice. */ + if (scm_i_pthread_mutex_trylock (&t->lock) == 0) + { + vacuum_weak_table (t); + scm_i_pthread_mutex_unlock (&t->lock); + } + + return; +} + +SCM +scm_c_make_weak_table (unsigned long k, scm_t_weak_table_kind kind) +{ + SCM ret; + + ret = make_weak_table (k, kind); + + scm_i_register_weak_gc_callback (ret, do_vacuum_weak_table); + + return ret; +} + +SCM +scm_weak_table_p (SCM obj) +{ + return scm_from_bool (SCM_WEAK_TABLE_P (obj)); +} + +SCM +scm_c_weak_table_ref (SCM table, unsigned long raw_hash, + scm_t_table_predicate_fn pred, + void *closure, SCM dflt) +#define FUNC_NAME "weak-table-ref" +{ + SCM ret; + scm_t_weak_table *t; + + SCM_VALIDATE_WEAK_TABLE (1, table); + + t = SCM_WEAK_TABLE (table); + + scm_i_pthread_mutex_lock (&t->lock); + + ret = weak_table_ref (t, raw_hash, pred, closure, dflt); + + scm_i_pthread_mutex_unlock (&t->lock); + + return ret; +} +#undef FUNC_NAME + +void +scm_c_weak_table_put_x (SCM table, unsigned long raw_hash, + scm_t_table_predicate_fn pred, + void *closure, SCM key, SCM value) +#define FUNC_NAME "weak-table-put!" +{ + scm_t_weak_table *t; + + SCM_VALIDATE_WEAK_TABLE (1, table); + + t = SCM_WEAK_TABLE (table); + + scm_i_pthread_mutex_lock (&t->lock); + + weak_table_put_x (t, raw_hash, pred, closure, key, value); + + scm_i_pthread_mutex_unlock (&t->lock); +} +#undef FUNC_NAME + +void +scm_c_weak_table_remove_x (SCM table, unsigned long raw_hash, + scm_t_table_predicate_fn pred, + void *closure) +#define FUNC_NAME "weak-table-remove!" +{ + scm_t_weak_table *t; + + SCM_VALIDATE_WEAK_TABLE (1, table); + + t = SCM_WEAK_TABLE (table); + + scm_i_pthread_mutex_lock (&t->lock); + + weak_table_remove_x (t, raw_hash, pred, closure); + + scm_i_pthread_mutex_unlock (&t->lock); +} +#undef FUNC_NAME + +static int +assq_predicate (SCM x, SCM y, void *closure) +{ + return scm_is_eq (x, SCM_PACK_POINTER (closure)); +} + +SCM +scm_weak_table_refq (SCM table, SCM key, SCM dflt) +{ + if (SCM_UNBNDP (dflt)) + dflt = SCM_BOOL_F; + + return scm_c_weak_table_ref (table, scm_ihashq (key, -1), + assq_predicate, SCM_UNPACK_POINTER (key), + dflt); +} + +void +scm_weak_table_putq_x (SCM table, SCM key, SCM value) +{ + scm_c_weak_table_put_x (table, scm_ihashq (key, -1), + assq_predicate, SCM_UNPACK_POINTER (key), + key, value); +} + +void +scm_weak_table_remq_x (SCM table, SCM key) +{ + scm_c_weak_table_remove_x (table, scm_ihashq (key, -1), + assq_predicate, SCM_UNPACK_POINTER (key)); +} + +void +scm_weak_table_clear_x (SCM table) +#define FUNC_NAME "weak-table-clear!" +{ + scm_t_weak_table *t; + + SCM_VALIDATE_WEAK_TABLE (1, table); + + t = SCM_WEAK_TABLE (table); + + scm_i_pthread_mutex_lock (&t->lock); + + memset (t->entries, 0, sizeof (scm_t_weak_entry) * t->size); + t->n_items = 0; + + scm_i_pthread_mutex_unlock (&t->lock); +} +#undef FUNC_NAME + +SCM +scm_c_weak_table_fold (scm_t_table_fold_fn proc, void *closure, + SCM init, SCM table) +{ + scm_t_weak_table *t; + scm_t_weak_entry *entries; + unsigned long k, size; + + t = SCM_WEAK_TABLE (table); + + scm_i_pthread_mutex_lock (&t->lock); + + size = t->size; + entries = t->entries; + + for (k = 0; k < size; k++) + { + if (entries[k].hash) + { + scm_t_weak_entry copy; + + copy_weak_entry (&entries[k], ©); + + if (copy.key && copy.value) + { + /* Release table lock while we call the function. */ + scm_i_pthread_mutex_unlock (&t->lock); + init = proc (closure, + SCM_PACK (copy.key), SCM_PACK (copy.value), + init); + scm_i_pthread_mutex_lock (&t->lock); + } + } + } + + scm_i_pthread_mutex_unlock (&t->lock); + + return init; +} + +static SCM +fold_trampoline (void *closure, SCM k, SCM v, SCM init) +{ + return scm_call_3 (SCM_PACK_POINTER (closure), k, v, init); +} + +SCM +scm_weak_table_fold (SCM proc, SCM init, SCM table) +#define FUNC_NAME "weak-table-fold" +{ + SCM_VALIDATE_WEAK_TABLE (3, table); + SCM_VALIDATE_PROC (1, proc); + + return scm_c_weak_table_fold (fold_trampoline, SCM_UNPACK_POINTER (proc), init, table); +} +#undef FUNC_NAME + +static SCM +for_each_trampoline (void *closure, SCM k, SCM v, SCM seed) +{ + scm_call_2 (SCM_PACK_POINTER (closure), k, v); + return seed; +} + +void +scm_weak_table_for_each (SCM proc, SCM table) +#define FUNC_NAME "weak-table-for-each" +{ + SCM_VALIDATE_WEAK_TABLE (2, table); + SCM_VALIDATE_PROC (1, proc); + + scm_c_weak_table_fold (for_each_trampoline, SCM_UNPACK_POINTER (proc), SCM_BOOL_F, table); +} +#undef FUNC_NAME + +static SCM +map_trampoline (void *closure, SCM k, SCM v, SCM seed) +{ + return scm_cons (scm_call_2 (SCM_PACK_POINTER (closure), k, v), seed); +} + +SCM +scm_weak_table_map_to_list (SCM proc, SCM table) +#define FUNC_NAME "weak-table-map->list" +{ + SCM_VALIDATE_WEAK_TABLE (2, table); + SCM_VALIDATE_PROC (1, proc); + + return scm_c_weak_table_fold (map_trampoline, SCM_UNPACK_POINTER (proc), SCM_EOL, table); +} +#undef FUNC_NAME + + + + +/* Legacy interface. */ + +SCM_DEFINE (scm_make_weak_key_hash_table, "make-weak-key-hash-table", 0, 1, 0, + (SCM n), + "@deffnx {Scheme Procedure} make-weak-value-hash-table size\n" + "@deffnx {Scheme Procedure} make-doubly-weak-hash-table size\n" + "Return a weak hash table with @var{size} buckets.\n" + "\n" + "You can modify weak hash tables in exactly the same way you\n" + "would modify regular hash tables. (@pxref{Hash Tables})") +#define FUNC_NAME s_scm_make_weak_key_hash_table +{ + return scm_c_make_weak_table (SCM_UNBNDP (n) ? 0 : scm_to_ulong (n), + SCM_WEAK_TABLE_KIND_KEY); +} +#undef FUNC_NAME + + +SCM_DEFINE (scm_make_weak_value_hash_table, "make-weak-value-hash-table", 0, 1, 0, + (SCM n), + "Return a hash table with weak values with @var{size} buckets.\n" + "(@pxref{Hash Tables})") +#define FUNC_NAME s_scm_make_weak_value_hash_table +{ + return scm_c_make_weak_table (SCM_UNBNDP (n) ? 0 : scm_to_ulong (n), + SCM_WEAK_TABLE_KIND_VALUE); +} +#undef FUNC_NAME + + +SCM_DEFINE (scm_make_doubly_weak_hash_table, "make-doubly-weak-hash-table", 1, 0, 0, + (SCM n), + "Return a hash table with weak keys and values with @var{size}\n" + "buckets. (@pxref{Hash Tables})") +#define FUNC_NAME s_scm_make_doubly_weak_hash_table +{ + return scm_c_make_weak_table (SCM_UNBNDP (n) ? 0 : scm_to_ulong (n), + SCM_WEAK_TABLE_KIND_BOTH); +} +#undef FUNC_NAME + + +SCM_DEFINE (scm_weak_key_hash_table_p, "weak-key-hash-table?", 1, 0, 0, + (SCM obj), + "@deffnx {Scheme Procedure} weak-value-hash-table? obj\n" + "@deffnx {Scheme Procedure} doubly-weak-hash-table? obj\n" + "Return @code{#t} if @var{obj} is the specified weak hash\n" + "table. Note that a doubly weak hash table is neither a weak key\n" + "nor a weak value hash table.") +#define FUNC_NAME s_scm_weak_key_hash_table_p +{ + return scm_from_bool (SCM_WEAK_TABLE_P (obj) && + SCM_WEAK_TABLE (obj)->kind == SCM_WEAK_TABLE_KIND_KEY); +} +#undef FUNC_NAME + + +SCM_DEFINE (scm_weak_value_hash_table_p, "weak-value-hash-table?", 1, 0, 0, + (SCM obj), + "Return @code{#t} if @var{obj} is a weak value hash table.") +#define FUNC_NAME s_scm_weak_value_hash_table_p +{ + return scm_from_bool (SCM_WEAK_TABLE_P (obj) && + SCM_WEAK_TABLE (obj)->kind == SCM_WEAK_TABLE_KIND_VALUE); +} +#undef FUNC_NAME + + +SCM_DEFINE (scm_doubly_weak_hash_table_p, "doubly-weak-hash-table?", 1, 0, 0, + (SCM obj), + "Return @code{#t} if @var{obj} is a doubly weak hash table.") +#define FUNC_NAME s_scm_doubly_weak_hash_table_p +{ + return scm_from_bool (SCM_WEAK_TABLE_P (obj) && + SCM_WEAK_TABLE (obj)->kind == SCM_WEAK_TABLE_KIND_BOTH); +} +#undef FUNC_NAME + + + + + +void +scm_weak_table_prehistory (void) +{ + weak_key_gc_kind = + GC_new_kind (GC_new_free_list (), + GC_MAKE_PROC (GC_new_proc (mark_weak_key_table), 0), + 0, 0); + weak_value_gc_kind = + GC_new_kind (GC_new_free_list (), + GC_MAKE_PROC (GC_new_proc (mark_weak_value_table), 0), + 0, 0); +} + +void +scm_init_weak_table () +{ +#include "libguile/weak-table.x" +} + +/* + Local Variables: + c-file-style: "gnu" + End: +*/ diff --git a/libguile/weak-table.h b/libguile/weak-table.h new file mode 100644 index 000000000..f516c2601 --- /dev/null +++ b/libguile/weak-table.h @@ -0,0 +1,94 @@ +/* classes: h_files */ + +#ifndef SCM_WEAK_TABLE_H +#define SCM_WEAK_TABLE_H + +/* Copyright (C) 2011, 2012 Free Software Foundation, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 3 of + * the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + + + +#include "libguile/__scm.h" + + + +/* The weak table API is currently only used internally. We could make it + public later, after some API review. */ + +typedef enum { + SCM_WEAK_TABLE_KIND_KEY, + SCM_WEAK_TABLE_KIND_VALUE, + SCM_WEAK_TABLE_KIND_BOTH, +} scm_t_weak_table_kind; + +/* Function that returns nonzero if the given mapping is the one we are + looking for. */ +typedef int (*scm_t_table_predicate_fn) (SCM k, SCM v, void *closure); + +/* Function to fold over the elements of a set. */ +typedef SCM (*scm_t_table_fold_fn) (void *closure, SCM k, SCM v, SCM result); + +SCM_INTERNAL SCM scm_c_make_weak_table (unsigned long k, + scm_t_weak_table_kind kind); +SCM_INTERNAL SCM scm_weak_table_p (SCM h); + +SCM_INTERNAL SCM scm_c_weak_table_ref (SCM table, unsigned long raw_hash, + scm_t_table_predicate_fn pred, + void *closure, SCM dflt); +SCM_INTERNAL void scm_c_weak_table_put_x (SCM table, unsigned long raw_hash, + scm_t_table_predicate_fn pred, + void *closure, SCM key, SCM value); +SCM_INTERNAL void scm_c_weak_table_remove_x (SCM table, unsigned long raw_hash, + scm_t_table_predicate_fn pred, + void *closure); + +SCM_INTERNAL SCM scm_weak_table_refq (SCM table, SCM key, SCM dflt); +SCM_INTERNAL void scm_weak_table_putq_x (SCM table, SCM key, SCM value); +SCM_INTERNAL void scm_weak_table_remq_x (SCM table, SCM key); + +SCM_INTERNAL void scm_weak_table_clear_x (SCM table); + +SCM_INTERNAL SCM scm_c_weak_table_fold (scm_t_table_fold_fn proc, void *closure, + SCM init, SCM table); +SCM_INTERNAL SCM scm_weak_table_fold (SCM proc, SCM init, SCM table); +SCM_INTERNAL void scm_weak_table_for_each (SCM proc, SCM table); +SCM_INTERNAL SCM scm_weak_table_map_to_list (SCM proc, SCM table); + + + +/* Legacy interface. */ +SCM_API SCM scm_make_weak_key_hash_table (SCM k); +SCM_API SCM scm_make_weak_value_hash_table (SCM k); +SCM_API SCM scm_make_doubly_weak_hash_table (SCM k); +SCM_API SCM scm_weak_key_hash_table_p (SCM h); +SCM_API SCM scm_weak_value_hash_table_p (SCM h); +SCM_API SCM scm_doubly_weak_hash_table_p (SCM h); + + + +SCM_INTERNAL void scm_i_weak_table_print (SCM exp, SCM port, scm_print_state *pstate); +SCM_INTERNAL void scm_weak_table_prehistory (void); +SCM_INTERNAL void scm_init_weak_table (void); + +#endif /* SCM_WEAK_TABLE_H */ + +/* + Local Variables: + c-file-style: "gnu" + End: +*/ diff --git a/libguile/weak-vector.c b/libguile/weak-vector.c new file mode 100644 index 000000000..3e90b3d57 --- /dev/null +++ b/libguile/weak-vector.c @@ -0,0 +1,207 @@ +/* Copyright (C) 1995,1996,1998,2000,2001, 2003, 2006, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 3 of + * the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + + + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#include <stdio.h> + +#include "libguile/_scm.h" +#include "libguile/vectors.h" + +#include "libguile/validate.h" + + + +/* {Weak Vectors} + */ + +#define VECTOR_MAX_LENGTH (SCM_T_BITS_MAX >> 8) + +static SCM +make_weak_vector (size_t len, SCM fill) +#define FUNC_NAME "make-weak-vector" +{ + SCM wv; + size_t j; + + SCM_ASSERT_RANGE (1, scm_from_size_t (len), len <= VECTOR_MAX_LENGTH); + + if (SCM_UNBNDP (fill)) + fill = SCM_UNSPECIFIED; + + wv = SCM_PACK_POINTER (scm_gc_malloc_pointerless ((len + 1) * sizeof (SCM), + "weak vector")); + + SCM_SET_CELL_WORD_0 (wv, (len << 8) | scm_tc7_wvect); + + if (SCM_HEAP_OBJECT_P (fill)) + { + memset (SCM_I_VECTOR_WELTS (wv), 0, len * sizeof (SCM)); + for (j = 0; j < len; j++) + scm_c_weak_vector_set_x (wv, j, fill); + } + else + for (j = 0; j < len; j++) + SCM_SIMPLE_VECTOR_SET (wv, j, fill); + + return wv; +} +#undef FUNC_NAME + +SCM_DEFINE (scm_make_weak_vector, "make-weak-vector", 1, 1, 0, + (SCM size, SCM fill), + "Return a weak vector with @var{size} elements. If the optional\n" + "argument @var{fill} is given, all entries in the vector will be\n" + "set to @var{fill}. The default value for @var{fill} is the\n" + "empty list.") +#define FUNC_NAME s_scm_make_weak_vector +{ + return make_weak_vector (scm_to_size_t (size), fill); +} +#undef FUNC_NAME + + +SCM_REGISTER_PROC(s_list_to_weak_vector, "list->weak-vector", 1, 0, 0, scm_weak_vector); + +SCM_DEFINE (scm_weak_vector, "weak-vector", 0, 0, 1, + (SCM lst), + "@deffnx {Scheme Procedure} list->weak-vector lst\n" + "Construct a weak vector from a list: @code{weak-vector} uses\n" + "the list of its arguments while @code{list->weak-vector} uses\n" + "its only argument @var{l} (a list) to construct a weak vector\n" + "the same way @code{list->vector} would.") +#define FUNC_NAME s_scm_weak_vector +{ + SCM wv; + size_t i; + long c_size; + + SCM_VALIDATE_LIST_COPYLEN (SCM_ARG1, lst, c_size); + + wv = make_weak_vector ((size_t) c_size, SCM_BOOL_F); + + for (i = 0; scm_is_pair (lst); lst = SCM_CDR (lst), i++) + scm_c_weak_vector_set_x (wv, i, SCM_CAR (lst)); + + return wv; +} +#undef FUNC_NAME + + +SCM_DEFINE (scm_weak_vector_p, "weak-vector?", 1, 0, 0, + (SCM obj), + "Return @code{#t} if @var{obj} is a weak vector. Note that all\n" + "weak hashes are also weak vectors.") +#define FUNC_NAME s_scm_weak_vector_p +{ + return scm_from_bool (SCM_I_WVECTP (obj)); +} +#undef FUNC_NAME + + +struct weak_vector_ref_data +{ + SCM wv; + size_t k; +}; + +static void* +weak_vector_ref (void *data) +{ + struct weak_vector_ref_data *d = data; + + return SCM_SIMPLE_VECTOR_REF (d->wv, d->k); +} + +SCM +scm_c_weak_vector_ref (SCM wv, size_t k) +{ + struct weak_vector_ref_data d; + void *ret; + + d.wv = wv; + d.k = k; + + if (k >= SCM_I_VECTOR_LENGTH (wv)) + scm_out_of_range (NULL, scm_from_size_t (k)); + + ret = GC_call_with_alloc_lock (weak_vector_ref, &d); + + if (ret) + return SCM_PACK_POINTER (ret); + else + return SCM_BOOL_F; +} + + +void +scm_c_weak_vector_set_x (SCM wv, size_t k, SCM x) +{ + SCM *elts; + struct weak_vector_ref_data d; + void *prev; + + d.wv = wv; + d.k = k; + + if (k >= SCM_I_VECTOR_LENGTH (wv)) + scm_out_of_range (NULL, scm_from_size_t (k)); + + prev = GC_call_with_alloc_lock (weak_vector_ref, &d); + + elts = SCM_I_VECTOR_WELTS (wv); + + if (prev && SCM_HEAP_OBJECT_P (SCM_PACK_POINTER (prev))) + GC_unregister_disappearing_link ((void **) &elts[k]); + + elts[k] = x; + + if (SCM_HEAP_OBJECT_P (x)) + SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &elts[k], + SCM2PTR (x)); +} + + + +static void +scm_init_weak_vector_builtins (void) +{ +#ifndef SCM_MAGIC_SNARFER +#include "libguile/weak-vector.x" +#endif +} + +void +scm_init_weak_vectors () +{ + scm_c_register_extension ("libguile-" SCM_EFFECTIVE_VERSION, + "scm_init_weak_vector_builtins", + (scm_t_extension_init_func)scm_init_weak_vector_builtins, + NULL); +} + + +/* + Local Variables: + c-file-style: "gnu" + End: +*/ diff --git a/libguile/weak-vector.h b/libguile/weak-vector.h new file mode 100644 index 000000000..1fd7cb5ec --- /dev/null +++ b/libguile/weak-vector.h @@ -0,0 +1,48 @@ +/* classes: h_files */ + +#ifndef SCM_WEAK_VECTOR_H +#define SCM_WEAK_VECTOR_H + +/* Copyright (C) 1995,1996,2000,2001, 2003, 2006, 2008, 2009, 2011 Free Software Foundation, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 3 of + * the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + + + +#include "libguile/__scm.h" + + +/* Weak vectors. */ + +#define SCM_I_WVECTP(x) (SCM_HAS_TYP7 (x, scm_tc7_wvect)) + +SCM_API SCM scm_make_weak_vector (SCM k, SCM fill); +SCM_API SCM scm_weak_vector (SCM l); +SCM_API SCM scm_weak_vector_p (SCM x); +SCM_INTERNAL SCM scm_c_weak_vector_ref (SCM v, size_t k); +SCM_INTERNAL void scm_c_weak_vector_set_x (SCM v, size_t k, SCM x); + +SCM_INTERNAL void scm_init_weak_vectors (void); + + +#endif /* SCM_WEAK_VECTOR_H */ + +/* + Local Variables: + c-file-style: "gnu" + End: +*/ diff --git a/libguile/weaks.c b/libguile/weaks.c deleted file mode 100644 index 79ae1fee5..000000000 --- a/libguile/weaks.c +++ /dev/null @@ -1,291 +0,0 @@ -/* Copyright (C) 1995, 1996, 1998, 2000, 2001, 2003, 2006, 2008, 2009, 2010, - * 2011, 2012 Free Software Foundation, Inc. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public License - * as published by the Free Software Foundation; either version 3 of - * the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA - * 02110-1301 USA - */ - - - -#ifdef HAVE_CONFIG_H -# include <config.h> -#endif - -#include <stdio.h> - -#include "libguile/_scm.h" -#include "libguile/vectors.h" -#include "libguile/hashtab.h" - -#include "libguile/validate.h" -#include "libguile/weaks.h" - -#include "libguile/bdw-gc.h" -#include <gc/gc_typed.h> - - - -/* Weak pairs for use in weak alist vectors and weak hash tables. - - We have weal-car pairs, weak-cdr pairs, and doubly weak pairs. In weak - pairs, the weak component(s) are not scanned for pointers and are - registered as disapperaring links; therefore, the weak component may be - set to NULL by the garbage collector when no other reference to that word - exist. Thus, users should only access weak pairs via the - `SCM_WEAK_PAIR_C[AD]R ()' macros. See also `scm_fixup_weak_alist ()' in - `hashtab.c'. */ - -/* Type descriptors for weak-c[ad]r pairs. */ -static GC_descr wcar_pair_descr, wcdr_pair_descr; - - -SCM -scm_weak_car_pair (SCM car, SCM cdr) -{ - scm_t_cell *cell; - - cell = (scm_t_cell *)GC_malloc_explicitly_typed (sizeof (*cell), - wcar_pair_descr); - - cell->word_0 = car; - cell->word_1 = cdr; - - if (SCM_NIMP (car)) - /* Weak car cells make sense iff the car is non-immediate. */ - SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &cell->word_0, SCM2PTR (car)); - - return (SCM_PACK (cell)); -} - -SCM -scm_weak_cdr_pair (SCM car, SCM cdr) -{ - scm_t_cell *cell; - - cell = (scm_t_cell *)GC_malloc_explicitly_typed (sizeof (*cell), - wcdr_pair_descr); - - cell->word_0 = car; - cell->word_1 = cdr; - - if (SCM_NIMP (cdr)) - /* Weak cdr cells make sense iff the cdr is non-immediate. */ - SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &cell->word_1, SCM2PTR (cdr)); - - return (SCM_PACK (cell)); -} - -SCM -scm_doubly_weak_pair (SCM car, SCM cdr) -{ - /* Doubly weak cells shall not be scanned at all for pointers. */ - scm_t_cell *cell = (scm_t_cell *)scm_gc_malloc_pointerless (sizeof (*cell), - "weak cell"); - - cell->word_0 = car; - cell->word_1 = cdr; - - if (SCM_NIMP (car)) - SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &cell->word_0, SCM2PTR (car)); - if (SCM_NIMP (cdr)) - SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &cell->word_1, SCM2PTR (cdr)); - - return (SCM_PACK (cell)); -} - - - - -/* 1. The current hash table implementation in hashtab.c uses weak alist - * vectors (formerly called weak hash tables) internally. - * - * 2. All hash table operations still work on alist vectors. - * - * 3. The weak vector and alist vector Scheme API is accessed through - * the module (ice-9 weak-vector). - */ - - -/* {Weak Vectors} - */ - - -SCM_DEFINE (scm_make_weak_vector, "make-weak-vector", 1, 1, 0, - (SCM size, SCM fill), - "Return a weak vector with @var{size} elements. If the optional\n" - "argument @var{fill} is given, all entries in the vector will be\n" - "set to @var{fill}. The default value for @var{fill} is the\n" - "empty list.") -#define FUNC_NAME s_scm_make_weak_vector -{ - return scm_i_make_weak_vector (0, size, fill); -} -#undef FUNC_NAME - - -SCM_REGISTER_PROC(s_list_to_weak_vector, "list->weak-vector", 1, 0, 0, scm_weak_vector); - -SCM_DEFINE (scm_weak_vector, "weak-vector", 0, 0, 1, - (SCM l), - "@deffnx {Scheme Procedure} list->weak-vector l\n" - "Construct a weak vector from a list: @code{weak-vector} uses\n" - "the list of its arguments while @code{list->weak-vector} uses\n" - "its only argument @var{l} (a list) to construct a weak vector\n" - "the same way @code{list->vector} would.") -#define FUNC_NAME s_scm_weak_vector -{ - return scm_i_make_weak_vector_from_list (0, l); -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_weak_vector_p, "weak-vector?", 1, 0, 0, - (SCM obj), - "Return @code{#t} if @var{obj} is a weak vector. Note that all\n" - "weak hashes are also weak vectors.") -#define FUNC_NAME s_scm_weak_vector_p -{ - return scm_from_bool (SCM_I_WVECTP (obj) && !SCM_IS_WHVEC (obj)); -} -#undef FUNC_NAME - - -/* Weak alist vectors, i.e., vectors of alists. - - The alist vector themselves are _not_ weak. The `car' (or `cdr', or both) - of the pairs within it are weak. See `hashtab.c' for details. */ - - -/* FIXME: We used to have two implementations of weak hash tables: the one in - here and the one in `hashtab.c'. The difference is that weak alist - vectors could be used as vectors while (weak) hash tables can't. We need - to unify that. */ - -SCM_DEFINE (scm_make_weak_key_alist_vector, "make-weak-key-alist-vector", 0, 1, 0, - (SCM size), - "@deffnx {Scheme Procedure} make-weak-value-alist-vector size\n" - "@deffnx {Scheme Procedure} make-doubly-weak-alist-vector size\n" - "Return a weak hash table with @var{size} buckets. As with any\n" - "hash table, choosing a good size for the table requires some\n" - "caution.\n" - "\n" - "You can modify weak hash tables in exactly the same way you\n" - "would modify regular hash tables. (@pxref{Hash Tables})") -#define FUNC_NAME s_scm_make_weak_key_alist_vector -{ - return scm_make_weak_key_hash_table (size); -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_make_weak_value_alist_vector, "make-weak-value-alist-vector", 0, 1, 0, - (SCM size), - "Return a hash table with weak values with @var{size} buckets.\n" - "(@pxref{Hash Tables})") -#define FUNC_NAME s_scm_make_weak_value_alist_vector -{ - return scm_make_weak_value_hash_table (size); -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_make_doubly_weak_alist_vector, "make-doubly-weak-alist-vector", 1, 0, 0, - (SCM size), - "Return a hash table with weak keys and values with @var{size}\n" - "buckets. (@pxref{Hash Tables})") -#define FUNC_NAME s_scm_make_doubly_weak_alist_vector -{ - return scm_make_doubly_weak_hash_table (size); -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_weak_key_alist_vector_p, "weak-key-alist-vector?", 1, 0, 0, - (SCM obj), - "@deffnx {Scheme Procedure} weak-value-alist-vector? obj\n" - "@deffnx {Scheme Procedure} doubly-weak-alist-vector? obj\n" - "Return @code{#t} if @var{obj} is the specified weak hash\n" - "table. Note that a doubly weak hash table is neither a weak key\n" - "nor a weak value hash table.") -#define FUNC_NAME s_scm_weak_key_alist_vector_p -{ - return scm_from_bool (SCM_I_WVECTP (obj) && SCM_IS_WHVEC (obj)); -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_weak_value_alist_vector_p, "weak-value-alist-vector?", 1, 0, 0, - (SCM obj), - "Return @code{#t} if @var{obj} is a weak value hash table.") -#define FUNC_NAME s_scm_weak_value_alist_vector_p -{ - return scm_from_bool (SCM_I_WVECTP (obj) && SCM_IS_WHVEC_V (obj)); -} -#undef FUNC_NAME - - -SCM_DEFINE (scm_doubly_weak_alist_vector_p, "doubly-weak-alist-vector?", 1, 0, 0, - (SCM obj), - "Return @code{#t} if @var{obj} is a doubly weak hash table.") -#define FUNC_NAME s_scm_doubly_weak_alist_vector_p -{ - return scm_from_bool (SCM_I_WVECTP (obj) && SCM_IS_WHVEC_B (obj)); -} -#undef FUNC_NAME - - - - -SCM -scm_init_weaks_builtins () -{ -#include "libguile/weaks.x" - return SCM_UNSPECIFIED; -} - -void -scm_weaks_prehistory () -{ - /* Initialize weak pairs. */ - GC_word wcar_pair_bitmap[GC_BITMAP_SIZE (scm_t_cell)] = { 0 }; - GC_word wcdr_pair_bitmap[GC_BITMAP_SIZE (scm_t_cell)] = { 0 }; - - /* In a weak-car pair, only the second word must be scanned for - pointers. */ - GC_set_bit (wcar_pair_bitmap, GC_WORD_OFFSET (scm_t_cell, word_1)); - wcar_pair_descr = GC_make_descriptor (wcar_pair_bitmap, - GC_WORD_LEN (scm_t_cell)); - - /* Conversely, in a weak-cdr pair, only the first word must be scanned for - pointers. */ - GC_set_bit (wcdr_pair_bitmap, GC_WORD_OFFSET (scm_t_cell, word_0)); - wcdr_pair_descr = GC_make_descriptor (wcdr_pair_bitmap, - GC_WORD_LEN (scm_t_cell)); - -} - -void -scm_init_weaks () -{ - scm_c_define_gsubr ("%init-weaks-builtins", 0, 0, 0, - scm_init_weaks_builtins); -} - - -/* - Local Variables: - c-file-style: "gnu" - End: -*/ diff --git a/libguile/weaks.h b/libguile/weaks.h deleted file mode 100644 index fc16f8bf8..000000000 --- a/libguile/weaks.h +++ /dev/null @@ -1,101 +0,0 @@ -/* classes: h_files */ - -#ifndef SCM_WEAKS_H -#define SCM_WEAKS_H - -/* Copyright (C) 1995,1996,2000,2001, 2003, 2006, 2008, 2009, 2011 Free Software Foundation, Inc. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public License - * as published by the Free Software Foundation; either version 3 of - * the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA - * 02110-1301 USA - */ - - - -#include "libguile/__scm.h" - - - -#define SCM_WVECTF_WEAK_KEY 1 -#define SCM_WVECTF_WEAK_VALUE 2 - -#define SCM_WVECT_WEAK_KEY_P(x) (SCM_I_WVECT_EXTRA(x) & SCM_WVECTF_WEAK_KEY) -#define SCM_WVECT_WEAK_VALUE_P(x) (SCM_I_WVECT_EXTRA(x) & SCM_WVECTF_WEAK_VALUE) - -#define SCM_I_WVECT_TYPE(x) (SCM_I_WVECT_EXTRA(x) & 7) -#define SCM_I_SET_WVECT_TYPE(x,t) (SCM_I_SET_WVECT_EXTRA \ - ((x), (SCM_I_WVECT_EXTRA (x) & ~7) | (t))) -#define SCM_IS_WHVEC(X) (SCM_I_WVECT_TYPE (X) == 1) -#define SCM_IS_WHVEC_V(X) (SCM_I_WVECT_TYPE (X) == 2) -#define SCM_IS_WHVEC_B(X) (SCM_I_WVECT_TYPE (X) == 3) -#define SCM_IS_WHVEC_ANY(X) (SCM_I_WVECT_TYPE (X) != 0) - - -/* Weak pairs. */ - -SCM_INTERNAL SCM scm_weak_car_pair (SCM car, SCM cdr); -SCM_INTERNAL SCM scm_weak_cdr_pair (SCM car, SCM cdr); -SCM_INTERNAL SCM scm_doubly_weak_pair (SCM car, SCM cdr); - -/* Testing the weak component(s) of a cell for reachability. */ -#define SCM_WEAK_PAIR_WORD_DELETED_P(_cell, _word) \ - (SCM_UNPACK (SCM_CELL_OBJECT ((_cell), (_word))) == 0) -#define SCM_WEAK_PAIR_CAR_DELETED_P(_cell) \ - (SCM_WEAK_PAIR_WORD_DELETED_P ((_cell), 0)) -#define SCM_WEAK_PAIR_CDR_DELETED_P(_cell) \ - (SCM_WEAK_PAIR_WORD_DELETED_P ((_cell), 1)) - -#define SCM_WEAK_PAIR_DELETED_P(_cell) \ - ((SCM_WEAK_PAIR_CAR_DELETED_P (_cell)) \ - || (SCM_WEAK_PAIR_CDR_DELETED_P (_cell))) - -/* Accessing the components of a weak cell. These return `SCM_UNDEFINED' if - the car/cdr has been collected. */ -#define SCM_WEAK_PAIR_WORD(_cell, _word) \ - (SCM_WEAK_PAIR_WORD_DELETED_P ((_cell), (_word)) \ - ? SCM_UNDEFINED \ - : SCM_CELL_OBJECT ((_cell), (_word))) -#define SCM_WEAK_PAIR_CAR(_cell) (SCM_WEAK_PAIR_WORD ((_cell), 0)) -#define SCM_WEAK_PAIR_CDR(_cell) (SCM_WEAK_PAIR_WORD ((_cell), 1)) - - - -/* Weak vectors and weak hash tables. */ - -SCM_API SCM scm_make_weak_vector (SCM k, SCM fill); -SCM_API SCM scm_weak_vector (SCM l); -SCM_API SCM scm_weak_vector_p (SCM x); -SCM_API SCM scm_make_weak_key_alist_vector (SCM k); -SCM_API SCM scm_make_weak_value_alist_vector (SCM k); -SCM_API SCM scm_make_doubly_weak_alist_vector (SCM k); -SCM_API SCM scm_weak_key_alist_vector_p (SCM x); -SCM_API SCM scm_weak_value_alist_vector_p (SCM x); -SCM_API SCM scm_doubly_weak_alist_vector_p (SCM x); -SCM_INTERNAL SCM scm_init_weaks_builtins (void); -SCM_INTERNAL void scm_weaks_prehistory (void); -SCM_INTERNAL void scm_init_weaks (void); - -SCM_INTERNAL void scm_i_init_weak_vectors_for_gc (void); -SCM_INTERNAL void scm_i_mark_weak_vector (SCM w); -SCM_INTERNAL int scm_i_mark_weak_vectors_non_weaks (void); -SCM_INTERNAL void scm_i_remove_weaks_from_weak_vectors (void); - - -#endif /* SCM_WEAKS_H */ - -/* - Local Variables: - c-file-style: "gnu" - End: -*/ diff --git a/m4/gnulib-cache.m4 b/m4/gnulib-cache.m4 index cae4bb732..50102b260 100644 --- a/m4/gnulib-cache.m4 +++ b/m4/gnulib-cache.m4 @@ -70,6 +70,7 @@ gl_MODULES([ inet_pton isinf isnan + largefile ldexp lib-symbol-versions lib-symbol-visibility diff --git a/meta/Makefile.am b/meta/Makefile.am index bd2078409..c9d6a3fd7 100644 --- a/meta/Makefile.am +++ b/meta/Makefile.am @@ -24,7 +24,7 @@ bin_SCRIPTS = guile-config guild EXTRA_DIST= \ guile.m4 ChangeLog-2008 \ - guile-2.0.pc.in guile-2.0-uninstalled.pc.in \ + guile-2.2.pc.in guile-2.2-uninstalled.pc.in \ guild.in guile-config.in # What we now call `guild' used to be known as `guile-tools'. @@ -37,7 +37,7 @@ install-exec-hook: $(LN_S) "$$guild" "$$guile_tools" pkgconfigdir = $(libdir)/pkgconfig -pkgconfig_DATA = guile-2.0.pc +pkgconfig_DATA = guile-2.2.pc ## FIXME: in the future there will be direct automake support for ## doing this. When that happens, switch over. diff --git a/meta/guile-2.0-uninstalled.pc.in b/meta/guile-2.2-uninstalled.pc.in index e43fd3ae4..e43fd3ae4 100644 --- a/meta/guile-2.0-uninstalled.pc.in +++ b/meta/guile-2.2-uninstalled.pc.in diff --git a/meta/guile-2.0.pc.in b/meta/guile-2.2.pc.in index 1bda73449..1bda73449 100644 --- a/meta/guile-2.0.pc.in +++ b/meta/guile-2.2.pc.in diff --git a/meta/guile-config.in b/meta/guile-config.in index 0226f685e..b3e4c3d94 100755 --- a/meta/guile-config.in +++ b/meta/guile-config.in @@ -8,7 +8,7 @@ exec "@installed_guile@" -e main -s $0 "$@" ;;;; guile-config --- utility for linking programs with Guile ;;;; Jim Blandy <jim@red-bean.com> --- September 1997 ;;;; -;;;; Copyright (C) 1998, 2001, 2004, 2005, 2006, 2008, 2009 Free Software Foundation, Inc. +;;;; Copyright (C) 1998, 2001, 2004, 2005, 2006, 2008, 2009, 2011 Free Software Foundation, Inc. ;;;; ;;;; This library is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Lesser General Public @@ -77,7 +77,7 @@ exec "@installed_guile@" -e main -s $0 "$@" (dle " " p " --help - show usage info (this message)") (dle " " p " --help SUBCOMMAND - show help for SUBCOMMAND"))) -(define guile-module "guile-2.0") +(define guile-module "guile-2.2") (define (pkg-config . args) (let* ((real-args (cons %pkg-config-program args)) diff --git a/module/Makefile.am b/module/Makefile.am index 472bc4838..c070014bf 100644 --- a/module/Makefile.am +++ b/module/Makefile.am @@ -125,7 +125,8 @@ BYTECODE_LANG_SOURCES = \ language/bytecode/spec.scm OBJCODE_LANG_SOURCES = \ - language/objcode/spec.scm + language/objcode/spec.scm \ + language/objcode/elf.scm VALUE_LANG_SOURCES = \ language/value/spec.scm @@ -141,6 +142,7 @@ ECMASCRIPT_LANG_SOURCES = \ language/ecmascript/spec.scm ELISP_LANG_SOURCES = \ + language/elisp/falias.scm \ language/elisp/lexer.scm \ language/elisp/parser.scm \ language/elisp/bindings.scm \ @@ -148,8 +150,6 @@ ELISP_LANG_SOURCES = \ language/elisp/runtime.scm \ language/elisp/runtime/function-slot.scm \ language/elisp/runtime/value-slot.scm \ - language/elisp/runtime/macros.scm \ - language/elisp/runtime/subrs.scm \ language/elisp/spec.scm BRAINFUCK_LANG_SOURCES = \ @@ -191,7 +191,6 @@ SYSTEM_BASE_SOURCES = \ system/base/ck.scm ICE_9_SOURCES = \ - ice-9/r4rs.scm \ ice-9/r5rs.scm \ ice-9/deprecated.scm \ ice-9/and-let-star.scm \ @@ -219,6 +218,12 @@ ICE_9_SOURCES = \ ice-9/null.scm \ ice-9/occam-channel.scm \ ice-9/optargs.scm \ + ice-9/peg/simplify-tree.scm \ + ice-9/peg/codegen.scm \ + ice-9/peg/cache.scm \ + ice-9/peg/using-parsers.scm \ + ice-9/peg/string-peg.scm \ + ice-9/peg.scm \ ice-9/poe.scm \ ice-9/poll.scm \ ice-9/posix.scm \ @@ -339,6 +344,7 @@ OOP_SOURCES = \ SYSTEM_SOURCES = \ system/vm/inspect.scm \ system/vm/coverage.scm \ + system/vm/elf.scm \ system/vm/frame.scm \ system/vm/instruction.scm \ system/vm/objcode.scm \ @@ -386,6 +392,9 @@ WEB_SOURCES = \ EXTRA_DIST += oop/ChangeLog-2008 +ELISP_SOURCES = \ + language/elisp/boot.el + NOCOMP_SOURCES = \ ice-9/match.upstream.scm \ ice-9/psyntax.scm \ diff --git a/module/ice-9/boot-9.scm b/module/ice-9/boot-9.scm index 31d4523d5..5f42ef4dd 100644 --- a/module/ice-9/boot-9.scm +++ b/module/ice-9/boot-9.scm @@ -51,10 +51,12 @@ (define make-prompt-tag (lambda* (#:optional (stem "prompt")) - (gensym stem))) + ;; The only property that prompt tags need have is uniqueness in the + ;; sense of eq?. A one-element list will serve nicely. + (list stem))) (define default-prompt-tag - ;; not sure if we should expose this to the user as a fluid + ;; Redefined later to be a parameter. (let ((%default-prompt-tag (make-prompt-tag))) (lambda () %default-prompt-tag))) @@ -186,10 +188,105 @@ If there is no handler at all, Guile prints an error and then exits." -;;; {R4RS compliance} +;;; {Language primitives} ;;; -(primitive-load-path "ice-9/r4rs") +;; These are are the procedural wrappers around the primitives of +;; Guile's language: @apply, @call-with-current-continuation, etc. +;; +;; Usually, a call to a primitive is compiled specially. The compiler +;; knows about all these kinds of expressions. But the primitives may +;; be referenced not only as operators, but as values as well. These +;; stub procedures are the "values" of apply, dynamic-wind, and other +;; such primitives. +;; +(define (apply fun . args) + (@apply fun (apply:nconc2last args))) +(define (call-with-current-continuation proc) + (@call-with-current-continuation proc)) +(define (call-with-values producer consumer) + (@call-with-values producer consumer)) +(define (dynamic-wind in thunk out) + "All three arguments must be 0-argument procedures. +Guard @var{in} is called, then @var{thunk}, then +guard @var{out}. + +If, any time during the execution of @var{thunk}, the +continuation of the @code{dynamic_wind} expression is escaped +non-locally, @var{out} is called. If the continuation of +the dynamic-wind is re-entered, @var{in} is called. Thus +@var{in} and @var{out} may be called any number of +times. +@lisp + (define x 'normal-binding) +@result{} x + (define a-cont + (call-with-current-continuation + (lambda (escape) + (let ((old-x x)) + (dynamic-wind + ;; in-guard: + ;; + (lambda () (set! x 'special-binding)) + + ;; thunk + ;; + (lambda () (display x) (newline) + (call-with-current-continuation escape) + (display x) (newline) + x) + + ;; out-guard: + ;; + (lambda () (set! x old-x))))))) + +;; Prints: +special-binding +;; Evaluates to: +@result{} a-cont +x +@result{} normal-binding + (a-cont #f) +;; Prints: +special-binding +;; Evaluates to: +@result{} a-cont ;; the value of the (define a-cont...) +x +@result{} normal-binding +a-cont +@result{} special-binding +@end lisp" + (@dynamic-wind in (thunk) out)) + + + +;;; {Low-Level Port Code} +;;; + +;; These are used to request the proper mode to open files in. +;; +(define OPEN_READ "r") +(define OPEN_WRITE "w") +(define OPEN_BOTH "r+") + +(define *null-device* "/dev/null") + +(define (open-input-file str) + "Takes a string naming an existing file and returns an input port +capable of delivering characters from the file. If the file +cannot be opened, an error is signalled." + (open-file str OPEN_READ)) + +(define (open-output-file str) + "Takes a string naming an output file to be created and returns an +output port capable of writing characters to a new file by that +name. If the file cannot be opened, an error is signalled. If a +file with the given name already exists, the effect is unspecified." + (open-file str OPEN_WRITE)) + +(define (open-io-file str) + "Open file with name STR for both input and output." + (open-file str OPEN_BOTH)) @@ -218,13 +315,11 @@ If there is no handler at all, Guile prints an error and then exits." (define current-warning-port current-error-port) (define (warn . stuff) - (with-output-to-port (current-warning-port) - (lambda () - (newline) - (display ";;; WARNING ") - (display stuff) - (newline) - (car (last-pair stuff))))) + (newline (current-warning-port)) + (display ";;; WARNING " (current-warning-port)) + (display stuff (current-warning-port)) + (newline (current-warning-port)) + (car (last-pair stuff))) @@ -963,15 +1058,11 @@ VALUE." ;; properties within the object itself. (define (make-object-property) - (define-syntax-rule (with-mutex lock exp) - (dynamic-wind (lambda () (lock-mutex lock)) - (lambda () exp) - (lambda () (unlock-mutex lock)))) - (let ((prop (make-weak-key-hash-table)) - (lock (make-mutex))) + ;; Weak tables are thread-safe. + (let ((prop (make-weak-key-hash-table))) (make-procedure-with-setter - (lambda (obj) (with-mutex lock (hashq-ref prop obj))) - (lambda (obj val) (with-mutex lock (hashq-set! prop obj val)))))) + (lambda (obj) (hashq-ref prop obj)) + (lambda (obj val) (hashq-set! prop obj val))))) @@ -1187,6 +1278,281 @@ VALUE." (provide 'record) + + +;;; {Parameters} +;;; + +(define <parameter> + ;; Three fields: the procedure itself, the fluid, and the converter. + (make-struct <applicable-struct-vtable> 0 'pwprpr)) +(set-struct-vtable-name! <parameter> '<parameter>) + +(define* (make-parameter init #:optional (conv (lambda (x) x))) + "Make a new parameter. + +A parameter is a dynamically bound value, accessed through a procedure. +To access the current value, apply the procedure with no arguments: + + (define p (make-parameter 10)) + (p) => 10 + +To provide a new value for the parameter in a dynamic extent, use +`parameterize': + + (parameterize ((p 20)) + (p)) => 20 + (p) => 10 + +The value outside of the dynamic extent of the body is unaffected. To +update the current value, apply it to one argument: + + (p 20) => 10 + (p) => 20 + +As you can see, the call that updates a parameter returns its previous +value. + +All values for the parameter are first run through the CONV procedure, +including INIT, the initial value. The default CONV procedure is the +identity procedure. CONV is commonly used to ensure some set of +invariants on the values that a parameter may have." + (let ((fluid (make-fluid (conv init)))) + (make-struct <parameter> 0 + (case-lambda + (() (fluid-ref fluid)) + ((x) (let ((prev (fluid-ref fluid))) + (fluid-set! fluid (conv x)) + prev))) + fluid conv))) + +(define (parameter? x) + (and (struct? x) (eq? (struct-vtable x) <parameter>))) + +(define (parameter-fluid p) + (if (parameter? p) + (struct-ref p 1) + (scm-error 'wrong-type-arg "parameter-fluid" + "Not a parameter: ~S" (list p) #f))) + +(define (parameter-converter p) + (if (parameter? p) + (struct-ref p 2) + (scm-error 'wrong-type-arg "parameter-fluid" + "Not a parameter: ~S" (list p) #f))) + +(define-syntax parameterize + (lambda (x) + (syntax-case x () + ((_ ((param value) ...) body body* ...) + (with-syntax (((p ...) (generate-temporaries #'(param ...)))) + #'(let ((p param) ...) + (if (not (parameter? p)) + (scm-error 'wrong-type-arg "parameterize" + "Not a parameter: ~S" (list p) #f)) + ... + (with-fluids (((struct-ref p 1) ((struct-ref p 2) value)) + ...) + body body* ...))))))) + +(define* (fluid->parameter fluid #:optional (conv (lambda (x) x))) + "Make a parameter that wraps a fluid. + +The value of the parameter will be the same as the value of the fluid. +If the parameter is rebound in some dynamic extent, perhaps via +`parameterize', the new value will be run through the optional CONV +procedure, as with any parameter. Note that unlike `make-parameter', +CONV is not applied to the initial value." + (make-struct <parameter> 0 + (case-lambda + (() (fluid-ref fluid)) + ((x) (let ((prev (fluid-ref fluid))) + (fluid-set! fluid (conv x)) + prev))) + fluid conv)) + + + +;;; Once parameters have booted, define the default prompt tag as being +;;; a parameter. +;;; + +(set! default-prompt-tag (make-parameter (default-prompt-tag))) + + + +;;; Current ports as parameters. +;;; + +(let () + (define-syntax-rule (port-parameterize! binding fluid predicate msg) + (begin + (set! binding (fluid->parameter (module-ref (current-module) 'fluid) + (lambda (x) + (if (predicate x) x + (error msg x))))) + (hashq-remove! (%get-pre-modules-obarray) 'fluid))) + + (port-parameterize! current-input-port %current-input-port-fluid + input-port? "expected an input port") + (port-parameterize! current-output-port %current-output-port-fluid + output-port? "expected an output port") + (port-parameterize! current-error-port %current-error-port-fluid + output-port? "expected an output port")) + + + +;;; {Warnings} +;;; + +(define current-warning-port + (make-parameter (current-error-port) + (lambda (x) + (if (output-port? x) + x + (error "expected an output port" x))))) + + + + +;;; {Languages} +;;; + +;; The language can be a symbolic name or a <language> object from +;; (system base language). +;; +(define current-language (make-parameter 'scheme)) + + + + +;;; {High-Level Port Routines} +;;; + +(define (call-with-input-file str proc) + "PROC should be a procedure of one argument, and STR should be a +string naming a file. The file must already exist. These procedures +call PROC with one argument: the port obtained by opening the named file +for input or output. If the file cannot be opened, an error is +signalled. If the procedure returns, then the port is closed +automatically and the values yielded by the procedure are returned. If +the procedure does not return, then the port will not be closed +automatically unless it is possible to prove that the port will never +again be used for a read or write operation." + (let ((p (open-input-file str))) + (call-with-values + (lambda () (proc p)) + (lambda vals + (close-input-port p) + (apply values vals))))) + +(define (call-with-output-file str proc) + "PROC should be a procedure of one argument, and STR should be a +string naming a file. The behaviour is unspecified if the file +already exists. These procedures call PROC +with one argument: the port obtained by opening the named file for +input or output. If the file cannot be opened, an error is +signalled. If the procedure returns, then the port is closed +automatically and the values yielded by the procedure are returned. +If the procedure does not return, then the port will not be closed +automatically unless it is possible to prove that the port will +never again be used for a read or write operation." + (let ((p (open-output-file str))) + (call-with-values + (lambda () (proc p)) + (lambda vals + (close-output-port p) + (apply values vals))))) + +(define (with-input-from-port port thunk) + (parameterize ((current-input-port port)) + (thunk))) + +(define (with-output-to-port port thunk) + (parameterize ((current-output-port port)) + (thunk))) + +(define (with-error-to-port port thunk) + (parameterize ((current-error-port port)) + (thunk))) + +(define (with-input-from-file file thunk) + "THUNK must be a procedure of no arguments, and FILE must be a +string naming a file. The file must already exist. The file is opened for +input, an input port connected to it is made +the default value returned by `current-input-port', +and the THUNK is called with no arguments. +When the THUNK returns, the port is closed and the previous +default is restored. Returns the values yielded by THUNK. If an +escape procedure is used to escape from the continuation of these +procedures, their behavior is implementation dependent." + (call-with-input-file file + (lambda (p) (with-input-from-port p thunk)))) + +(define (with-output-to-file file thunk) + "THUNK must be a procedure of no arguments, and FILE must be a +string naming a file. The effect is unspecified if the file already exists. +The file is opened for output, an output port connected to it is made +the default value returned by `current-output-port', +and the THUNK is called with no arguments. +When the THUNK returns, the port is closed and the previous +default is restored. Returns the values yielded by THUNK. If an +escape procedure is used to escape from the continuation of these +procedures, their behavior is implementation dependent." + (call-with-output-file file + (lambda (p) (with-output-to-port p thunk)))) + +(define (with-error-to-file file thunk) + "THUNK must be a procedure of no arguments, and FILE must be a +string naming a file. The effect is unspecified if the file already exists. +The file is opened for output, an output port connected to it is made +the default value returned by `current-error-port', +and the THUNK is called with no arguments. +When the THUNK returns, the port is closed and the previous +default is restored. Returns the values yielded by THUNK. If an +escape procedure is used to escape from the continuation of these +procedures, their behavior is implementation dependent." + (call-with-output-file file + (lambda (p) (with-error-to-port p thunk)))) + +(define (call-with-input-string string proc) + "Calls the one-argument procedure @var{proc} with a newly created +input port from which @var{string}'s contents may be read. The value +yielded by the @var{proc} is returned." + (proc (open-input-string string))) + +(define (with-input-from-string string thunk) + "THUNK must be a procedure of no arguments. +The test of STRING is opened for +input, an input port connected to it is made, +and the THUNK is called with no arguments. +When the THUNK returns, the port is closed. +Returns the values yielded by THUNK. If an +escape procedure is used to escape from the continuation of these +procedures, their behavior is implementation dependent." + (call-with-input-string string + (lambda (p) (with-input-from-port p thunk)))) + +(define (call-with-output-string proc) + "Calls the one-argument procedure @var{proc} with a newly created output +port. When the function returns, the string composed of the characters +written into the port is returned." + (let ((port (open-output-string))) + (proc port) + (get-output-string port))) + +(define (with-output-to-string thunk) + "Calls THUNK and returns its output as a string." + (call-with-output-string + (lambda (p) (with-output-to-port p thunk)))) + +(define (with-error-to-string thunk) + "Calls THUNK and returns its error output as a string." + (call-with-output-string + (lambda (p) (with-error-to-port p thunk)))) + +(define the-eof-object (call-with-input-string "" (lambda (p) (read-char p)))) + ;;; {Booleans} @@ -1236,7 +1602,7 @@ VALUE." (lambda (str) (->bool (stat str #f))) (lambda (str) - (let ((port (catch 'system-error (lambda () (open-file str OPEN_READ)) + (let ((port (catch 'system-error (lambda () (open-input-file str)) (lambda args #f)))) (if port (begin (close-port port) #t) #f))))) @@ -1247,8 +1613,8 @@ VALUE." (eq? (stat:type (stat str)) 'directory)) (lambda (str) (let ((port (catch 'system-error - (lambda () (open-file (string-append str "/.") - OPEN_READ)) + (lambda () + (open-input-file (string-append str "/."))) (lambda args #f)))) (if port (begin (close-port port) #t) #f))))) @@ -1624,7 +1990,7 @@ VALUE." ((define-record-type (lambda (x) (define (make-id scope . fragments) - (datum->syntax #'scope + (datum->syntax scope (apply symbol-append (map (lambda (x) (if (symbol? x) x (syntax->datum x))) @@ -1759,10 +2125,6 @@ VALUE." ;; initial uses list, or binding procedure. ;; (define* (make-module #:optional (size 31) (uses '()) (binder #f)) - (define %default-import-size - ;; Typical number of imported bindings actually used by a module. - 600) - (if (not (integer? size)) (error "Illegal size to make-module." size)) (if (not (and (list? uses) @@ -1775,7 +2137,7 @@ VALUE." (module-constructor (make-hash-table size) uses binder #f macroexpand #f #f #f - (make-hash-table %default-import-size) + (make-hash-table) '() (make-weak-key-hash-table 31) #f (make-hash-table 7) #f #f #f)) @@ -2093,33 +2455,6 @@ VALUE." (define (module-define-submodule! module name submodule) (hashq-set! (module-submodules module) name submodule)) -;; It used to be, however, that module names were also present in the -;; value namespace. When we enable deprecated code, we preserve this -;; legacy behavior. -;; -;; These shims are defined here instead of in deprecated.scm because we -;; need their definitions before loading other modules. -;; -(begin-deprecated - (define (module-ref-submodule module name) - (or (hashq-ref (module-submodules module) name) - (and (module-submodule-binder module) - ((module-submodule-binder module) module name)) - (let ((var (module-local-variable module name))) - (and var (variable-bound? var) (module? (variable-ref var)) - (begin - (warn "module" module "not in submodules table") - (variable-ref var)))))) - - (define (module-define-submodule! module name submodule) - (let ((var (module-local-variable module name))) - (if (and var - (or (not (variable-bound? var)) - (not (module? (variable-ref var))))) - (warn "defining module" module ": not overriding local definition" var) - (module-define! module name submodule))) - (hashq-set! (module-submodules module) name submodule))) - ;;; {Module-based Loading} @@ -2920,145 +3255,6 @@ but it fails to load." -;;; {Parameters} -;;; - -(define <parameter> - ;; Three fields: the procedure itself, the fluid, and the converter. - (make-struct <applicable-struct-vtable> 0 'pwprpr)) -(set-struct-vtable-name! <parameter> '<parameter>) - -(define* (make-parameter init #:optional (conv (lambda (x) x))) - "Make a new parameter. - -A parameter is a dynamically bound value, accessed through a procedure. -To access the current value, apply the procedure with no arguments: - - (define p (make-parameter 10)) - (p) => 10 - -To provide a new value for the parameter in a dynamic extent, use -`parameterize': - - (parameterize ((p 20)) - (p)) => 20 - (p) => 10 - -The value outside of the dynamic extent of the body is unaffected. To -update the current value, apply it to one argument: - - (p 20) => 10 - (p) => 20 - -As you can see, the call that updates a parameter returns its previous -value. - -All values for the parameter are first run through the CONV procedure, -including INIT, the initial value. The default CONV procedure is the -identity procedure. CONV is commonly used to ensure some set of -invariants on the values that a parameter may have." - (let ((fluid (make-fluid (conv init)))) - (make-struct <parameter> 0 - (case-lambda - (() (fluid-ref fluid)) - ((x) (let ((prev (fluid-ref fluid))) - (fluid-set! fluid (conv x)) - prev))) - fluid conv))) - -(define* (fluid->parameter fluid #:optional (conv (lambda (x) x))) - "Make a parameter that wraps a fluid. - -The value of the parameter will be the same as the value of the fluid. -If the parameter is rebound in some dynamic extent, perhaps via -`parameterize', the new value will be run through the optional CONV -procedure, as with any parameter. Note that unlike `make-parameter', -CONV is not applied to the initial value." - (make-struct <parameter> 0 - (case-lambda - (() (fluid-ref fluid)) - ((x) (let ((prev (fluid-ref fluid))) - (fluid-set! fluid (conv x)) - prev))) - fluid conv)) - -(define (parameter? x) - (and (struct? x) (eq? (struct-vtable x) <parameter>))) - -(define (parameter-fluid p) - (if (parameter? p) - (struct-ref p 1) - (scm-error 'wrong-type-arg "parameter-fluid" - "Not a parameter: ~S" (list p) #f))) - -(define (parameter-converter p) - (if (parameter? p) - (struct-ref p 2) - (scm-error 'wrong-type-arg "parameter-fluid" - "Not a parameter: ~S" (list p) #f))) - -(define-syntax parameterize - (lambda (x) - (syntax-case x () - ((_ ((param value) ...) body body* ...) - (with-syntax (((p ...) (generate-temporaries #'(param ...)))) - #'(let ((p param) ...) - (if (not (parameter? p)) - (scm-error 'wrong-type-arg "parameterize" - "Not a parameter: ~S" (list p) #f)) - ... - (with-fluids (((struct-ref p 1) ((struct-ref p 2) value)) - ...) - body body* ...))))))) - - -;;; -;;; Current ports as parameters. -;;; - -(let () - (define-syntax-rule (port-parameterize! binding fluid predicate msg) - (begin - (set! binding (fluid->parameter (module-ref (current-module) 'fluid) - (lambda (x) - (if (predicate x) x - (error msg x))))) - (module-remove! (current-module) 'fluid))) - - (port-parameterize! current-input-port %current-input-port-fluid - input-port? "expected an input port") - (port-parameterize! current-output-port %current-output-port-fluid - output-port? "expected an output port") - (port-parameterize! current-error-port %current-error-port-fluid - output-port? "expected an output port")) - - - -;;; -;;; Warnings. -;;; - -(define current-warning-port - (make-parameter (current-error-port) - (lambda (x) - (if (output-port? x) - x - (error "expected an output port" x))))) - - - -;;; -;;; Languages. -;;; - -;; The language can be a symbolic name or a <language> object from -;; (system base language). -;; -(define current-language (make-parameter 'scheme)) - - - - ;;; {Running Repls} ;;; @@ -3369,13 +3565,6 @@ CONV is not applied to the initial value." (process-use-modules (list quoted-args ...)) *unspecified*)))))) -(define-syntax-rule (use-syntax spec ...) - (begin - (eval-when (eval load compile expand) - (issue-deprecation-warning - "`use-syntax' is deprecated. Please contact guile-devel for more info.")) - (use-modules spec ...))) - (include-from-path "ice-9/r6rs-libraries") (define-syntax-rule (define-private foo bar) @@ -3831,6 +4020,7 @@ reading PATH with READER." ;; Adjust the above comment when changing this. '(guile guile-2 + guile-2.2 r5rs srfi-0 ;; cond-expand itself srfi-4 ;; homogenous numeric vectors diff --git a/module/ice-9/deprecated.scm b/module/ice-9/deprecated.scm index 56b9c0495..9835c1230 100644 --- a/module/ice-9/deprecated.scm +++ b/module/ice-9/deprecated.scm @@ -16,893 +16,4 @@ ;;;; (define-module (ice-9 deprecated) - #:export (substring-move-left! substring-move-right! - dynamic-maybe-call dynamic-maybe-link - try-module-linked try-module-dynamic-link - list* feature? eval-case unmemoize-expr - $asinh - $acosh - $atanh - $sqrt - $abs - $exp - $expt - $log - $sin - $cos - $tan - $asin - $acos - $atan - $sinh - $cosh - $tanh - closure? - %nil - @bind - bad-throw - error-catching-loop - error-catching-repl - scm-style-repl - apply-to-args - has-suffix? - scheme-file-suffix - get-option - for-next-option - display-usage-report - transform-usage-lambda - collect - assert-repl-silence - assert-repl-print-unspecified - assert-repl-verbosity - set-repl-prompt! - set-batch-mode?! - repl - pre-unwind-handler-dispatch - default-pre-unwind-handler - handle-system-error - stack-saved? - the-last-stack - save-stack - named-module-use! - top-repl - turn-on-debugging - read-hash-procedures - process-define-module - fluid-let-syntax - set-system-module! - char-code-limit - generalized-vector? - generalized-vector-length - generalized-vector-ref - generalized-vector-set! - generalized-vector->list)) - - -;;;; Deprecated definitions. - -(define substring-move-left! - (lambda args - (issue-deprecation-warning - "`substring-move-left!' is deprecated. Use `substring-move!' instead.") - (apply substring-move! args))) -(define substring-move-right! - (lambda args - (issue-deprecation-warning - "`substring-move-right!' is deprecated. Use `substring-move!' instead.") - (apply substring-move! args))) - - - -;; This method of dynamically linking Guile Extensions is deprecated. -;; Use `load-extension' explicitly from Scheme code instead. - -(define (split-c-module-name str) - (let loop ((rev '()) - (start 0) - (pos 0) - (end (string-length str))) - (cond - ((= pos end) - (reverse (cons (string->symbol (substring str start pos)) rev))) - ((eq? (string-ref str pos) #\space) - (loop (cons (string->symbol (substring str start pos)) rev) - (+ pos 1) - (+ pos 1) - end)) - (else - (loop rev start (+ pos 1) end))))) - -(define (convert-c-registered-modules dynobj) - (let ((res (map (lambda (c) - (list (split-c-module-name (car c)) (cdr c) dynobj)) - (c-registered-modules)))) - (c-clear-registered-modules) - res)) - -(define registered-modules '()) - -(define (register-modules dynobj) - (set! registered-modules - (append! (convert-c-registered-modules dynobj) - registered-modules))) - -(define (warn-autoload-deprecation modname) - (issue-deprecation-warning - "Autoloading of compiled code modules is deprecated." - "Write a Scheme file instead that uses `load-extension'.") - (issue-deprecation-warning - (simple-format #f "(You just autoloaded module ~S.)" modname))) - -(define (init-dynamic-module modname) - ;; Register any linked modules which have been registered on the C level - (register-modules #f) - (or-map (lambda (modinfo) - (if (equal? (car modinfo) modname) - (begin - (warn-autoload-deprecation modname) - (set! registered-modules (delq! modinfo registered-modules)) - (let ((mod (resolve-module modname #f))) - (save-module-excursion - (lambda () - (set-current-module mod) - (set-module-public-interface! mod mod) - (dynamic-call (cadr modinfo) (caddr modinfo)) - )) - #t)) - #f)) - registered-modules)) - -(define (dynamic-maybe-call name dynobj) - (issue-deprecation-warning - "`dynamic-maybe-call' is deprecated. " - "Wrap `dynamic-call' in a `false-if-exception' yourself.") - (false-if-exception (dynamic-call name dynobj))) - - -(define (dynamic-maybe-link filename) - (issue-deprecation-warning - "`dynamic-maybe-link' is deprecated. " - "Wrap `dynamic-link' in a `false-if-exception' yourself.") - (false-if-exception (dynamic-link filename))) - -(define (find-and-link-dynamic-module module-name) - (define (make-init-name mod-name) - (string-append "scm_init" - (list->string (map (lambda (c) - (if (or (char-alphabetic? c) - (char-numeric? c)) - c - #\_)) - (string->list mod-name))) - "_module")) - - ;; Put the subdirectory for this module in the car of SUBDIR-AND-LIBNAME, - ;; and the `libname' (the name of the module prepended by `lib') in the cdr - ;; field. For example, if MODULE-NAME is the list (inet tcp-ip udp), then - ;; SUBDIR-AND-LIBNAME will be the pair ("inet/tcp-ip" . "libudp"). - (let ((subdir-and-libname - (let loop ((dirs "") - (syms module-name)) - (if (null? (cdr syms)) - (cons dirs (string-append "lib" (symbol->string (car syms)))) - (loop (string-append dirs (symbol->string (car syms)) "/") - (cdr syms))))) - (init (make-init-name (apply string-append - (map (lambda (s) - (string-append "_" - (symbol->string s))) - module-name))))) - (let ((subdir (car subdir-and-libname)) - (libname (cdr subdir-and-libname))) - - ;; Now look in each dir in %LOAD-PATH for `subdir/libfoo.la'. If that - ;; file exists, fetch the dlname from that file and attempt to link - ;; against it. If `subdir/libfoo.la' does not exist, or does not seem - ;; to name any shared library, look for `subdir/libfoo.so' instead and - ;; link against that. - (let check-dirs ((dir-list %load-path)) - (if (null? dir-list) - #f - (let* ((dir (in-vicinity (car dir-list) subdir)) - (sharlib-full - (or (try-using-libtool-name dir libname) - (try-using-sharlib-name dir libname)))) - (if (and sharlib-full (file-exists? sharlib-full)) - (link-dynamic-module sharlib-full init) - (check-dirs (cdr dir-list))))))))) - -(define (try-using-libtool-name libdir libname) - (let ((libtool-filename (in-vicinity libdir - (string-append libname ".la")))) - (and (file-exists? libtool-filename) - libtool-filename))) - -(define (try-using-sharlib-name libdir libname) - (in-vicinity libdir (string-append libname ".so"))) - -(define (link-dynamic-module filename initname) - ;; Register any linked modules which have been registered on the C level - (register-modules #f) - (let ((dynobj (dynamic-link filename))) - (dynamic-call initname dynobj) - (register-modules dynobj))) - -(define (try-module-linked module-name) - (issue-deprecation-warning - "`try-module-linked' is deprecated." - "See the manual for how more on C extensions.") - (init-dynamic-module module-name)) - -(define (try-module-dynamic-link module-name) - (issue-deprecation-warning - "`try-module-dynamic-link' is deprecated." - "See the manual for how more on C extensions.") - (and (find-and-link-dynamic-module module-name) - (init-dynamic-module module-name))) - - -(define (list* . args) - (issue-deprecation-warning "'list*' is deprecated. Use 'cons*' instead.") - (apply cons* args)) - -(define (feature? sym) - (issue-deprecation-warning - "`feature?' is deprecated. Use `provided?' instead.") - (provided? sym)) - -(define-macro (eval-case . clauses) - (issue-deprecation-warning - "`eval-case' is deprecated. Use `eval-when' instead.") - ;; Practically speaking, eval-case only had load-toplevel and else as - ;; conditions. - (cond - ((assoc-ref clauses '(load-toplevel)) - => (lambda (exps) - ;; the *unspecified so that non-toplevel definitions will be - ;; caught - `(begin *unspecified* . ,exps))) - ((assoc-ref clauses 'else) - => (lambda (exps) - `(begin *unspecified* . ,exps))) - (else - `(begin)))) - -;; The strange prototype system for uniform arrays has been -;; deprecated. -(read-hash-extend - #\y - (lambda (c port) - (issue-deprecation-warning - "The `#y' bytevector syntax is deprecated. Use `#s8' instead.") - (let ((x (read port))) - (cond - ((list? x) (list->s8vector x)) - (else (error "#y needs to be followed by a list" x)))))) - -(define (unmemoize-expr . args) - (issue-deprecation-warning - "`unmemoize-expr' is deprecated. Use `unmemoize-expression' instead.") - (apply unmemoize-expression args)) - -(define ($asinh z) - (issue-deprecation-warning - "`$asinh' is deprecated. Use `asinh' instead.") - (asinh z)) -(define ($acosh z) - (issue-deprecation-warning - "`$acosh' is deprecated. Use `acosh' instead.") - (acosh z)) -(define ($atanh z) - (issue-deprecation-warning - "`$atanh' is deprecated. Use `atanh' instead.") - (atanh z)) -(define ($sqrt z) - (issue-deprecation-warning - "`$sqrt' is deprecated. Use `sqrt' instead.") - (sqrt z)) -(define ($abs z) - (issue-deprecation-warning - "`$abs' is deprecated. Use `abs' instead.") - (abs z)) -(define ($exp z) - (issue-deprecation-warning - "`$exp' is deprecated. Use `exp' instead.") - (exp z)) -(define ($expt z1 z2) - (issue-deprecation-warning - "`$expt' is deprecated. Use `expt' instead.") - (expt z1 z2)) -(define ($log z) - (issue-deprecation-warning - "`$log' is deprecated. Use `log' instead.") - (log z)) -(define ($sin z) - (issue-deprecation-warning - "`$sin' is deprecated. Use `sin' instead.") - (sin z)) -(define ($cos z) - (issue-deprecation-warning - "`$cos' is deprecated. Use `cos' instead.") - (cos z)) -(define ($tan z) - (issue-deprecation-warning - "`$tan' is deprecated. Use `tan' instead.") - (tan z)) -(define ($asin z) - (issue-deprecation-warning - "`$asin' is deprecated. Use `asin' instead.") - (asin z)) -(define ($acos z) - (issue-deprecation-warning - "`$acos' is deprecated. Use `acos' instead.") - (acos z)) -(define ($atan z) - (issue-deprecation-warning - "`$atan' is deprecated. Use `atan' instead.") - (atan z)) -(define ($sinh z) - (issue-deprecation-warning - "`$sinh' is deprecated. Use `sinh' instead.") - (sinh z)) -(define ($cosh z) - (issue-deprecation-warning - "`$cosh' is deprecated. Use `cosh' instead.") - (cosh z)) -(define ($tanh z) - (issue-deprecation-warning - "`$tanh' is deprecated. Use `tanh' instead.") - (tanh z)) - -(define (closure? x) - (issue-deprecation-warning - "`closure?' is deprecated. Use `procedure?' instead.") - (procedure? x)) - -(define %nil #nil) - -;;; @bind is used by the old elisp code as a dynamic scoping mechanism. -;;; Please let the Guile developers know if you are using this macro. -;;; -(define-syntax @bind - (lambda (x) - (define (bound-member id ids) - (cond ((null? ids) #f) - ((bound-identifier=? id (car ids)) #t) - ((bound-member (car ids) (cdr ids))))) - - (issue-deprecation-warning - "`@bind' is deprecated. Use `with-fluids' instead.") - - (syntax-case x () - ((_ () b0 b1 ...) - #'(let () b0 b1 ...)) - ((_ ((id val) ...) b0 b1 ...) - (and-map identifier? #'(id ...)) - (if (let lp ((ids #'(id ...))) - (cond ((null? ids) #f) - ((bound-member (car ids) (cdr ids)) #t) - (else (lp (cdr ids))))) - (syntax-violation '@bind "duplicate bound identifier" x) - (with-syntax (((old-v ...) (generate-temporaries #'(id ...))) - ((v ...) (generate-temporaries #'(id ...)))) - #'(let ((old-v id) ... - (v val) ...) - (dynamic-wind - (lambda () - (set! id v) ...) - (lambda () b0 b1 ...) - (lambda () - (set! id old-v) ...))))))))) - -;; There are deprecated definitions for module-ref-submodule and -;; module-define-submodule! in boot-9.scm. - -;; Define (%app) and (%app modules), and have (app) alias (%app). This -;; side-effects the-root-module, both to the submodules table and (through -;; module-define-submodule! above) the obarray. -;; -(let ((%app (make-module 31))) - (set-module-name! %app '(%app)) - (module-define-submodule! the-root-module '%app %app) - (module-define-submodule! the-root-module 'app %app) - (module-define-submodule! %app 'modules (resolve-module '() #f))) - -;; Allow code that poked %module-public-interface to keep on working. -;; -(set! module-public-interface - (let ((getter module-public-interface)) - (lambda (mod) - (or (getter mod) - (cond - ((and=> (module-local-variable mod '%module-public-interface) - variable-ref) - => (lambda (iface) - (issue-deprecation-warning -"Setting a module's public interface via munging %module-public-interface is -deprecated. Use set-module-public-interface! instead.") - (set-module-public-interface! mod iface) - iface)) - (else #f)))))) - -(set! set-module-public-interface! - (let ((setter set-module-public-interface!)) - (lambda (mod iface) - (setter mod iface) - (module-define! mod '%module-public-interface iface)))) - -(define (bad-throw key . args) - (issue-deprecation-warning - "`bad-throw' in the default environment is deprecated. -Find it in the `(ice-9 scm-style-repl)' module instead.") - (apply (@ (ice-9 scm-style-repl) bad-throw) key args)) - -(define (error-catching-loop thunk) - (issue-deprecation-warning - "`error-catching-loop' in the default environment is deprecated. -Find it in the `(ice-9 scm-style-repl)' module instead.") - ((@ (ice-9 scm-style-repl) error-catching-loop) thunk)) - -(define (error-catching-repl r e p) - (issue-deprecation-warning - "`error-catching-repl' in the default environment is deprecated. -Find it in the `(ice-9 scm-style-repl)' module instead.") - ((@ (ice-9 scm-style-repl) error-catching-repl) r e p)) - -(define (scm-style-repl) - (issue-deprecation-warning - "`scm-style-repl' in the default environment is deprecated. -Find it in the `(ice-9 scm-style-repl)' module instead, or -better yet, use the repl from `(system repl repl)'.") - ((@ (ice-9 scm-style-repl) scm-style-repl))) - - -;;; Apply-to-args had the following comment attached to it in boot-9, but it's -;;; wrong-headed: in the mentioned case, a point should either be a record or -;;; multiple values. -;;; -;;; apply-to-args is functionally redundant with apply and, worse, -;;; is less general than apply since it only takes two arguments. -;;; -;;; On the other hand, apply-to-args is a syntacticly convenient way to -;;; perform binding in many circumstances when the "let" family of -;;; of forms don't cut it. E.g.: -;;; -;;; (apply-to-args (return-3d-mouse-coords) -;;; (lambda (x y z) -;;; ...)) -;;; - -(define (apply-to-args args fn) - (issue-deprecation-warning - "`apply-to-args' is deprecated. Include a local copy in your program.") - (apply fn args)) - -(define (has-suffix? str suffix) - (issue-deprecation-warning - "`has-suffix?' is deprecated. Use `string-suffix?' instead (args reversed).") - (string-suffix? suffix str)) - -(define scheme-file-suffix - (lambda () - (issue-deprecation-warning - "`scheme-file-suffix' is deprecated. Use `%load-extensions' instead.") - ".scm")) - - - -;;; {Command Line Options} -;;; - -(define (get-option argv kw-opts kw-args return) - (issue-deprecation-warning - "`get-option' is deprecated. Use `(ice-9 getopt-long)' instead.") - (cond - ((null? argv) - (return #f #f argv)) - - ((or (not (eq? #\- (string-ref (car argv) 0))) - (eq? (string-length (car argv)) 1)) - (return 'normal-arg (car argv) (cdr argv))) - - ((eq? #\- (string-ref (car argv) 1)) - (let* ((kw-arg-pos (or (string-index (car argv) #\=) - (string-length (car argv)))) - (kw (symbol->keyword (substring (car argv) 2 kw-arg-pos))) - (kw-opt? (member kw kw-opts)) - (kw-arg? (member kw kw-args)) - (arg (or (and (not (eq? kw-arg-pos (string-length (car argv)))) - (substring (car argv) - (+ kw-arg-pos 1) - (string-length (car argv)))) - (and kw-arg? - (begin (set! argv (cdr argv)) (car argv)))))) - (if (or kw-opt? kw-arg?) - (return kw arg (cdr argv)) - (return 'usage-error kw (cdr argv))))) - - (else - (let* ((char (substring (car argv) 1 2)) - (kw (symbol->keyword char))) - (cond - - ((member kw kw-opts) - (let* ((rest-car (substring (car argv) 2 (string-length (car argv)))) - (new-argv (if (= 0 (string-length rest-car)) - (cdr argv) - (cons (string-append "-" rest-car) (cdr argv))))) - (return kw #f new-argv))) - - ((member kw kw-args) - (let* ((rest-car (substring (car argv) 2 (string-length (car argv)))) - (arg (if (= 0 (string-length rest-car)) - (cadr argv) - rest-car)) - (new-argv (if (= 0 (string-length rest-car)) - (cddr argv) - (cdr argv)))) - (return kw arg new-argv))) - - (else (return 'usage-error kw argv))))))) - -(define (for-next-option proc argv kw-opts kw-args) - (issue-deprecation-warning - "`for-next-option' is deprecated. Use `(ice-9 getopt-long)' instead.") - (let loop ((argv argv)) - (get-option argv kw-opts kw-args - (lambda (opt opt-arg argv) - (and opt (proc opt opt-arg argv loop)))))) - -(define (display-usage-report kw-desc) - (issue-deprecation-warning - "`display-usage-report' is deprecated. Use `(ice-9 getopt-long)' instead.") - (for-each - (lambda (kw) - (or (eq? (car kw) #t) - (eq? (car kw) 'else) - (let* ((opt-desc kw) - (help (cadr opt-desc)) - (opts (car opt-desc)) - (opts-proper (if (string? (car opts)) (cdr opts) opts)) - (arg-name (if (string? (car opts)) - (string-append "<" (car opts) ">") - "")) - (left-part (string-append - (with-output-to-string - (lambda () - (map (lambda (x) (display (keyword->symbol x)) (display " ")) - opts-proper))) - arg-name)) - (middle-part (if (and (< (string-length left-part) 30) - (< (string-length help) 40)) - (make-string (- 30 (string-length left-part)) #\ ) - "\n\t"))) - (display left-part) - (display middle-part) - (display help) - (newline)))) - kw-desc)) - -(define (transform-usage-lambda cases) - (issue-deprecation-warning - "`display-usage-report' is deprecated. Use `(ice-9 getopt-long)' instead.") - (let* ((raw-usage (delq! 'else (map car cases))) - (usage-sans-specials (map (lambda (x) - (or (and (not (list? x)) x) - (and (symbol? (car x)) #t) - (and (boolean? (car x)) #t) - x)) - raw-usage)) - (usage-desc (delq! #t usage-sans-specials)) - (kw-desc (map car usage-desc)) - (kw-opts (apply append (map (lambda (x) (and (not (string? (car x))) x)) kw-desc))) - (kw-args (apply append (map (lambda (x) (and (string? (car x)) (cdr x))) kw-desc))) - (transmogrified-cases (map (lambda (case) - (cons (let ((opts (car case))) - (if (or (boolean? opts) (eq? 'else opts)) - opts - (cond - ((symbol? (car opts)) opts) - ((boolean? (car opts)) opts) - ((string? (caar opts)) (cdar opts)) - (else (car opts))))) - (cdr case))) - cases))) - `(let ((%display-usage (lambda () (display-usage-report ',usage-desc)))) - (lambda (%argv) - (let %next-arg ((%argv %argv)) - (get-option %argv - ',kw-opts - ',kw-args - (lambda (%opt %arg %new-argv) - (case %opt - ,@ transmogrified-cases)))))))) - - - -;;; {collect} -;;; -;;; Similar to `begin' but returns a list of the results of all constituent -;;; forms instead of the result of the last form. -;;; - -(define-syntax collect - (lambda (x) - (issue-deprecation-warning - "`collect' is deprecated. Define it yourself.") - (syntax-case x () - ((_) #''()) - ((_ x x* ...) - #'(let ((val x)) - (cons val (collect x* ...))))))) - - - - -(define (assert-repl-silence v) - (issue-deprecation-warning - "`assert-repl-silence' has moved to `(ice-9 scm-style-repl)'.") - ((@ (ice-9 scm-style-repl) assert-repl-silence) v)) - -(define (assert-repl-print-unspecified v) - (issue-deprecation-warning - "`assert-repl-print-unspecified' has moved to `(ice-9 scm-style-repl)'.") - ((@ (ice-9 scm-style-repl) assert-repl-print-unspecified) v)) - -(define (assert-repl-verbosity v) - (issue-deprecation-warning - "`assert-repl-verbosity' has moved to `(ice-9 scm-style-repl)'.") - ((@ (ice-9 scm-style-repl) assert-repl-verbosity) v)) - -(define (set-repl-prompt! v) - (issue-deprecation-warning - "`set-repl-prompt!' is deprecated. Use `repl-default-prompt-set!' from -the `(system repl common)' module.") - ;; Avoid @, as when bootstrapping it will cause the (system repl common) - ;; module to be loaded at expansion time, which eventually loads srfi-1, but - ;; that fails due to an unbuilt supporting lib... grrrrrrrrr. - ((module-ref (resolve-interface '(system repl common)) - 'repl-default-prompt-set!) - v)) - -(define (set-batch-mode?! arg) - (cond - (arg - (issue-deprecation-warning - "`set-batch-mode?!' is deprecated. Use `ensure-batch-mode!' instead.") - (ensure-batch-mode!)) - (else - (issue-deprecation-warning - "`set-batch-mode?!' with an argument of `#f' is deprecated. Use the -`*repl-stack*' fluid instead.") - #t))) - -(define (repl read evaler print) - (issue-deprecation-warning - "`repl' is deprecated. Define it yourself.") - (let loop ((source (read (current-input-port)))) - (print (evaler source)) - (loop (read (current-input-port))))) - -(define (pre-unwind-handler-dispatch key . args) - (issue-deprecation-warning - "`pre-unwind-handler-dispatch' is deprecated. Use -`default-pre-unwind-handler' from `(ice-9 scm-style-repl)' directly.") - (apply (@ (ice-9 scm-style-repl) default-pre-unwind-handler) key args)) - -(define (default-pre-unwind-handler key . args) - (issue-deprecation-warning - "`default-pre-unwind-handler' is deprecated. Use it from -`(ice-9 scm-style-repl)' if you need it.") - (apply (@ (ice-9 scm-style-repl) default-pre-unwind-handler) key args)) - -(define (handle-system-error key . args) - (issue-deprecation-warning - "`handle-system-error' is deprecated. Use it from -`(ice-9 scm-style-repl)' if you need it.") - (apply (@ (ice-9 scm-style-repl) handle-system-error) key args)) - -(define-syntax stack-saved? - (make-variable-transformer - (lambda (x) - (issue-deprecation-warning - "`stack-saved?' is deprecated. Use it from -`(ice-9 save-stack)' if you need it.") - (syntax-case x (set!) - ((set! id val) - (identifier? #'id) - #'(set! (@ (ice-9 save-stack) stack-saved?) val)) - (id - (identifier? #'id) - #'(@ (ice-9 save-stack) stack-saved?)))))) - -(define-syntax the-last-stack - (lambda (x) - (issue-deprecation-warning - "`the-last-stack' is deprecated. Use it from `(ice-9 save-stack)' -if you need it.") - (syntax-case x () - (id - (identifier? #'id) - #'(@ (ice-9 save-stack) the-last-stack))))) - -(define (save-stack . args) - (issue-deprecation-warning - "`save-stack' is deprecated. Use it from `(ice-9 save-stack)' if you need -it.") - (apply (@ (ice-9 save-stack) save-stack) args)) - -(define (named-module-use! user usee) - (issue-deprecation-warning - "`named-module-use!' is deprecated. Define it yourself if you need it.") - (module-use! (resolve-module user) (resolve-interface usee))) - -(define (top-repl) - (issue-deprecation-warning - "`top-repl' has moved to the `(ice-9 top-repl)' module.") - ((module-ref (resolve-module '(ice-9 top-repl)) 'top-repl))) - -(set! debug-enable - (let ((debug-enable debug-enable)) - (lambda opts - (if (memq 'debug opts) - (begin - (issue-deprecation-warning - "`(debug-enable 'debug)' is obsolete and has no effect." - "Remove it from your code.") - (apply debug-enable (delq 'debug opts))) - (apply debug-enable opts))))) - -(define (turn-on-debugging) - (issue-deprecation-warning - "`(turn-on-debugging)' is obsolete and usually has no effect." - "Debugging capabilities are present by default.") - (debug-enable 'backtrace) - (read-enable 'positions)) - -(define (read-hash-procedures-warning) - (issue-deprecation-warning - "`read-hash-procedures' is deprecated." - "Use the fluid `%read-hash-procedures' instead.")) - -(define-syntax read-hash-procedures - (identifier-syntax - (_ - (begin (read-hash-procedures-warning) - (fluid-ref %read-hash-procedures))) - ((set! _ expr) - (begin (read-hash-procedures-warning) - (fluid-set! %read-hash-procedures expr))))) - -(define (process-define-module args) - (define (missing kw) - (error "missing argument to define-module keyword" kw)) - (define (unrecognized arg) - (error "unrecognized define-module argument" arg)) - - (issue-deprecation-warning - "`process-define-module' is deprecated. Use `define-module*' instead.") - - (let ((name (car args)) - (filename #f) - (pure? #f) - (version #f) - (system? #f) - (duplicates '()) - (transformer #f)) - (let loop ((kws (cdr args)) - (imports '()) - (exports '()) - (re-exports '()) - (replacements '()) - (autoloads '())) - (if (null? kws) - (define-module* name - #:filename filename #:pure pure? #:version version - #:duplicates duplicates #:transformer transformer - #:imports (reverse! imports) - #:exports exports - #:re-exports re-exports - #:replacements replacements - #:autoloads autoloads) - (case (car kws) - ((#:use-module #:use-syntax) - (or (pair? (cdr kws)) - (missing (car kws))) - (cond - ((equal? (cadr kws) '(ice-9 syncase)) - (issue-deprecation-warning - "(ice-9 syncase) is deprecated. Support for syntax-case is now in Guile core.") - (loop (cddr kws) - imports exports re-exports replacements autoloads)) - (else - (let ((iface-spec (cadr kws))) - (if (eq? (car kws) #:use-syntax) - (set! transformer iface-spec)) - (loop (cddr kws) - (cons iface-spec imports) exports re-exports - replacements autoloads))))) - ((#:autoload) - (or (and (pair? (cdr kws)) (pair? (cddr kws))) - (missing (car kws))) - (let ((name (cadr kws)) - (bindings (caddr kws))) - (loop (cdddr kws) - imports exports re-exports - replacements (cons* name bindings autoloads)))) - ((#:no-backtrace) - ;; FIXME: deprecate? - (set! system? #t) - (loop (cdr kws) - imports exports re-exports replacements autoloads)) - ((#:pure) - (set! pure? #t) - (loop (cdr kws) - imports exports re-exports replacements autoloads)) - ((#:version) - (or (pair? (cdr kws)) - (missing (car kws))) - (set! version (cadr kws)) - (loop (cddr kws) - imports exports re-exports replacements autoloads)) - ((#:duplicates) - (if (not (pair? (cdr kws))) - (missing (car kws))) - (set! duplicates (cadr kws)) - (loop (cddr kws) - imports exports re-exports replacements autoloads)) - ((#:export #:export-syntax) - (or (pair? (cdr kws)) - (missing (car kws))) - (loop (cddr kws) - imports (append exports (cadr kws)) re-exports - replacements autoloads)) - ((#:re-export #:re-export-syntax) - (or (pair? (cdr kws)) - (missing (car kws))) - (loop (cddr kws) - imports exports (append re-exports (cadr kws)) - replacements autoloads)) - ((#:replace #:replace-syntax) - (or (pair? (cdr kws)) - (missing (car kws))) - (loop (cddr kws) - imports exports re-exports - (append replacements (cadr kws)) autoloads)) - ((#:filename) - (or (pair? (cdr kws)) - (missing (car kws))) - (set! filename (cadr kws)) - (loop (cddr kws) - imports exports re-exports replacements autoloads)) - (else - (unrecognized kws))))))) - -(define-syntax fluid-let-syntax - (lambda (x) - (issue-deprecation-warning - "`fluid-let-syntax' is deprecated. Use syntax parameters instead.") - (syntax-case x () - ((_ ((k v) ...) body0 body ...) - #'(syntax-parameterize ((k v) ...) - body0 body ...))))) - -(define (close-io-port port) - (issue-deprecation-warning - "`close-io-port' is deprecated. Use `close-port' instead.") - (close-port port)) - -(define (set-system-module! m s) - (issue-deprecation-warning - "`set-system-module!' is deprecated. There is no need to use it.") - (set-procedure-property! (module-eval-closure m) 'system-module s)) - -(set! module-eval-closure - (lambda (m) - (issue-deprecation-warning - "`module-eval-closure' is deprecated. Use module-variable or module-define! instead.") - (standard-eval-closure m))) - -;; Legacy definition. We can't make it identifier-syntax yet though, -;; because compiled code might rely on it. -(define char-code-limit 256) + #:export ()) diff --git a/module/ice-9/eval.scm b/module/ice-9/eval.scm index 554c88e56..90bc25457 100644 --- a/module/ice-9/eval.scm +++ b/module/ice-9/eval.scm @@ -1,6 +1,6 @@ ;;; -*- mode: scheme; coding: utf-8; -*- -;;;; Copyright (C) 2009, 2010, 2012, 2013 Free Software Foundation, Inc. +;;;; Copyright (C) 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc. ;;;; ;;;; This library is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Lesser General Public @@ -424,14 +424,11 @@ (set-procedure-property! proc 'documentation docstring)) proc)) - (('begin (first . rest)) - (let lp ((first first) (rest rest)) - (if (null? rest) - (eval first env) - (begin - (eval first env) - (lp (car rest) (cdr rest)))))) - + (('seq (head . tail)) + (begin + (eval head env) + (eval tail env))) + (('lexical-set! (n . x)) (let ((val (eval x env))) (list-set! env n val))) diff --git a/module/ice-9/local-eval.scm b/module/ice-9/local-eval.scm index 28f30b991..493dbed0d 100644 --- a/module/ice-9/local-eval.scm +++ b/module/ice-9/local-eval.scm @@ -180,7 +180,11 @@ t) patterns)))) (else - (error "what" type val)))))))))) + ;; Interestingly, this case can include globals (and + ;; global macros), now that Guile tracks which globals it + ;; introduces. Not sure what to do here! For now, punt. + ;; + (lp ids capture formals wrappers patterns)))))))))) (define-syntax the-environment (lambda (x) diff --git a/module/ice-9/peg.scm b/module/ice-9/peg.scm new file mode 100644 index 000000000..4e03131cd --- /dev/null +++ b/module/ice-9/peg.scm @@ -0,0 +1,42 @@ +;;;; peg.scm --- Parsing Expression Grammar (PEG) parser generator +;;;; +;;;; Copyright (C) 2010, 2011 Free Software Foundation, Inc. +;;;; +;;;; This library is free software; you can redistribute it and/or +;;;; modify it under the terms of the GNU Lesser General Public +;;;; License as published by the Free Software Foundation; either +;;;; version 3 of the License, or (at your option) any later version. +;;;; +;;;; This library is distributed in the hope that it will be useful, +;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +;;;; Lesser General Public License for more details. +;;;; +;;;; You should have received a copy of the GNU Lesser General Public +;;;; License along with this library; if not, write to the Free Software +;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +;;;; + +(define-module (ice-9 peg) + #:use-module (ice-9 peg codegen) + #:use-module (ice-9 peg string-peg) + ;; Note: the most important effect of using string-peg is not whatever + ;; functions it exports, but the fact that it adds a new handler to + ;; peg-sexp-compile. + #:use-module (ice-9 peg simplify-tree) + #:use-module (ice-9 peg using-parsers) + #:use-module (ice-9 peg cache) + #:re-export (define-peg-pattern + define-peg-string-patterns + match-pattern + search-for-pattern + compile-peg-pattern + keyword-flatten + context-flatten + peg:start + peg:end + peg:string + peg:tree + peg:substring + peg-record?)) + diff --git a/module/ice-9/peg/cache.scm b/module/ice-9/peg/cache.scm new file mode 100644 index 000000000..f45432b35 --- /dev/null +++ b/module/ice-9/peg/cache.scm @@ -0,0 +1,45 @@ +;;;; cache.scm --- cache the results of parsing +;;;; +;;;; Copyright (C) 2010, 2011 Free Software Foundation, Inc. +;;;; +;;;; This library is free software; you can redistribute it and/or +;;;; modify it under the terms of the GNU Lesser General Public +;;;; License as published by the Free Software Foundation; either +;;;; version 3 of the License, or (at your option) any later version. +;;;; +;;;; This library is distributed in the hope that it will be useful, +;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +;;;; Lesser General Public License for more details. +;;;; +;;;; You should have received a copy of the GNU Lesser General Public +;;;; License along with this library; if not, write to the Free Software +;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +;;;; + +(define-module (ice-9 peg cache) + #:export (cg-cached-parser)) + +;; The results of parsing using a nonterminal are cached. Think of it like a +;; hash with no conflict resolution. Process for deciding on the cache size +;; wasn't very scientific; just ran the benchmarks and stopped a little after +;; the point of diminishing returns on my box. +(define *cache-size* 512) + +(define (make-cache) + (make-vector *cache-size* #f)) + +;; given a syntax object which is a parser function, returns syntax +;; which, if evaluated, will become a parser function that uses a cache. +(define (cg-cached-parser parser) + #`(let ((cache (make-cache))) + (lambda (str strlen at) + (let* ((vref (vector-ref cache (modulo at *cache-size*)))) + ;; Check to see whether the value is cached. + (if (and vref (eq? (car vref) str) (= (cadr vref) at)) + (caddr vref);; If it is return it. + (let ((fres ;; Else calculate it and cache it. + (#,parser str strlen at))) + (vector-set! cache (modulo at *cache-size*) + (list str at fres)) + fres)))))) diff --git a/module/ice-9/peg/codegen.scm b/module/ice-9/peg/codegen.scm new file mode 100644 index 000000000..d80c3e849 --- /dev/null +++ b/module/ice-9/peg/codegen.scm @@ -0,0 +1,359 @@ +;;;; codegen.scm --- code generation for composable parsers +;;;; +;;;; Copyright (C) 2011 Free Software Foundation, Inc. +;;;; +;;;; This library is free software; you can redistribute it and/or +;;;; modify it under the terms of the GNU Lesser General Public +;;;; License as published by the Free Software Foundation; either +;;;; version 3 of the License, or (at your option) any later version. +;;;; +;;;; This library is distributed in the hope that it will be useful, +;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +;;;; Lesser General Public License for more details. +;;;; +;;;; You should have received a copy of the GNU Lesser General Public +;;;; License along with this library; if not, write to the Free Software +;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +;;;; + +(define-module (ice-9 peg codegen) + #:export (compile-peg-pattern wrap-parser-for-users add-peg-compiler!) + #:use-module (ice-9 pretty-print) + #:use-module (system base pmatch)) + +(define-syntax single? + (syntax-rules () + "Return #t if X is a list of one element." + ((_ x) + (pmatch x + ((_) #t) + (else #f))))) + +(define-syntax single-filter + (syntax-rules () + "If EXP is a list of one element, return the element. Otherwise +return EXP." + ((_ exp) + (pmatch exp + ((,elt) elt) + (,elts elts))))) + +(define-syntax push-not-null! + (syntax-rules () + "If OBJ is non-null, push it onto LST, otherwise do nothing." + ((_ lst obj) + (if (not (null? obj)) + (push! lst obj))))) + +(define-syntax push! + (syntax-rules () + "Push an object onto a list." + ((_ lst obj) + (set! lst (cons obj lst))))) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;; CODE GENERATORS +;; These functions generate scheme code for parsing PEGs. +;; Conventions: +;; accum: (all name body none) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Code we generate will have a certain return structure depending on how we're +;; accumulating (the ACCUM variable). +(define (cg-generic-ret accum name body-uneval at) + ;; name, body-uneval and at are syntax + #`(let ((body #,body-uneval)) + #,(cond + ((and (eq? accum 'all) name) + #`(list #,at + (cond + ((not (list? body)) (list '#,name body)) + ((null? body) '#,name) + ((symbol? (car body)) (list '#,name body)) + (else (cons '#,name body))))) + ((eq? accum 'name) + #`(list #,at '#,name)) + ((eq? accum 'body) + #`(list #,at + (cond + ((single? body) (car body)) + (else body)))) + ((eq? accum 'none) + #`(list #,at '())) + (else + (begin + (pretty-print `(cg-generic-ret-error ,accum ,name ,body-uneval ,at)) + (pretty-print "Defaulting to accum of none.\n") + #`(list #,at '())))))) + +;; The short name makes the formatting below much easier to read. +(define cggr cg-generic-ret) + +;; Generates code that matches a particular string. +;; E.g.: (cg-string syntax "abc" 'body) +(define (cg-string pat accum) + (let ((plen (string-length pat))) + #`(lambda (str len pos) + (let ((end (+ pos #,plen))) + (and (<= end len) + (string= str #,pat pos end) + #,(case accum + ((all) #`(list end (list 'cg-string #,pat))) + ((name) #`(list end 'cg-string)) + ((body) #`(list end #,pat)) + ((none) #`(list end '())) + (else (error "bad accum" accum)))))))) + +;; Generates code for matching any character. +;; E.g.: (cg-peg-any syntax 'body) +(define (cg-peg-any accum) + #`(lambda (str len pos) + (and (< pos len) + #,(case accum + ((all) #`(list (1+ pos) + (list 'cg-peg-any (substring str pos (1+ pos))))) + ((name) #`(list (1+ pos) 'cg-peg-any)) + ((body) #`(list (1+ pos) (substring str pos (1+ pos)))) + ((none) #`(list (1+ pos) '())) + (else (error "bad accum" accum)))))) + +;; Generates code for matching a range of characters between start and end. +;; E.g.: (cg-range syntax #\a #\z 'body) +(define (cg-range pat accum) + (syntax-case pat () + ((start end) + (if (not (and (char? (syntax->datum #'start)) + (char? (syntax->datum #'end)))) + (error "range PEG should have characters after it; instead got" + #'start #'end)) + #`(lambda (str len pos) + (and (< pos len) + (let ((c (string-ref str pos))) + (and (char>=? c start) + (char<=? c end) + #,(case accum + ((all) #`(list (1+ pos) (list 'cg-range (string c)))) + ((name) #`(list (1+ pos) 'cg-range)) + ((body) #`(list (1+ pos) (string c))) + ((none) #`(list (1+ pos) '())) + (else (error "bad accum" accum)))))))))) + +;; Generate code to match a pattern and do nothing with the result +(define (cg-ignore pat accum) + (syntax-case pat () + ((inner) + (compile-peg-pattern #'inner 'none)))) + +(define (cg-capture pat accum) + (syntax-case pat () + ((inner) + (compile-peg-pattern #'inner 'body)))) + +;; Filters the accum argument to compile-peg-pattern for buildings like string +;; literals (since we don't want to tag them with their name if we're doing an +;; "all" accum). +(define (builtin-accum-filter accum) + (cond + ((eq? accum 'all) 'body) + ((eq? accum 'name) 'name) + ((eq? accum 'body) 'body) + ((eq? accum 'none) 'none))) +(define baf builtin-accum-filter) + +;; Top-level function builder for AND. Reduces to a call to CG-AND-INT. +(define (cg-and clauses accum) + #`(lambda (str len pos) + (let ((body '())) + #,(cg-and-int clauses (baf accum) #'str #'len #'pos #'body)))) + +;; Internal function builder for AND (calls itself). +(define (cg-and-int clauses accum str strlen at body) + (syntax-case clauses () + (() + (cggr accum 'cg-and #`(reverse #,body) at)) + ((first rest ...) + #`(let ((res (#,(compile-peg-pattern #'first accum) #,str #,strlen #,at))) + (and res + ;; update AT and BODY then recurse + (let ((newat (car res)) + (newbody (cadr res))) + (set! #,at newat) + (push-not-null! #,body (single-filter newbody)) + #,(cg-and-int #'(rest ...) accum str strlen at body))))))) + +;; Top-level function builder for OR. Reduces to a call to CG-OR-INT. +(define (cg-or clauses accum) + #`(lambda (str len pos) + #,(cg-or-int clauses (baf accum) #'str #'len #'pos))) + +;; Internal function builder for OR (calls itself). +(define (cg-or-int clauses accum str strlen at) + (syntax-case clauses () + (() + #f) + ((first rest ...) + #`(or (#,(compile-peg-pattern #'first accum) #,str #,strlen #,at) + #,(cg-or-int #'(rest ...) accum str strlen at))))) + +(define (cg-* args accum) + (syntax-case args () + ((pat) + #`(lambda (str strlen at) + (let ((body '())) + (let lp ((end at) (count 0)) + (let* ((match (#,(compile-peg-pattern #'pat (baf accum)) + str strlen end)) + (new-end (if match (car match) end)) + (count (if (> new-end end) (1+ count) count))) + (if (> new-end end) + (push-not-null! body (single-filter (cadr match)))) + (if (and (> new-end end) + #,#t) + (lp new-end count) + (let ((success #,#t)) + #,#`(and success + #,(cggr (baf accum) 'cg-body + #'(reverse body) #'new-end))))))))))) + +(define (cg-+ args accum) + (syntax-case args () + ((pat) + #`(lambda (str strlen at) + (let ((body '())) + (let lp ((end at) (count 0)) + (let* ((match (#,(compile-peg-pattern #'pat (baf accum)) + str strlen end)) + (new-end (if match (car match) end)) + (count (if (> new-end end) (1+ count) count))) + (if (> new-end end) + (push-not-null! body (single-filter (cadr match)))) + (if (and (> new-end end) + #,#t) + (lp new-end count) + (let ((success #,#'(>= count 1))) + #,#`(and success + #,(cggr (baf accum) 'cg-body + #'(reverse body) #'new-end))))))))))) + +(define (cg-? args accum) + (syntax-case args () + ((pat) + #`(lambda (str strlen at) + (let ((body '())) + (let lp ((end at) (count 0)) + (let* ((match (#,(compile-peg-pattern #'pat (baf accum)) + str strlen end)) + (new-end (if match (car match) end)) + (count (if (> new-end end) (1+ count) count))) + (if (> new-end end) + (push-not-null! body (single-filter (cadr match)))) + (if (and (> new-end end) + #,#'(< count 1)) + (lp new-end count) + (let ((success #,#t)) + #,#`(and success + #,(cggr (baf accum) 'cg-body + #'(reverse body) #'new-end))))))))))) + +(define (cg-followed-by args accum) + (syntax-case args () + ((pat) + #`(lambda (str strlen at) + (let ((body '())) + (let lp ((end at) (count 0)) + (let* ((match (#,(compile-peg-pattern #'pat (baf accum)) + str strlen end)) + (new-end (if match (car match) end)) + (count (if (> new-end end) (1+ count) count))) + (if (> new-end end) + (push-not-null! body (single-filter (cadr match)))) + (if (and (> new-end end) + #,#'(< count 1)) + (lp new-end count) + (let ((success #,#'(= count 1))) + #,#`(and success + #,(cggr (baf accum) 'cg-body #''() #'at))))))))))) + +(define (cg-not-followed-by args accum) + (syntax-case args () + ((pat) + #`(lambda (str strlen at) + (let ((body '())) + (let lp ((end at) (count 0)) + (let* ((match (#,(compile-peg-pattern #'pat (baf accum)) + str strlen end)) + (new-end (if match (car match) end)) + (count (if (> new-end end) (1+ count) count))) + (if (> new-end end) + (push-not-null! body (single-filter (cadr match)))) + (if (and (> new-end end) + #,#'(< count 1)) + (lp new-end count) + (let ((success #,#'(= count 1))) + #,#`(if success + #f + #,(cggr (baf accum) 'cg-body #''() #'at))))))))))) + +;; Association list of functions to handle different expressions as PEGs +(define peg-compiler-alist '()) + +(define (add-peg-compiler! symbol function) + (set! peg-compiler-alist + (assq-set! peg-compiler-alist symbol function))) + +(add-peg-compiler! 'range cg-range) +(add-peg-compiler! 'ignore cg-ignore) +(add-peg-compiler! 'capture cg-capture) +(add-peg-compiler! 'and cg-and) +(add-peg-compiler! 'or cg-or) +(add-peg-compiler! '* cg-*) +(add-peg-compiler! '+ cg-+) +(add-peg-compiler! '? cg-?) +(add-peg-compiler! 'followed-by cg-followed-by) +(add-peg-compiler! 'not-followed-by cg-not-followed-by) + +;; Takes an arbitrary expressions and accumulation variable, then parses it. +;; E.g.: (compile-peg-pattern syntax '(and "abc" (or "-" (range #\a #\z))) 'all) +(define (compile-peg-pattern pat accum) + (syntax-case pat (peg-any) + (peg-any + (cg-peg-any (baf accum))) + (sym (identifier? #'sym) ;; nonterminal + #'sym) + (str (string? (syntax->datum #'str)) ;; literal string + (cg-string (syntax->datum #'str) (baf accum))) + ((name . args) (let* ((nm (syntax->datum #'name)) + (entry (assq-ref peg-compiler-alist nm))) + (if entry + (entry #'args accum) + (error "Bad peg form" nm #'args + "Not one of" (map car peg-compiler-alist))))))) + +;; Packages the results of a parser +(define (wrap-parser-for-users for-syntax parser accumsym s-syn) + #`(lambda (str strlen at) + (let ((res (#,parser str strlen at))) + ;; Try to match the nonterminal. + (if res + ;; If we matched, do some post-processing to figure out + ;; what data to propagate upward. + (let ((at (car res)) + (body (cadr res))) + #,(cond + ((eq? accumsym 'name) + #`(list at '#,s-syn)) + ((eq? accumsym 'all) + #`(list (car res) + (cond + ((not (list? body)) + (list '#,s-syn body)) + ((null? body) '#,s-syn) + ((symbol? (car body)) + (list '#,s-syn body)) + (else (cons '#,s-syn body))))) + ((eq? accumsym 'none) #`(list (car res) '())) + (else #`(begin res)))) + ;; If we didn't match, just return false. + #f)))) diff --git a/module/ice-9/peg/simplify-tree.scm b/module/ice-9/peg/simplify-tree.scm new file mode 100644 index 000000000..4c781a191 --- /dev/null +++ b/module/ice-9/peg/simplify-tree.scm @@ -0,0 +1,97 @@ +;;;; simplify-tree.scm --- utility functions for the PEG parser +;;;; +;;;; Copyright (C) 2010, 2011 Free Software Foundation, Inc. +;;;; +;;;; This library is free software; you can redistribute it and/or +;;;; modify it under the terms of the GNU Lesser General Public +;;;; License as published by the Free Software Foundation; either +;;;; version 3 of the License, or (at your option) any later version. +;;;; +;;;; This library is distributed in the hope that it will be useful, +;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +;;;; Lesser General Public License for more details. +;;;; +;;;; You should have received a copy of the GNU Lesser General Public +;;;; License along with this library; if not, write to the Free Software +;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +;;;; + +(define-module (ice-9 peg simplify-tree) + #:export (keyword-flatten context-flatten string-collapse) + #:use-module (system base pmatch)) + +(define-syntax single? + (syntax-rules () + "Return #t if X is a list of one element." + ((_ x) + (pmatch x + ((_) #t) + (else #f))))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;; POST-PROCESSING FUNCTIONS (TO CANONICALIZE MATCH TREES) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Is everything in LST true? +(define (andlst lst) + (or (null? lst) + (and (car lst) (andlst (cdr lst))))) + +;; Is LST a list of strings? +(define (string-list? lst) + (and (list? lst) (not (null? lst)) + (andlst (map string? lst)))) + +;; Groups all strings that are next to each other in LST. Used in +;; STRING-COLLAPSE. +(define (string-group lst) + (if (not (list? lst)) + lst + (if (null? lst) + '() + (let ((next (string-group (cdr lst)))) + (if (not (string? (car lst))) + (cons (car lst) next) + (if (and (not (null? next)) + (list? (car next)) + (string? (caar next))) + (cons (cons (car lst) (car next)) (cdr next)) + (cons (list (car lst)) next))))))) + + +;; Collapses all the string in LST. +;; ("a" "b" (c d) "e" "f") -> ("ab" (c d) "ef") +(define (string-collapse lst) + (if (list? lst) + (let ((res (map (lambda (x) (if (string-list? x) + (apply string-append x) + x)) + (string-group (map string-collapse lst))))) + (if (single? res) (car res) res)) + lst)) + +;; If LST is an atom, return (list LST), else return LST. +(define (mklst lst) + (if (not (list? lst)) (list lst) lst)) + +;; Takes a list and "flattens" it, using the predicate TST to know when to stop +;; instead of terminating on atoms (see tutorial). +(define (context-flatten tst lst) + (if (or (not (list? lst)) (null? lst)) + lst + (if (tst lst) + (list lst) + (apply append + (map (lambda (x) (mklst (context-flatten tst x))) + lst))))) + +;; Takes a list and "flattens" it, using the list of keywords KEYWORD-LST to +;; know when to stop at (see tutorial). +(define (keyword-flatten keyword-lst lst) + (context-flatten + (lambda (x) + (if (or (not (list? x)) (null? x)) + #t + (member (car x) keyword-lst))) + lst)) diff --git a/module/ice-9/peg/string-peg.scm b/module/ice-9/peg/string-peg.scm new file mode 100644 index 000000000..45ed14bb1 --- /dev/null +++ b/module/ice-9/peg/string-peg.scm @@ -0,0 +1,273 @@ +;;;; string-peg.scm --- representing PEG grammars as strings +;;;; +;;;; Copyright (C) 2010, 2011 Free Software Foundation, Inc. +;;;; +;;;; This library is free software; you can redistribute it and/or +;;;; modify it under the terms of the GNU Lesser General Public +;;;; License as published by the Free Software Foundation; either +;;;; version 3 of the License, or (at your option) any later version. +;;;; +;;;; This library is distributed in the hope that it will be useful, +;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +;;;; Lesser General Public License for more details. +;;;; +;;;; You should have received a copy of the GNU Lesser General Public +;;;; License along with this library; if not, write to the Free Software +;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +;;;; + +(define-module (ice-9 peg string-peg) + #:export (peg-as-peg + define-peg-string-patterns + peg-grammar) + #:use-module (ice-9 peg using-parsers) + #:use-module (ice-9 peg codegen) + #:use-module (ice-9 peg simplify-tree)) + +;; Gets the left-hand depth of a list. +(define (depth lst) + (if (or (not (list? lst)) (null? lst)) + 0 + (+ 1 (depth (car lst))))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;; Parse string PEGs using sexp PEGs. +;; See the variable PEG-AS-PEG for an easier-to-read syntax. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Grammar for PEGs in PEG grammar. +(define peg-as-peg +"grammar <-- (nonterminal ('<--' / '<-' / '<') sp pattern)+ +pattern <-- alternative (SLASH sp alternative)* +alternative <-- ([!&]? sp suffix)+ +suffix <-- primary ([*+?] sp)* +primary <-- '(' sp pattern ')' sp / '.' sp / literal / charclass / nonterminal !'<' +literal <-- ['] (!['] .)* ['] sp +charclass <-- LB (!']' (CCrange / CCsingle))* RB sp +CCrange <-- . '-' . +CCsingle <-- . +nonterminal <-- [a-zA-Z0-9-]+ sp +sp < [ \t\n]* +SLASH < '/' +LB < '[' +RB < ']' +") + +(define-syntax define-sexp-parser + (lambda (x) + (syntax-case x () + ((_ sym accum pat) + (let* ((matchf (compile-peg-pattern #'pat (syntax->datum #'accum))) + (accumsym (syntax->datum #'accum)) + (syn (wrap-parser-for-users x matchf accumsym #'sym))) + #`(define sym #,syn)))))) + +(define-sexp-parser peg-grammar all + (+ (and peg-nonterminal (or "<--" "<-" "<") peg-sp peg-pattern))) +(define-sexp-parser peg-pattern all + (and peg-alternative + (* (and (ignore "/") peg-sp peg-alternative)))) +(define-sexp-parser peg-alternative all + (+ (and (? (or "!" "&")) peg-sp peg-suffix))) +(define-sexp-parser peg-suffix all + (and peg-primary (* (and (or "*" "+" "?") peg-sp)))) +(define-sexp-parser peg-primary all + (or (and "(" peg-sp peg-pattern ")" peg-sp) + (and "." peg-sp) + peg-literal + peg-charclass + (and peg-nonterminal (not-followed-by "<")))) +(define-sexp-parser peg-literal all + (and "'" (* (and (not-followed-by "'") peg-any)) "'" peg-sp)) +(define-sexp-parser peg-charclass all + (and (ignore "[") + (* (and (not-followed-by "]") + (or charclass-range charclass-single))) + (ignore "]") + peg-sp)) +(define-sexp-parser charclass-range all (and peg-any "-" peg-any)) +(define-sexp-parser charclass-single all peg-any) +(define-sexp-parser peg-nonterminal all + (and (+ (or (range #\a #\z) (range #\A #\Z) (range #\0 #\9) "-")) peg-sp)) +(define-sexp-parser peg-sp none + (* (or " " "\t" "\n"))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;; PARSE STRING PEGS +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Takes a string representing a PEG grammar and returns syntax that +;; will define all of the nonterminals in the grammar with equivalent +;; PEG s-expressions. +(define (peg-parser str for-syntax) + (let ((parsed (match-pattern peg-grammar str))) + (if (not parsed) + (begin + ;; (display "Invalid PEG grammar!\n") + #f) + (let ((lst (peg:tree parsed))) + (cond + ((or (not (list? lst)) (null? lst)) + lst) + ((eq? (car lst) 'peg-grammar) + #`(begin + #,@(map (lambda (x) (peg-nonterm->defn x for-syntax)) + (context-flatten (lambda (lst) (<= (depth lst) 2)) + (cdr lst)))))))))) + +;; Macro wrapper for PEG-PARSER. Parses PEG grammars expressed as strings and +;; defines all the appropriate nonterminals. +(define-syntax define-peg-string-patterns + (lambda (x) + (syntax-case x () + ((_ str) + (peg-parser (syntax->datum #'str) x))))) + +;; lst has format (nonterm grabber pattern), where +;; nonterm is a symbol (the name of the nonterminal), +;; grabber is a string (either "<", "<-" or "<--"), and +;; pattern is the parse of a PEG pattern expressed as as string. +(define (peg-nonterm->defn lst for-syntax) + (let* ((nonterm (car lst)) + (grabber (cadr lst)) + (pattern (caddr lst)) + (nonterm-name (datum->syntax for-syntax + (string->symbol (cadr nonterm))))) + #`(define-peg-pattern #,nonterm-name + #,(cond + ((string=? grabber "<--") (datum->syntax for-syntax 'all)) + ((string=? grabber "<-") (datum->syntax for-syntax 'body)) + (else (datum->syntax for-syntax 'none))) + #,(compressor (peg-pattern->defn pattern for-syntax) for-syntax)))) + +;; lst has format ('peg-pattern ...). +;; After the context-flatten, (cdr lst) has format +;; (('peg-alternative ...) ...), where the outer list is a collection +;; of elements from a '/' alternative. +(define (peg-pattern->defn lst for-syntax) + #`(or #,@(map (lambda (x) (peg-alternative->defn x for-syntax)) + (context-flatten (lambda (x) (eq? (car x) 'peg-alternative)) + (cdr lst))))) + +;; lst has format ('peg-alternative ...). +;; After the context-flatten, (cdr lst) has the format +;; (item ...), where each item has format either ("!" ...), ("&" ...), +;; or ('peg-suffix ...). +(define (peg-alternative->defn lst for-syntax) + #`(and #,@(map (lambda (x) (peg-body->defn x for-syntax)) + (context-flatten (lambda (x) (or (string? (car x)) + (eq? (car x) 'peg-suffix))) + (cdr lst))))) + +;; lst has the format either +;; ("!" ('peg-suffix ...)), ("&" ('peg-suffix ...)), or +;; ('peg-suffix ...). +(define (peg-body->defn lst for-syntax) + (cond + ((equal? (car lst) "&") + #`(followed-by #,(peg-suffix->defn (cadr lst) for-syntax))) + ((equal? (car lst) "!") + #`(not-followed-by #,(peg-suffix->defn (cadr lst) for-syntax))) + ((eq? (car lst) 'peg-suffix) + (peg-suffix->defn lst for-syntax)) + (else `(peg-parse-body-fail ,lst)))) + +;; lst has format ('peg-suffix <peg-primary> (? (/ "*" "?" "+"))) +(define (peg-suffix->defn lst for-syntax) + (let ((inner-defn (peg-primary->defn (cadr lst) for-syntax))) + (cond + ((null? (cddr lst)) + inner-defn) + ((equal? (caddr lst) "*") + #`(* #,inner-defn)) + ((equal? (caddr lst) "?") + #`(? #,inner-defn)) + ((equal? (caddr lst) "+") + #`(+ #,inner-defn))))) + +;; Parse a primary. +(define (peg-primary->defn lst for-syntax) + (let ((el (cadr lst))) + (cond + ((list? el) + (cond + ((eq? (car el) 'peg-literal) + (peg-literal->defn el for-syntax)) + ((eq? (car el) 'peg-charclass) + (peg-charclass->defn el for-syntax)) + ((eq? (car el) 'peg-nonterminal) + (datum->syntax for-syntax (string->symbol (cadr el)))))) + ((string? el) + (cond + ((equal? el "(") + (peg-pattern->defn (caddr lst) for-syntax)) + ((equal? el ".") + (datum->syntax for-syntax 'peg-any)) + (else (datum->syntax for-syntax + `(peg-parse-any unknown-string ,lst))))) + (else (datum->syntax for-syntax + `(peg-parse-any unknown-el ,lst)))))) + +;; Trims characters off the front and end of STR. +;; (trim-1chars "'ab'") -> "ab" +(define (trim-1chars str) (substring str 1 (- (string-length str) 1))) + +;; Parses a literal. +(define (peg-literal->defn lst for-syntax) + (datum->syntax for-syntax (trim-1chars (cadr lst)))) + +;; Parses a charclass. +(define (peg-charclass->defn lst for-syntax) + #`(or + #,@(map + (lambda (cc) + (cond + ((eq? (car cc) 'charclass-range) + #`(range #,(datum->syntax + for-syntax + (string-ref (cadr cc) 0)) + #,(datum->syntax + for-syntax + (string-ref (cadr cc) 2)))) + ((eq? (car cc) 'charclass-single) + (datum->syntax for-syntax (cadr cc))))) + (context-flatten + (lambda (x) (or (eq? (car x) 'charclass-range) + (eq? (car x) 'charclass-single))) + (cdr lst))))) + +;; Compresses a list to save the optimizer work. +;; e.g. (or (and a)) -> a +(define (compressor-core lst) + (if (or (not (list? lst)) (null? lst)) + lst + (cond + ((and (or (eq? (car lst) 'or) (eq? (car lst) 'and)) + (null? (cddr lst))) + (compressor-core (cadr lst))) + ((and (eq? (car lst) 'body) + (eq? (cadr lst) 'lit) + (eq? (cadddr lst) 1)) + (compressor-core (caddr lst))) + (else (map compressor-core lst))))) + +(define (compressor syn for-syntax) + (datum->syntax for-syntax + (compressor-core (syntax->datum syn)))) + +;; Builds a lambda-expressions for the pattern STR using accum. +(define (peg-string-compile args accum) + (syntax-case args () + ((str-stx) (string? (syntax->datum #'str-stx)) + (let ((string (syntax->datum #'str-stx))) + (compile-peg-pattern + (compressor + (peg-pattern->defn + (peg:tree (match-pattern peg-pattern string)) #'str-stx) + #'str-stx) + (if (eq? accum 'all) 'body accum)))) + (else (error "Bad embedded PEG string" args)))) + +(add-peg-compiler! 'peg peg-string-compile) + diff --git a/module/ice-9/peg/using-parsers.scm b/module/ice-9/peg/using-parsers.scm new file mode 100644 index 000000000..076de2999 --- /dev/null +++ b/module/ice-9/peg/using-parsers.scm @@ -0,0 +1,116 @@ +;;;; using-parsers.scm --- utilities to make using parsers easier +;;;; +;;;; Copyright (C) 2010, 2011 Free Software Foundation, Inc. +;;;; +;;;; This library is free software; you can redistribute it and/or +;;;; modify it under the terms of the GNU Lesser General Public +;;;; License as published by the Free Software Foundation; either +;;;; version 3 of the License, or (at your option) any later version. +;;;; +;;;; This library is distributed in the hope that it will be useful, +;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +;;;; Lesser General Public License for more details. +;;;; +;;;; You should have received a copy of the GNU Lesser General Public +;;;; License along with this library; if not, write to the Free Software +;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +;;;; + +(define-module (ice-9 peg using-parsers) + #:use-module (ice-9 peg simplify-tree) + #:use-module (ice-9 peg codegen) + #:use-module (ice-9 peg cache) + #:export (match-pattern define-peg-pattern search-for-pattern + prec make-prec peg:start peg:end peg:string + peg:tree peg:substring peg-record?)) + +;;; +;;; Helper Macros +;;; + +(define-syntax until + (syntax-rules () + "Evaluate TEST. If it is true, return its value. Otherwise, +execute the STMTs and try again." + ((_ test stmt stmt* ...) + (let lp () + (or test + (begin stmt stmt* ... (lp))))))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;; FOR DEFINING AND USING NONTERMINALS +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Parses STRING using NONTERM +(define (match-pattern nonterm string) + ;; We copy the string before using it because it might have been modified + ;; in-place since the last time it was parsed, which would invalidate the + ;; cache. Guile uses copy-on-write for strings, so this is fast. + (let ((res (nonterm (string-copy string) (string-length string) 0))) + (if (not res) + #f + (make-prec 0 (car res) string (string-collapse (cadr res)))))) + +;; Defines a new nonterminal symbol accumulating with ACCUM. +(define-syntax define-peg-pattern + (lambda (x) + (syntax-case x () + ((_ sym accum pat) + (let ((matchf (compile-peg-pattern #'pat (syntax->datum #'accum))) + (accumsym (syntax->datum #'accum))) + ;; CODE is the code to parse the string if the result isn't cached. + (let ((syn (wrap-parser-for-users x matchf accumsym #'sym))) + #`(define sym #,(cg-cached-parser syn)))))))) + +(define (peg-like->peg pat) + (syntax-case pat () + (str (string? (syntax->datum #'str)) #'(peg str)) + (else pat))) + +;; Searches through STRING for something that parses to PEG-MATCHER. Think +;; regexp search. +(define-syntax search-for-pattern + (lambda (x) + (syntax-case x () + ((_ pattern string-uncopied) + (let ((pmsym (syntax->datum #'pattern))) + (let ((matcher (compile-peg-pattern (peg-like->peg #'pattern) 'body))) + ;; We copy the string before using it because it might have been + ;; modified in-place since the last time it was parsed, which would + ;; invalidate the cache. Guile uses copy-on-write for strings, so + ;; this is fast. + #`(let ((string (string-copy string-uncopied)) + (strlen (string-length string-uncopied)) + (at 0)) + (let ((ret (until (or (>= at strlen) + (#,matcher string strlen at)) + (set! at (+ at 1))))) + (if (eq? ret #t) ;; (>= at strlen) succeeded + #f + (let ((end (car ret)) + (match (cadr ret))) + (make-prec + at end string + (string-collapse match)))))))))))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;; PMATCH STRUCTURE MUNGING +;; Pretty self-explanatory. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(define prec + (make-record-type "peg" '(start end string tree))) +(define make-prec + (record-constructor prec '(start end string tree))) +(define (peg:start pm) + (if pm ((record-accessor prec 'start) pm) #f)) +(define (peg:end pm) + (if pm ((record-accessor prec 'end) pm) #f)) +(define (peg:string pm) + (if pm ((record-accessor prec 'string) pm) #f)) +(define (peg:tree pm) + (if pm ((record-accessor prec 'tree) pm) #f)) +(define (peg:substring pm) + (if pm (substring (peg:string pm) (peg:start pm) (peg:end pm)) #f)) +(define peg-record? (record-predicate prec)) diff --git a/module/ice-9/poll.scm b/module/ice-9/poll.scm index 2ba868748..1633dcbc5 100644 --- a/module/ice-9/poll.scm +++ b/module/ice-9/poll.scm @@ -1,6 +1,6 @@ ;; poll -;;;; Copyright (C) 2010, 2011 Free Software Foundation, Inc. +;;;; Copyright (C) 2010, 2011, 2012 Free Software Foundation, Inc. ;;;; ;;;; This library is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Lesser General Public @@ -139,13 +139,7 @@ (off (pollfd-offset idx)) (fd (if (integer? fd-or-port) fd-or-port - (port->fdes fd-or-port)))) - - (if (port? fd-or-port) - ;; As we store the port in the fdset, there is no need to - ;; increment the revealed count to prevent the fd from being - ;; closed by a gc'd port. - (release-port-handle fd-or-port)) + (fileno fd-or-port)))) (ensure-pset-size! set (1+ idx)) (bytevector-s32-native-set! (pset-pollfds set) off fd) diff --git a/module/ice-9/psyntax-pp.scm b/module/ice-9/psyntax-pp.scm index a0d338cb0..e330423b5 100644 --- a/module/ice-9/psyntax-pp.scm +++ b/module/ice-9/psyntax-pp.scm @@ -47,19 +47,22 @@ test consequent alternate))) - (make-application + (make-call (lambda (src proc args) (make-struct (vector-ref %expanded-vtables 11) 0 src proc args))) - (make-sequence - (lambda (src exps) - (make-struct (vector-ref %expanded-vtables 12) 0 src exps))) + (make-primcall + (lambda (src name args) + (make-struct (vector-ref %expanded-vtables 12) 0 src name args))) + (make-seq + (lambda (src head tail) + (make-struct (vector-ref %expanded-vtables 13) 0 src head tail))) (make-lambda (lambda (src meta body) - (make-struct (vector-ref %expanded-vtables 13) 0 src meta body))) + (make-struct (vector-ref %expanded-vtables 14) 0 src meta body))) (make-lambda-case (lambda (src req opt rest kw inits gensyms body alternate) (make-struct - (vector-ref %expanded-vtables 14) + (vector-ref %expanded-vtables 15) 0 src req @@ -73,7 +76,7 @@ (make-let (lambda (src names gensyms vals body) (make-struct - (vector-ref %expanded-vtables 15) + (vector-ref %expanded-vtables 16) 0 src names @@ -83,7 +86,7 @@ (make-letrec (lambda (src in-order? names gensyms vals body) (make-struct - (vector-ref %expanded-vtables 16) + (vector-ref %expanded-vtables 17) 0 src in-order? @@ -94,7 +97,7 @@ (make-dynlet (lambda (src fluids vals body) (make-struct - (vector-ref %expanded-vtables 17) + (vector-ref %expanded-vtables 18) 0 src fluids @@ -103,7 +106,7 @@ (lambda? (lambda (x) (and (struct? x) - (eq? (struct-vtable x) (vector-ref %expanded-vtables 13))))) + (eq? (struct-vtable x) (vector-ref %expanded-vtables 14))))) (lambda-meta (lambda (x) (struct-ref x 1))) (set-lambda-meta! (lambda (x v) (struct-set! x 1 v))) (top-level-eval-hook (lambda (x mod) (primitive-eval x))) @@ -142,9 +145,9 @@ (if (not (assq 'name meta)) (set-lambda-meta! val (acons 'name name meta))))))) (build-void (lambda (source) (make-void source))) - (build-application + (build-call (lambda (source fun-exp arg-exps) - (make-application source fun-exp arg-exps))) + (make-call source fun-exp arg-exps))) (build-conditional (lambda (source test-exp then-exp else-exp) (make-conditional source test-exp then-exp else-exp))) @@ -206,15 +209,15 @@ (build-lambda-case (lambda (src req opt rest kw inits vars body else-case) (make-lambda-case src req opt rest kw inits vars body else-case))) - (build-primref - (lambda (src name) - (if (equal? (module-name (current-module)) '(guile)) - (make-toplevel-ref src name) - (make-module-ref src '(guile) name #f)))) + (build-primcall + (lambda (src name args) (make-primcall src name args))) + (build-primref (lambda (src name) (make-primitive-ref src name))) (build-data (lambda (src exp) (make-const src exp))) (build-sequence (lambda (src exps) - (if (null? (cdr exps)) (car exps) (make-sequence src exps)))) + (if (null? (cdr exps)) + (car exps) + (make-seq src (car exps) (build-sequence #f (cdr exps)))))) (build-let (lambda (src ids vars val-exps body-exp) (for-each maybe-name-value! ids val-exps) @@ -231,10 +234,7 @@ (list f-name) (list f) (list proc) - (build-application - src - (build-lexical-reference 'fun src f-name f) - val-exps)))))) + (build-call src (build-lexical-reference 'fun src f-name f) val-exps)))))) (build-letrec (lambda (src in-order? ids vars val-exps body-exp) (if (null? vars) @@ -285,15 +285,9 @@ (if (null? r) '() (let ((a (car r))) - (if (eq? (cadr a) 'macro) + (if (memq (cadr a) '(macro syntax-parameter)) (cons a (macros-only-env (cdr r))) (macros-only-env (cdr r))))))) - (lookup - (lambda (x r mod) - (let ((t (assq x r))) - (cond (t (cdr t)) - ((symbol? x) (or (get-global-definition-hook x mod) '(global))) - (else '(displaced-lexical)))))) (global-extend (lambda (type sym val) (put-global-definition-hook sym type val))) (nonsymbol-id? @@ -374,43 +368,53 @@ (eq? (car x) (car y)) (same-marks? (cdr x) (cdr y)))))) (id-var-name - (lambda (id w) + (lambda (id w mod) (letrec* ((search - (lambda (sym subst marks) + (lambda (sym subst marks mod) (if (null? subst) (values #f marks) (let ((fst (car subst))) (if (eq? fst 'shift) - (search sym (cdr subst) (cdr marks)) + (search sym (cdr subst) (cdr marks) mod) (let ((symnames (ribcage-symnames fst))) (if (vector? symnames) - (search-vector-rib sym subst marks symnames fst) - (search-list-rib sym subst marks symnames fst)))))))) + (search-vector-rib sym subst marks symnames fst mod) + (search-list-rib sym subst marks symnames fst mod)))))))) (search-list-rib - (lambda (sym subst marks symnames ribcage) + (lambda (sym subst marks symnames ribcage mod) (let f ((symnames symnames) (i 0)) - (cond ((null? symnames) (search sym (cdr subst) marks)) + (cond ((null? symnames) (search sym (cdr subst) marks mod)) ((and (eq? (car symnames) sym) (same-marks? marks (list-ref (ribcage-marks ribcage) i))) - (values (list-ref (ribcage-labels ribcage) i) marks)) + (let ((n (list-ref (ribcage-labels ribcage) i))) + (if (pair? n) + (if (equal? mod (car n)) + (values (cdr n) marks) + (f (cdr symnames) (+ i 1))) + (values n marks)))) (else (f (cdr symnames) (+ i 1))))))) (search-vector-rib - (lambda (sym subst marks symnames ribcage) + (lambda (sym subst marks symnames ribcage mod) (let ((n (vector-length symnames))) (let f ((i 0)) - (cond ((= i n) (search sym (cdr subst) marks)) + (cond ((= i n) (search sym (cdr subst) marks mod)) ((and (eq? (vector-ref symnames i) sym) (same-marks? marks (vector-ref (ribcage-marks ribcage) i))) - (values (vector-ref (ribcage-labels ribcage) i) marks)) + (let ((n (vector-ref (ribcage-labels ribcage) i))) + (if (pair? n) + (if (equal? mod (car n)) (values (cdr n) marks) (f (+ i 1))) + (values n marks)))) (else (f (+ i 1))))))))) - (cond ((symbol? id) (or (search id (cdr w) (car w)) id)) + (cond ((symbol? id) (or (search id (cdr w) (car w) mod) id)) ((syntax-object? id) - (let ((id (syntax-object-expression id)) (w1 (syntax-object-wrap id))) + (let ((id (syntax-object-expression id)) + (w1 (syntax-object-wrap id)) + (mod (syntax-object-module id))) (let ((marks (join-marks (car w) (car w1)))) (call-with-values - (lambda () (search id (cdr w) marks)) - (lambda (new-id marks) (or new-id (search id (cdr w1) marks) id)))))) + (lambda () (search id (cdr w) marks mod)) + (lambda (new-id marks) (or new-id (search id (cdr w1) marks mod) id)))))) (else (syntax-violation 'id-var-name "invalid id" id)))))) (locally-bound-identifiers (lambda (w mod) @@ -447,20 +451,29 @@ results)))))))) (scan (cdr w) '())))) (resolve-identifier - (lambda (id w r mod) + (lambda (id w r mod resolve-syntax-parameters?) (letrec* - ((resolve-global + ((resolve-syntax-parameters + (lambda (b) + (if (and resolve-syntax-parameters? (eq? (car b) 'syntax-parameter)) + (or (assq-ref r (cdr b)) (cons 'macro (car (cdr b)))) + b))) + (resolve-global (lambda (var mod) - (let ((b (or (get-global-definition-hook var mod) '(global)))) + (let ((b (resolve-syntax-parameters + (or (get-global-definition-hook var mod) '(global))))) (if (eq? (car b) 'global) (values 'global var mod) (values (car b) (cdr b) mod))))) (resolve-lexical (lambda (label mod) - (let ((b (or (assq-ref r label) '(displaced-lexical)))) + (let ((b (resolve-syntax-parameters + (or (assq-ref r label) '(displaced-lexical))))) (values (car b) (cdr b) mod))))) - (let ((n (id-var-name id w))) - (cond ((symbol? n) + (let ((n (id-var-name id w mod))) + (cond ((syntax-object? n) + (resolve-identifier n w r mod resolve-syntax-parameters?)) + ((symbol? n) (resolve-global n (if (syntax-object? id) (syntax-object-module id) mod))) @@ -477,9 +490,27 @@ (lambda (k) ((fluid-ref transformer-environment) k))) (free-id=? (lambda (i j) - (and (eq? (let ((x i)) (if (syntax-object? x) (syntax-object-expression x) x)) - (let ((x j)) (if (syntax-object? x) (syntax-object-expression x) x))) - (eq? (id-var-name i '(())) (id-var-name j '(())))))) + (let* ((mi (and (syntax-object? i) (syntax-object-module i))) + (mj (and (syntax-object? j) (syntax-object-module j))) + (ni (id-var-name i '(()) mi)) + (nj (id-var-name j '(()) mj))) + (letrec* + ((id-module-binding + (lambda (id mod) + (module-variable + (if mod (resolve-module (cdr mod)) (current-module)) + (let ((x id)) (if (syntax-object? x) (syntax-object-expression x) x)))))) + (cond ((syntax-object? ni) (free-id=? ni j)) + ((syntax-object? nj) (free-id=? i nj)) + ((symbol? ni) + (and (eq? nj + (let ((x j)) (if (syntax-object? x) (syntax-object-expression x) x))) + (let ((bi (id-module-binding i mi))) + (if bi + (eq? bi (id-module-binding j mj)) + (and (not (id-module-binding j mj)) (eq? ni nj)))) + (eq? (id-module-binding i mi) (id-module-binding j mj)))) + (else (equal? ni nj))))))) (bound-id=? (lambda (i j) (if (and (syntax-object? i) (syntax-object? j)) @@ -525,162 +556,151 @@ (cons first (dobody (cdr body) r w mod)))))))) (expand-top-sequence (lambda (body r w s m esew mod) - (letrec* - ((scan (lambda (body r w s m esew mod exps) - (if (null? body) - exps - (call-with-values - (lambda () - (call-with-values - (lambda () - (let ((e (car body))) - (syntax-type e r w (or (source-annotation e) s) #f mod #f))) - (lambda (type value form e w s mod) - (let ((key type)) - (cond ((memv key '(begin-form)) - (let* ((tmp e) (tmp-1 ($sc-dispatch tmp '(_)))) - (if tmp-1 - (apply (lambda () exps) tmp-1) - (let ((tmp-1 ($sc-dispatch tmp '(_ any . each-any)))) - (if tmp-1 - (apply (lambda (e1 e2) (scan (cons e1 e2) r w s m esew mod exps)) - tmp-1) - (syntax-violation - #f - "source expression failed to match any pattern" - tmp)))))) - ((memv key '(local-syntax-form)) - (expand-local-syntax - value - e - r - w - s - mod - (lambda (body r w s mod) (scan body r w s m esew mod exps)))) - ((memv key '(eval-when-form)) - (let* ((tmp-1 e) (tmp ($sc-dispatch tmp-1 '(_ each-any any . each-any)))) - (if tmp - (apply (lambda (x e1 e2) - (let ((when-list (parse-when-list e x)) (body (cons e1 e2))) - (cond ((eq? m 'e) - (if (memq 'eval when-list) - (scan body - r - w - s - (if (memq 'expand when-list) 'c&e 'e) - '(eval) - mod - exps) - (begin - (if (memq 'expand when-list) - (top-level-eval-hook - (expand-top-sequence body r w s 'e '(eval) mod) - mod)) - (values exps)))) - ((memq 'load when-list) - (cond ((or (memq 'compile when-list) - (memq 'expand when-list) - (and (eq? m 'c&e) (memq 'eval when-list))) - (scan body r w s 'c&e '(compile load) mod exps)) - ((memq m '(c c&e)) - (scan body r w s 'c '(load) mod exps)) - (else (values exps)))) - ((or (memq 'compile when-list) - (memq 'expand when-list) - (and (eq? m 'c&e) (memq 'eval when-list))) + (let* ((r (cons '("placeholder" placeholder) r)) + (ribcage (make-ribcage '() '() '())) + (w (cons (car w) (cons ribcage (cdr w))))) + (letrec* + ((record-definition! + (lambda (id var) + (let ((mod (cons 'hygiene (module-name (current-module))))) + (extend-ribcage! + ribcage + id + (cons (syntax-object-module id) (wrap var '((top)) mod)))))) + (macro-introduced-identifier? + (lambda (id) (not (equal? (car (syntax-object-wrap id)) '(top))))) + (fresh-derived-name + (lambda (id orig-form) + (symbol-append + (syntax-object-expression id) + '- + (string->symbol + (number->string + (hash (syntax->datum orig-form) most-positive-fixnum) + 16))))) + (parse (lambda (body r w s m esew mod) + (let lp ((body body) (exps '())) + (if (null? body) + exps + (lp (cdr body) (append (parse1 (car body) r w s m esew mod) exps)))))) + (parse1 + (lambda (x r w s m esew mod) + (call-with-values + (lambda () (syntax-type x r w (source-annotation x) ribcage mod #f)) + (lambda (type value form e w s mod) + (let ((key type)) + (cond ((memv key '(define-form)) + (let* ((id (wrap value w mod)) + (label (gen-label)) + (var (if (macro-introduced-identifier? id) + (fresh-derived-name id x) + (syntax-object-expression id)))) + (record-definition! id var) + (list (if (eq? m 'c&e) + (let ((x (build-global-definition s var (expand e r w mod)))) + (top-level-eval-hook x mod) + (lambda () x)) + (lambda () (build-global-definition s var (expand e r w mod))))))) + ((memv key '(define-syntax-form define-syntax-parameter-form)) + (let* ((id (wrap value w mod)) + (label (gen-label)) + (var (if (macro-introduced-identifier? id) + (fresh-derived-name id x) + (syntax-object-expression id)))) + (record-definition! id var) + (let ((key m)) + (cond ((memv key '(c)) + (cond ((memq 'compile esew) + (let ((e (expand-install-global var type (expand e r w mod)))) + (top-level-eval-hook e mod) + (if (memq 'load esew) (list (lambda () e)) '()))) + ((memq 'load esew) + (list (lambda () (expand-install-global var type (expand e r w mod))))) + (else '()))) + ((memv key '(c&e)) + (let ((e (expand-install-global var type (expand e r w mod)))) + (top-level-eval-hook e mod) + (list (lambda () e)))) + (else + (if (memq 'eval esew) + (top-level-eval-hook + (expand-install-global var type (expand e r w mod)) + mod)) + '()))))) + ((memv key '(begin-form)) + (let* ((tmp-1 e) (tmp ($sc-dispatch tmp-1 '(_ . each-any)))) + (if tmp + (apply (lambda (e1) (parse e1 r w s m esew mod)) tmp) + (syntax-violation + #f + "source expression failed to match any pattern" + tmp-1)))) + ((memv key '(local-syntax-form)) + (expand-local-syntax + value + e + r + w + s + mod + (lambda (forms r w s mod) (parse forms r w s m esew mod)))) + ((memv key '(eval-when-form)) + (let* ((tmp-1 e) (tmp ($sc-dispatch tmp-1 '(_ each-any any . each-any)))) + (if tmp + (apply (lambda (x e1 e2) + (let ((when-list (parse-when-list e x)) (body (cons e1 e2))) + (letrec* + ((recurse (lambda (m esew) (parse body r w s m esew mod)))) + (cond ((eq? m 'e) + (if (memq 'eval when-list) + (recurse (if (memq 'expand when-list) 'c&e 'e) '(eval)) + (begin + (if (memq 'expand when-list) (top-level-eval-hook (expand-top-sequence body r w s 'e '(eval) mod) - mod) - (values exps)) - (else (values exps))))) - tmp) - (syntax-violation - #f - "source expression failed to match any pattern" - tmp-1)))) - ((memv key '(define-syntax-form define-syntax-parameter-form)) - (let ((n (id-var-name value w)) (r (macros-only-env r))) - (let ((key m)) - (cond ((memv key '(c)) - (cond ((memq 'compile esew) - (let ((e (expand-install-global n (expand e r w mod)))) - (top-level-eval-hook e mod) - (if (memq 'load esew) (values (cons e exps)) (values exps)))) - ((memq 'load esew) - (values - (cons (expand-install-global n (expand e r w mod)) exps))) - (else (values exps)))) - ((memv key '(c&e)) - (let ((e (expand-install-global n (expand e r w mod)))) - (top-level-eval-hook e mod) - (values (cons e exps)))) - (else - (if (memq 'eval esew) - (top-level-eval-hook - (expand-install-global n (expand e r w mod)) - mod)) - (values exps)))))) - ((memv key '(define-form)) - (let* ((n (id-var-name value w)) (type (car (lookup n r mod))) (key type)) - (cond ((memv key '(global core macro module-ref)) - (if (and (memq m '(c c&e)) - (not (module-local-variable (current-module) n)) - (current-module)) - (let ((old (module-variable (current-module) n))) - (if (and (variable? old) (variable-bound? old)) - (module-define! (current-module) n (variable-ref old)) - (module-add! (current-module) n (make-undefined-variable))))) - (values - (cons (if (eq? m 'c&e) - (let ((x (build-global-definition s n (expand e r w mod)))) - (top-level-eval-hook x mod) - x) - (lambda () (build-global-definition s n (expand e r w mod)))) - exps))) - ((memv key '(displaced-lexical)) - (syntax-violation - #f - "identifier out of context" - (source-wrap form w s mod) - (wrap value w mod))) - (else - (syntax-violation - #f - "cannot define keyword at top level" - (source-wrap form w s mod) - (wrap value w mod)))))) - (else - (values - (cons (if (eq? m 'c&e) - (let ((x (expand-expr type value form e r w s mod))) - (top-level-eval-hook x mod) - x) - (lambda () (expand-expr type value form e r w s mod))) - exps)))))))) - (lambda (exps) (scan (cdr body) r w s m esew mod exps))))))) - (call-with-values - (lambda () (scan body r w s m esew mod '())) - (lambda (exps) - (if (null? exps) - (build-void s) - (build-sequence - s - (let lp ((in exps) (out '())) - (if (null? in) - out - (let ((e (car in))) - (lp (cdr in) (cons (if (procedure? e) (e) e) out)))))))))))) + mod)) + '()))) + ((memq 'load when-list) + (cond ((or (memq 'compile when-list) + (memq 'expand when-list) + (and (eq? m 'c&e) (memq 'eval when-list))) + (recurse 'c&e '(compile load))) + ((memq m '(c c&e)) (recurse 'c '(load))) + (else '()))) + ((or (memq 'compile when-list) + (memq 'expand when-list) + (and (eq? m 'c&e) (memq 'eval when-list))) + (top-level-eval-hook + (expand-top-sequence body r w s 'e '(eval) mod) + mod) + '()) + (else '()))))) + tmp) + (syntax-violation + #f + "source expression failed to match any pattern" + tmp-1)))) + (else + (list (if (eq? m 'c&e) + (let ((x (expand-expr type value form e r w s mod))) + (top-level-eval-hook x mod) + (lambda () x)) + (lambda () (expand-expr type value form e r w s mod)))))))))))) + (let ((exps (map (lambda (x) (x)) (reverse (parse body r w s m esew mod))))) + (if (null? exps) (build-void s) (build-sequence s exps))))))) (expand-install-global - (lambda (name e) + (lambda (name type e) (build-global-definition #f name - (build-application + (build-primcall #f - (build-primref #f 'make-syntax-transformer) - (list (build-data #f name) (build-data #f 'macro) e))))) + 'make-syntax-transformer + (if (eq? type 'define-syntax-parameter-form) + (list (build-data #f name) + (build-data #f 'syntax-parameter) + (build-primcall #f 'list (list e))) + (list (build-data #f name) (build-data #f 'macro) e)))))) (parse-when-list (lambda (e when-list) (let ((result (strip when-list '(())))) @@ -691,24 +711,23 @@ (syntax-type (lambda (e r w s rib mod for-car?) (cond ((symbol? e) - (let* ((n (id-var-name e w)) - (b (lookup n r mod)) - (type (car b)) - (key type)) - (cond ((memv key '(lexical)) (values type (cdr b) e e w s mod)) - ((memv key '(global)) (values type n e e w s mod)) - ((memv key '(macro)) - (if for-car? - (values type (cdr b) e e w s mod) - (syntax-type - (expand-macro (cdr b) e r w s rib mod) - r - '(()) - s - rib - mod - #f))) - (else (values type (cdr b) e e w s mod))))) + (call-with-values + (lambda () (resolve-identifier e w r mod #t)) + (lambda (type value mod*) + (let ((key type)) + (cond ((memv key '(macro)) + (if for-car? + (values type value e e w s mod) + (syntax-type + (expand-macro value e r w s rib mod) + r + '(()) + s + rib + mod + #f))) + ((memv key '(global)) (values type value e value w s mod*)) + (else (values type value e e w s mod))))))) ((pair? e) (let ((first (car e))) (call-with-values @@ -822,7 +841,7 @@ (lambda () (value e r w)) (lambda (e r w s mod) (expand e r w mod)))) ((memv key '(lexical-call)) - (expand-application + (expand-call (let ((id (car e))) (build-lexical-reference 'fun @@ -835,7 +854,7 @@ s mod)) ((memv key '(global-call)) - (expand-application + (expand-call (build-global-reference (source-annotation (car e)) (if (syntax-object? value) (syntax-object-expression value) value) @@ -849,7 +868,7 @@ (build-data s (strip (source-wrap e w s mod) '(())))) ((memv key '(global)) (build-global-reference s value mod)) ((memv key '(call)) - (expand-application (expand (car e) r w mod) e r w s mod)) + (expand-call (expand (car e) r w mod) e r w s mod)) ((memv key '(begin-form)) (let* ((tmp e) (tmp-1 ($sc-dispatch tmp '(_ any . each-any)))) (if tmp-1 @@ -858,15 +877,10 @@ (let ((tmp-1 ($sc-dispatch tmp '(_)))) (if tmp-1 (apply (lambda () - (if (include-deprecated-features) - (begin - (issue-deprecation-warning - "Sequences of zero expressions are deprecated. Use *unspecified*.") - (expand-void)) - (syntax-violation - #f - "sequence of zero expressions" - (source-wrap e w s mod)))) + (syntax-violation + #f + "sequence of zero expressions" + (source-wrap e w s mod))) tmp-1) (syntax-violation #f @@ -905,12 +919,12 @@ (source-wrap e w s mod))) (else (syntax-violation #f "unexpected syntax" (source-wrap e w s mod))))))) - (expand-application + (expand-call (lambda (x e r w s mod) (let* ((tmp-1 e) (tmp ($sc-dispatch tmp-1 '(any . each-any)))) (if tmp (apply (lambda (e0 e1) - (build-application s x (map (lambda (e) (expand e r w mod)) e1))) + (build-call s x (map (lambda (e) (expand e r w mod)) e1))) tmp) (syntax-violation #f @@ -990,7 +1004,7 @@ (cons var vars) (cons (cons er (wrap e w mod)) vals) (cons (cons 'lexical var) bindings))))) - ((memv key '(define-syntax-form define-syntax-parameter-form)) + ((memv key '(define-syntax-form)) (let ((id (wrap value w mod)) (label (gen-label)) (trans-r (macros-only-env er))) @@ -1002,6 +1016,19 @@ (list (cons 'macro (eval-local-transformer (expand e trans-r w mod) mod))) (cdr r))) (parse (cdr body) (cons id ids) labels var-ids vars vals bindings))) + ((memv key '(define-syntax-parameter-form)) + (let ((id (wrap value w mod)) + (label (gen-label)) + (trans-r (macros-only-env er))) + (extend-ribcage! ribcage id label) + (set-cdr! + r + (extend-env + (list label) + (list (cons 'syntax-parameter + (list (eval-local-transformer (expand e trans-r w mod) mod)))) + (cdr r))) + (parse (cdr body) (cons id ids) labels var-ids vars vals bindings))) ((memv key '(begin-form)) (let* ((tmp-1 e) (tmp ($sc-dispatch tmp-1 '(_ . each-any)))) (if tmp @@ -1516,28 +1543,34 @@ (tmp ($sc-dispatch tmp '(_ #(each (any any)) any . each-any)))) (if (and tmp (apply (lambda (var val e1 e2) (valid-bound-ids? var)) tmp)) (apply (lambda (var val e1 e2) - (let ((names (map (lambda (x) (id-var-name x w)) var))) - (for-each - (lambda (id n) - (let ((key (car (lookup n r mod)))) - (if (memv key '(displaced-lexical)) - (syntax-violation - 'syntax-parameterize - "identifier out of context" - e - (source-wrap id w s mod))))) - var - names) + (let ((names (map (lambda (x) + (call-with-values + (lambda () (resolve-identifier x w r mod #f)) + (lambda (type value mod) + (let ((key type)) + (cond ((memv key '(displaced-lexical)) + (syntax-violation + 'syntax-parameterize + "identifier out of context" + e + (source-wrap x w s mod))) + ((memv key '(syntax-parameter)) value) + (else + (syntax-violation + 'syntax-parameterize + "invalid syntax parameter" + e + (source-wrap x w s mod)))))))) + var)) + (bindings + (let ((trans-r (macros-only-env r))) + (map (lambda (x) + (cons 'macro (eval-local-transformer (expand x trans-r w mod) mod))) + val)))) (expand-body (cons e1 e2) (source-wrap e w s mod) - (extend-env - names - (let ((trans-r (macros-only-env r))) - (map (lambda (x) - (cons 'macro (eval-local-transformer (expand x trans-r w mod) mod))) - val)) - r) + (extend-env names bindings r) w mod))) tmp) @@ -1560,15 +1593,16 @@ ((gen-syntax (lambda (src e r maps ellipsis? mod) (if (id? e) - (let* ((label (id-var-name e '(()))) (b (lookup label r mod))) - (cond ((eq? (car b) 'syntax) - (call-with-values - (lambda () - (let ((var.lev (cdr b))) - (gen-ref src (car var.lev) (cdr var.lev) maps))) - (lambda (var maps) (values (list 'ref var) maps)))) - ((ellipsis? e) (syntax-violation 'syntax "misplaced ellipsis" src)) - (else (values (list 'quote e) maps)))) + (call-with-values + (lambda () (resolve-identifier e '(()) r mod #f)) + (lambda (type value mod) + (let ((key type)) + (cond ((memv key '(syntax)) + (call-with-values + (lambda () (gen-ref src (car value) (cdr value) maps)) + (lambda (var maps) (values (list 'ref var) maps)))) + ((ellipsis? e) (syntax-violation 'syntax "misplaced ellipsis" src)) + (else (values (list 'quote e) maps)))))) (let* ((tmp e) (tmp-1 ($sc-dispatch tmp '(any any)))) (if (and tmp-1 (apply (lambda (dots e) (ellipsis? dots)) tmp-1)) (apply (lambda (dots e) (gen-syntax src e r maps (lambda (x) #f) mod)) @@ -1678,8 +1712,7 @@ (if (list? (cadr x)) (build-simple-lambda #f (cadr x) #f (cadr x) '() (regen (caddr x))) (error "how did we get here" x))) - (else - (build-application #f (build-primref #f (car x)) (map regen (cdr x))))))))) + (else (build-primcall #f (car x) (map regen (cdr x))))))))) (lambda (e r w s mod) (let* ((e (source-wrap e w s mod)) (tmp e) @@ -1876,36 +1909,36 @@ (let* ((tmp-1 e) (tmp ($sc-dispatch tmp-1 '(_ any any)))) (if (and tmp (apply (lambda (id val) (id? id)) tmp)) (apply (lambda (id val) - (let ((n (id-var-name id w)) - (id-mod (if (syntax-object? id) (syntax-object-module id) mod))) - (let* ((b (lookup n r id-mod)) (key (car b))) - (cond ((memv key '(lexical)) - (build-lexical-assignment - s - (syntax->datum id) - (cdr b) - (expand val r w mod))) - ((memv key '(global)) - (build-global-assignment s n (expand val r w mod) id-mod)) - ((memv key '(macro)) - (let ((p (cdr b))) - (if (procedure-property p 'variable-transformer) - (expand (expand-macro p e r w s #f mod) r '(()) mod) + (call-with-values + (lambda () (resolve-identifier id w r mod #t)) + (lambda (type value id-mod) + (let ((key type)) + (cond ((memv key '(lexical)) + (build-lexical-assignment + s + (syntax->datum id) + value + (expand val r w mod))) + ((memv key '(global)) + (build-global-assignment s value (expand val r w mod) id-mod)) + ((memv key '(macro)) + (if (procedure-property value 'variable-transformer) + (expand (expand-macro value e r w s #f mod) r '(()) mod) (syntax-violation 'set! "not a variable transformer" (wrap e w mod) - (wrap id w id-mod))))) - ((memv key '(displaced-lexical)) - (syntax-violation 'set! "identifier out of context" (wrap id w mod))) - (else (syntax-violation 'set! "bad set!" (source-wrap e w s mod))))))) + (wrap id w id-mod)))) + ((memv key '(displaced-lexical)) + (syntax-violation 'set! "identifier out of context" (wrap id w mod))) + (else (syntax-violation 'set! "bad set!" (source-wrap e w s mod)))))))) tmp) (let ((tmp ($sc-dispatch tmp-1 '(_ (any . each-any) any)))) (if tmp (apply (lambda (head tail val) (call-with-values (lambda () (syntax-type head r '(()) #f #f mod #t)) - (lambda (type value formform ee ww ss modmod) + (lambda (type value ee* ee ww ss modmod) (let ((key type)) (if (memv key '(module-ref)) (let ((val (expand val r w mod))) @@ -1920,7 +1953,7 @@ #f "source expression failed to match any pattern" tmp-1)))))) - (build-application + (build-call s (expand (list '#(syntax-object setter ((top)) (hygiene guile)) head) @@ -2121,9 +2154,9 @@ (lambda (pvars exp y r mod) (let ((ids (map car pvars)) (levels (map cdr pvars))) (let ((labels (gen-labels ids)) (new-vars (map gen-var ids))) - (build-application + (build-primcall #f - (build-primref #f 'apply) + 'apply (list (build-simple-lambda #f (map syntax->datum ids) @@ -2152,7 +2185,7 @@ (syntax-violation 'syntax-case "misplaced ellipsis" pat)) (else (let ((y (gen-var 'tmp))) - (build-application + (build-call #f (build-simple-lambda #f @@ -2174,17 +2207,14 @@ (build-dispatch-call pvars exp y r mod) (gen-syntax-case x keys clauses r mod)))) (list (if (eq? p 'any) - (build-application #f (build-primref #f 'list) (list x)) - (build-application - #f - (build-primref #f '$sc-dispatch) - (list x (build-data #f p))))))))))))) + (build-primcall #f 'list (list x)) + (build-primcall #f '$sc-dispatch (list x (build-data #f p))))))))))))) (gen-syntax-case (lambda (x keys clauses r mod) (if (null? clauses) - (build-application + (build-primcall #f - (build-primref #f 'syntax-violation) + 'syntax-violation (list (build-data #f #f) (build-data #f "source expression failed to match any pattern") x)) @@ -2198,7 +2228,7 @@ (if (free-id=? pat '#(syntax-object _ ((top)) (hygiene guile))) (expand exp r '(()) mod) (let ((labels (list (gen-label))) (var (gen-var pat))) - (build-application + (build-call #f (build-simple-lambda #f @@ -2228,7 +2258,7 @@ (apply (lambda (val key m) (if (and-map (lambda (x) (and (id? x) (not (ellipsis? x)))) key) (let ((x (gen-var 'tmp))) - (build-application + (build-call s (build-simple-lambda #f @@ -2334,7 +2364,8 @@ (syntax-object-expression id) (strip-anti-mark (syntax-object-wrap id)) r - (syntax-object-module id))) + (syntax-object-module id) + #t)) (lambda (type value mod) (let ((key type)) (cond ((memv key '(lexical)) (values 'lexical value)) @@ -2537,13 +2568,22 @@ (vector '(#(syntax-object macro-type ((top)) (hygiene guile)) . - #(syntax-object syntax-rules ((top)) (hygiene guile))) + #(syntax-object + syntax-rules + ((top) + #(ribcage + #(syntax-rules) + #((top)) + #(((hygiene guile) + . + #(syntax-object syntax-rules ((top)) (hygiene guile)))))) + (hygiene guile))) (cons '#(syntax-object patterns ((top)) (hygiene guile)) pattern)) (cons '#(syntax-object syntax-case ((top)) (hygiene guile)) (cons '#(syntax-object x ((top)) (hygiene guile)) (cons k (map (lambda (tmp-1 tmp) - (list (cons '#(syntax-object dummy ((top)) (hygiene guile)) tmp) + (list (cons '#(syntax-object _ ((top)) (hygiene guile)) tmp) (list '#(syntax-object syntax ((top)) (hygiene guile)) tmp-1))) template @@ -2562,13 +2602,22 @@ (vector '(#(syntax-object macro-type ((top)) (hygiene guile)) . - #(syntax-object syntax-rules ((top)) (hygiene guile))) + #(syntax-object + syntax-rules + ((top) + #(ribcage + #(syntax-rules) + #((top)) + #(((hygiene guile) + . + #(syntax-object syntax-rules ((top)) (hygiene guile)))))) + (hygiene guile))) (cons '#(syntax-object patterns ((top)) (hygiene guile)) pattern)) (cons '#(syntax-object syntax-case ((top)) (hygiene guile)) (cons '#(syntax-object x ((top)) (hygiene guile)) (cons k (map (lambda (tmp-1 tmp) - (list (cons '#(syntax-object dummy ((top)) (hygiene guile)) tmp) + (list (cons '#(syntax-object _ ((top)) (hygiene guile)) tmp) (list '#(syntax-object syntax ((top)) (hygiene guile)) tmp-1))) template @@ -2668,11 +2717,32 @@ tmp-1) (let ((tmp-1 ($sc-dispatch tmp - '(#(free-id #(syntax-object quasiquote ((top)) (hygiene guile))) any)))) + '(#(free-id + #(syntax-object + quasiquote + ((top) + #(ribcage + #(quasiquote) + #((top)) + #(((hygiene guile) + . + #(syntax-object quasiquote ((top)) (hygiene guile)))))) + (hygiene guile))) + any)))) (if tmp-1 (apply (lambda (p) (quasicons - '("quote" #(syntax-object quasiquote ((top)) (hygiene guile))) + '("quote" + #(syntax-object + quasiquote + ((top) + #(ribcage + #(quasiquote) + #((top)) + #(((hygiene guile) + . + #(syntax-object quasiquote ((top)) (hygiene guile)))))) + (hygiene guile))) (quasi (list p) (+ lev 1)))) tmp-1) (let ((tmp-1 ($sc-dispatch tmp '(any . any)))) @@ -3056,7 +3126,16 @@ '(#(syntax-object x ((top)) (hygiene guile))) '#((#(syntax-object macro-type ((top)) (hygiene guile)) . - #(syntax-object identifier-syntax ((top)) (hygiene guile)))) + #(syntax-object + identifier-syntax + ((top) + #(ribcage + #(identifier-syntax) + #((top)) + #(((hygiene guile) + . + #(syntax-object identifier-syntax ((top)) (hygiene guile)))))) + (hygiene guile)))) (list '#(syntax-object syntax-case ((top)) (hygiene guile)) '#(syntax-object x ((top)) (hygiene guile)) '() diff --git a/module/ice-9/psyntax.scm b/module/ice-9/psyntax.scm index 565c91199..79f2fd41f 100644 --- a/module/ice-9/psyntax.scm +++ b/module/ice-9/psyntax.scm @@ -316,9 +316,9 @@ (lambda (source) (make-void source))) - (define build-application + (define build-call (lambda (source fun-exp arg-exps) - (make-application source fun-exp arg-exps))) + (make-call source fun-exp arg-exps))) (define build-conditional (lambda (source test-exp then-exp else-exp) @@ -405,12 +405,14 @@ (lambda (src req opt rest kw inits vars body else-case) (make-lambda-case src req opt rest kw inits vars body else-case))) + (define build-primcall + (lambda (src name args) + (make-primcall src name args))) + (define build-primref (lambda (src name) - (if (equal? (module-name (current-module)) '(guile)) - (make-toplevel-ref src name) - (make-module-ref src '(guile) name #f)))) - + (make-primitive-ref src name))) + (define (build-data src exp) (make-const src exp)) @@ -418,7 +420,7 @@ (lambda (src exps) (if (null? (cdr exps)) (car exps) - (make-sequence src exps)))) + (make-seq src (car exps) (build-sequence #f (cdr exps)))))) (define build-let (lambda (src ids vars val-exps body-exp) @@ -439,8 +441,8 @@ (make-letrec src #f (list f-name) (list f) (list proc) - (build-application src (build-lexical-reference 'fun src f-name f) - val-exps)))))) + (build-call src (build-lexical-reference 'fun src f-name f) + val-exps)))))) (define build-letrec (lambda (src in-order? ids vars val-exps body-exp) @@ -485,13 +487,14 @@ ;; global (assumed global variable) and displaced-lexical (see below) ;; do not show up in any environment; instead, they are fabricated by - ;; lookup when it finds no other bindings. + ;; resolve-identifier when it finds no other bindings. ;; <environment> ::= ((<label> . <binding>)*) ;; identifier bindings include a type and a value ;; <binding> ::= (macro . <procedure>) macros + ;; (syntax-parameter . (<procedure>)) syntax parameters ;; (core . <procedure>) core forms ;; (module-ref . <procedure>) @ or @@ ;; (begin) begin @@ -563,22 +566,10 @@ (if (null? r) '() (let ((a (car r))) - (if (eq? (cadr a) 'macro) + (if (memq (cadr a) '(macro syntax-parameter)) (cons a (macros-only-env (cdr r))) (macros-only-env (cdr r))))))) - (define lookup - ;; x may be a label or a symbol - ;; although symbols are usually global, we check the environment first - ;; anyway because a temporary binding may have been established by - ;; fluid-let-syntax - (lambda (x r mod) - (cond - ((assq x r) => cdr) - ((symbol? x) - (or (get-global-definition-hook x mod) (make-binding 'global))) - (else (make-binding 'displaced-lexical))))) - (define global-extend (lambda (type sym val) (put-global-definition-hook sym type val))) @@ -731,51 +722,86 @@ (same-marks? (cdr x) (cdr y)))))) (define id-var-name - (lambda (id w) + ;; Syntax objects use wraps to associate names with marked + ;; identifiers. This function returns the name corresponding to + ;; the given identifier and wrap, or the original identifier if no + ;; corresponding name was found. + ;; + ;; The name may be a string created by gen-label, indicating a + ;; lexical binding, or another syntax object, indicating a + ;; reference to a top-level definition created during a previous + ;; macroexpansion. + ;; + ;; For lexical variables, finding a label simply amounts to + ;; looking for an entry with the same symbolic name and the same + ;; marks. Finding a toplevel definition is the same, except we + ;; also have to compare modules, hence the `mod' parameter. + ;; Instead of adding a separate entry in the ribcage for modules, + ;; which wouldn't be used for lexicals, we arrange for the entry + ;; for the name entry to be a pair with the module in its car, and + ;; the name itself in the cdr. So if the name that we find is a + ;; pair, we have to check modules. + ;; + ;; The identifer may be passed in wrapped or unwrapped. In any + ;; case, this routine returns either a symbol, a syntax object, or + ;; a string label. + ;; + (lambda (id w mod) (define-syntax-rule (first e) ;; Rely on Guile's multiple-values truncation. e) (define search - (lambda (sym subst marks) + (lambda (sym subst marks mod) (if (null? subst) (values #f marks) (let ((fst (car subst))) (if (eq? fst 'shift) - (search sym (cdr subst) (cdr marks)) + (search sym (cdr subst) (cdr marks) mod) (let ((symnames (ribcage-symnames fst))) (if (vector? symnames) - (search-vector-rib sym subst marks symnames fst) - (search-list-rib sym subst marks symnames fst)))))))) + (search-vector-rib sym subst marks symnames fst mod) + (search-list-rib sym subst marks symnames fst mod)))))))) (define search-list-rib - (lambda (sym subst marks symnames ribcage) + (lambda (sym subst marks symnames ribcage mod) (let f ((symnames symnames) (i 0)) (cond - ((null? symnames) (search sym (cdr subst) marks)) + ((null? symnames) (search sym (cdr subst) marks mod)) ((and (eq? (car symnames) sym) (same-marks? marks (list-ref (ribcage-marks ribcage) i))) - (values (list-ref (ribcage-labels ribcage) i) marks)) + (let ((n (list-ref (ribcage-labels ribcage) i))) + (if (pair? n) + (if (equal? mod (car n)) + (values (cdr n) marks) + (f (cdr symnames) (fx+ i 1))) + (values n marks)))) (else (f (cdr symnames) (fx+ i 1))))))) (define search-vector-rib - (lambda (sym subst marks symnames ribcage) + (lambda (sym subst marks symnames ribcage mod) (let ((n (vector-length symnames))) (let f ((i 0)) (cond - ((fx= i n) (search sym (cdr subst) marks)) + ((fx= i n) (search sym (cdr subst) marks mod)) ((and (eq? (vector-ref symnames i) sym) (same-marks? marks (vector-ref (ribcage-marks ribcage) i))) - (values (vector-ref (ribcage-labels ribcage) i) marks)) + (let ((n (vector-ref (ribcage-labels ribcage) i))) + (if (pair? n) + (if (equal? mod (car n)) + (values (cdr n) marks) + (f (fx+ i 1))) + (values n marks)))) (else (f (fx+ i 1)))))))) (cond ((symbol? id) - (or (first (search id (wrap-subst w) (wrap-marks w))) id)) + (or (first (search id (wrap-subst w) (wrap-marks w) mod)) id)) ((syntax-object? id) (let ((id (syntax-object-expression id)) - (w1 (syntax-object-wrap id))) + (w1 (syntax-object-wrap id)) + (mod (syntax-object-module id))) (let ((marks (join-marks (wrap-marks w) (wrap-marks w1)))) - (call-with-values (lambda () (search id (wrap-subst w) marks)) + (call-with-values (lambda () (search id (wrap-subst w) marks mod)) (lambda (new-id marks) (or new-id - (first (search id (wrap-subst w1) marks)) + (first (search id (wrap-subst w1) marks mod)) id)))))) (else (syntax-violation 'id-var-name "invalid id" id))))) @@ -830,19 +856,31 @@ ;; Returns three values: binding type, binding value, the module (for ;; resolving toplevel vars). - (define (resolve-identifier id w r mod) + (define (resolve-identifier id w r mod resolve-syntax-parameters?) + (define (resolve-syntax-parameters b) + (if (and resolve-syntax-parameters? + (eq? (binding-type b) 'syntax-parameter)) + (or (assq-ref r (binding-value b)) + (make-binding 'macro (car (binding-value b)))) + b)) (define (resolve-global var mod) - (let ((b (or (get-global-definition-hook var mod) - (make-binding 'global)))) + (let ((b (resolve-syntax-parameters + (or (get-global-definition-hook var mod) + (make-binding 'global))))) (if (eq? (binding-type b) 'global) (values 'global var mod) (values (binding-type b) (binding-value b) mod)))) (define (resolve-lexical label mod) - (let ((b (or (assq-ref r label) - (make-binding 'displaced-lexical)))) + (let ((b (resolve-syntax-parameters + (or (assq-ref r label) + (make-binding 'displaced-lexical))))) (values (binding-type b) (binding-value b) mod))) - (let ((n (id-var-name id w))) + (let ((n (id-var-name id w mod))) (cond + ((syntax-object? n) + ;; Recursing allows syntax-parameterize to override + ;; macro-introduced syntax parameters. + (resolve-identifier n w r mod resolve-syntax-parameters?)) ((symbol? n) (resolve-global n (if (syntax-object? id) (syntax-object-module id) @@ -867,9 +905,39 @@ (define free-id=? (lambda (i j) - (and (eq? (id-sym-name i) (id-sym-name j)) ; accelerator - (eq? (id-var-name i empty-wrap) (id-var-name j empty-wrap))))) - + (let* ((mi (and (syntax-object? i) (syntax-object-module i))) + (mj (and (syntax-object? j) (syntax-object-module j))) + (ni (id-var-name i empty-wrap mi)) + (nj (id-var-name j empty-wrap mj))) + (define (id-module-binding id mod) + (module-variable + (if mod + ;; The normal case. + (resolve-module (cdr mod)) + ;; Either modules have not been booted, or we have a + ;; raw symbol coming in, which is possible. + (current-module)) + (id-sym-name id))) + (cond + ((syntax-object? ni) (free-id=? ni j)) + ((syntax-object? nj) (free-id=? i nj)) + ((symbol? ni) + ;; `i' is not lexically bound. Assert that `j' is free, + ;; and if so, compare their bindings, that they are either + ;; bound to the same variable, or both unbound and have + ;; the same name. + (and (eq? nj (id-sym-name j)) + (let ((bi (id-module-binding i mi))) + (if bi + (eq? bi (id-module-binding j mj)) + (and (not (id-module-binding j mj)) + (eq? ni nj)))) + (eq? (id-module-binding i mi) (id-module-binding j mj)))) + (else + ;; Otherwise `i' is bound, so check that `j' is bound, and + ;; bound to the same thing. + (equal? ni nj)))))) + ;; bound-id=? may be passed unwrapped (or partially wrapped) ids as ;; long as the missing portion of the wrap is common to both of the ids ;; since (bound-id=? x y) iff (bound-id=? (wrap x w) (wrap y w)) @@ -960,161 +1028,171 @@ ;; (define expand-top-sequence (lambda (body r w s m esew mod) - (define (scan body r w s m esew mod exps) - (cond - ((null? body) - ;; in reversed order - exps) - (else + (let* ((r (cons '("placeholder" . (placeholder)) r)) + (ribcage (make-empty-ribcage)) + (w (make-wrap (wrap-marks w) (cons ribcage (wrap-subst w))))) + (define (record-definition! id var) + (let ((mod (cons 'hygiene (module-name (current-module))))) + ;; Ribcages map symbol+marks to names, mostly for + ;; resolving lexicals. Here to add a mapping for toplevel + ;; definitions we also need to match the module. So, we + ;; put it in the name instead, and make id-var-name handle + ;; the special case of names that are pairs. See the + ;; comments in id-var-name for more. + (extend-ribcage! ribcage id + (cons (syntax-object-module id) + (wrap var top-wrap mod))))) + (define (macro-introduced-identifier? id) + (not (equal? (wrap-marks (syntax-object-wrap id)) '(top)))) + (define (fresh-derived-name id orig-form) + (symbol-append + (syntax-object-expression id) + '- + (string->symbol + ;; FIXME: `hash' currently stops descending into nested + ;; data at some point, so it's less unique than we would + ;; like. Also this encodes hash values into the ABI of + ;; compiled modules; a problem? + (number->string + (hash (syntax->datum orig-form) most-positive-fixnum) + 16)))) + (define (parse body r w s m esew mod) + (let lp ((body body) (exps '())) + (if (null? body) + exps + (lp (cdr body) + (append (parse1 (car body) r w s m esew mod) + exps))))) + (define (parse1 x r w s m esew mod) (call-with-values (lambda () - (call-with-values - (lambda () - (let ((e (car body))) - (syntax-type e r w (or (source-annotation e) s) #f mod #f))) - (lambda (type value form e w s mod) - (case type - ((begin-form) - (syntax-case e () - ((_) exps) - ((_ e1 e2 ...) - (scan #'(e1 e2 ...) r w s m esew mod exps)))) - ((local-syntax-form) - (expand-local-syntax value e r w s mod - (lambda (body r w s mod) - (scan body r w s m esew mod exps)))) - ((eval-when-form) - (syntax-case e () - ((_ (x ...) e1 e2 ...) - (let ((when-list (parse-when-list e #'(x ...))) - (body #'(e1 e2 ...))) - (cond - ((eq? m 'e) - (if (memq 'eval when-list) - (scan body r w s - (if (memq 'expand when-list) 'c&e 'e) - '(eval) - mod exps) - (begin - (if (memq 'expand when-list) - (top-level-eval-hook - (expand-top-sequence body r w s 'e '(eval) mod) - mod)) - (values exps)))) - ((memq 'load when-list) - (if (or (memq 'compile when-list) - (memq 'expand when-list) - (and (eq? m 'c&e) (memq 'eval when-list))) - (scan body r w s 'c&e '(compile load) mod exps) - (if (memq m '(c c&e)) - (scan body r w s 'c '(load) mod exps) - (values exps)))) - ((or (memq 'compile when-list) - (memq 'expand when-list) - (and (eq? m 'c&e) (memq 'eval when-list))) - (top-level-eval-hook - (expand-top-sequence body r w s 'e '(eval) mod) - mod) - (values exps)) - (else - (values exps))))))) - ((define-syntax-form define-syntax-parameter-form) - (let ((n (id-var-name value w)) (r (macros-only-env r))) - (case m - ((c) - (if (memq 'compile esew) - (let ((e (expand-install-global n (expand e r w mod)))) - (top-level-eval-hook e mod) - (if (memq 'load esew) - (values (cons e exps)) - (values exps))) - (if (memq 'load esew) - (values (cons (expand-install-global n (expand e r w mod)) - exps)) - (values exps)))) - ((c&e) - (let ((e (expand-install-global n (expand e r w mod)))) - (top-level-eval-hook e mod) - (values (cons e exps)))) - (else - (if (memq 'eval esew) - (top-level-eval-hook - (expand-install-global n (expand e r w mod)) - mod)) - (values exps))))) - ((define-form) - (let* ((n (id-var-name value w)) - ;; Lookup the name in the module of the define form. - (type (binding-type (lookup n r mod)))) - (case type - ((global core macro module-ref) - ;; affect compile-time environment (once we have booted) - (if (and (memq m '(c c&e)) - (not (module-local-variable (current-module) n)) - (current-module)) - (let ((old (module-variable (current-module) n))) - ;; use value of the same-named imported variable, if - ;; any - (if (and (variable? old) (variable-bound? old)) - (module-define! (current-module) n (variable-ref old)) - (module-add! (current-module) n (make-undefined-variable))))) - (values - (cons - (if (eq? m 'c&e) - (let ((x (build-global-definition s n (expand e r w mod)))) - (top-level-eval-hook x mod) - x) - (lambda () - (build-global-definition s n (expand e r w mod)))) - exps))) - ((displaced-lexical) - (syntax-violation #f "identifier out of context" - (source-wrap form w s mod) - (wrap value w mod))) - (else - (syntax-violation #f "cannot define keyword at top level" - (source-wrap form w s mod) - (wrap value w mod)))))) - (else - (values (cons - (if (eq? m 'c&e) - (let ((x (expand-expr type value form e r w s mod))) - (top-level-eval-hook x mod) - x) - (lambda () - (expand-expr type value form e r w s mod))) - exps))))))) - (lambda (exps) - (scan (cdr body) r w s m esew mod exps)))))) - - (call-with-values (lambda () - (scan body r w s m esew mod '())) - (lambda (exps) + (syntax-type x r w (source-annotation x) ribcage mod #f)) + (lambda (type value form e w s mod) + (case type + ((define-form) + (let* ((id (wrap value w mod)) + (label (gen-label)) + (var (if (macro-introduced-identifier? id) + (fresh-derived-name id x) + (syntax-object-expression id)))) + (record-definition! id var) + (list + (if (eq? m 'c&e) + (let ((x (build-global-definition s var (expand e r w mod)))) + (top-level-eval-hook x mod) + (lambda () x)) + (lambda () + (build-global-definition s var (expand e r w mod))))))) + ((define-syntax-form define-syntax-parameter-form) + (let* ((id (wrap value w mod)) + (label (gen-label)) + (var (if (macro-introduced-identifier? id) + (fresh-derived-name id x) + (syntax-object-expression id)))) + (record-definition! id var) + (case m + ((c) + (cond + ((memq 'compile esew) + (let ((e (expand-install-global var type (expand e r w mod)))) + (top-level-eval-hook e mod) + (if (memq 'load esew) + (list (lambda () e)) + '()))) + ((memq 'load esew) + (list (lambda () + (expand-install-global var type (expand e r w mod))))) + (else '()))) + ((c&e) + (let ((e (expand-install-global var type (expand e r w mod)))) + (top-level-eval-hook e mod) + (list (lambda () e)))) + (else + (if (memq 'eval esew) + (top-level-eval-hook + (expand-install-global var type (expand e r w mod)) + mod)) + '())))) + ((begin-form) + (syntax-case e () + ((_ e1 ...) + (parse #'(e1 ...) r w s m esew mod)))) + ((local-syntax-form) + (expand-local-syntax value e r w s mod + (lambda (forms r w s mod) + (parse forms r w s m esew mod)))) + ((eval-when-form) + (syntax-case e () + ((_ (x ...) e1 e2 ...) + (let ((when-list (parse-when-list e #'(x ...))) + (body #'(e1 e2 ...))) + (define (recurse m esew) + (parse body r w s m esew mod)) + (cond + ((eq? m 'e) + (if (memq 'eval when-list) + (recurse (if (memq 'expand when-list) 'c&e 'e) + '(eval)) + (begin + (if (memq 'expand when-list) + (top-level-eval-hook + (expand-top-sequence body r w s 'e '(eval) mod) + mod)) + '()))) + ((memq 'load when-list) + (if (or (memq 'compile when-list) + (memq 'expand when-list) + (and (eq? m 'c&e) (memq 'eval when-list))) + (recurse 'c&e '(compile load)) + (if (memq m '(c c&e)) + (recurse 'c '(load)) + '()))) + ((or (memq 'compile when-list) + (memq 'expand when-list) + (and (eq? m 'c&e) (memq 'eval when-list))) + (top-level-eval-hook + (expand-top-sequence body r w s 'e '(eval) mod) + mod) + '()) + (else + '())))))) + (else + (list + (if (eq? m 'c&e) + (let ((x (expand-expr type value form e r w s mod))) + (top-level-eval-hook x mod) + (lambda () x)) + (lambda () + (expand-expr type value form e r w s mod))))))))) + (let ((exps (map (lambda (x) (x)) + (reverse (parse body r w s m esew mod))))) (if (null? exps) (build-void s) - (build-sequence - s - (let lp ((in exps) (out '())) - (if (null? in) out - (let ((e (car in))) - (lp (cdr in) - (cons (if (procedure? e) (e) e) out))))))))))) + (build-sequence s exps)))))) (define expand-install-global - (lambda (name e) + (lambda (name type e) (build-global-definition no-source name - (build-application + (build-primcall no-source - (build-primref no-source 'make-syntax-transformer) - (list (build-data no-source name) - (build-data no-source 'macro) - e))))) - + 'make-syntax-transformer + (if (eq? type 'define-syntax-parameter-form) + (list (build-data no-source name) + (build-data no-source 'syntax-parameter) + (build-primcall no-source 'list (list e))) + (list (build-data no-source name) + (build-data no-source 'macro) + e)))))) + (define parse-when-list (lambda (e when-list) - ;; when-list is syntax'd version of list of situations + ;; `when-list' is syntax'd version of list of situations. We + ;; could match these keywords lexically, via free-id=?, but then + ;; we twingle the definition of eval-when to the bindings of + ;; eval, load, expand, and compile, which is totally unintended. + ;; So do a symbolic match instead. (let ((result (strip when-list empty-wrap))) (let lp ((l result)) (if (null? l) @@ -1168,18 +1246,19 @@ (lambda (e r w s rib mod for-car?) (cond ((symbol? e) - (let* ((n (id-var-name e w)) - (b (lookup n r mod)) - (type (binding-type b))) - (case type - ((lexical) (values type (binding-value b) e e w s mod)) - ((global) (values type n e e w s mod)) - ((macro) - (if for-car? - (values type (binding-value b) e e w s mod) - (syntax-type (expand-macro (binding-value b) e r w s rib mod) - r empty-wrap s rib mod #f))) - (else (values type (binding-value b) e e w s mod))))) + (call-with-values (lambda () (resolve-identifier e w r mod #t)) + (lambda (type value mod*) + (case type + ((macro) + (if for-car? + (values type value e e w s mod) + (syntax-type (expand-macro value e r w s rib mod) + r empty-wrap s rib mod #f))) + ((global) + ;; Toplevel definitions may resolve to bindings with + ;; different names or in different modules. + (values type value e value w s mod*)) + (else (values type value e e w s mod)))))) ((pair? e) (let ((first (car e))) (call-with-values @@ -1271,7 +1350,7 @@ (lambda (e r w s mod) (expand e r w mod)))) ((lexical-call) - (expand-application + (expand-call (let ((id (car e))) (build-lexical-reference 'fun (source-annotation id) (if (syntax-object? id) @@ -1280,7 +1359,7 @@ value)) e r w s mod)) ((global-call) - (expand-application + (expand-call (build-global-reference (source-annotation (car e)) (if (syntax-object? value) (syntax-object-expression value) @@ -1291,18 +1370,13 @@ e r w s mod)) ((constant) (build-data s (strip (source-wrap e w s mod) empty-wrap))) ((global) (build-global-reference s value mod)) - ((call) (expand-application (expand (car e) r w mod) e r w s mod)) + ((call) (expand-call (expand (car e) r w mod) e r w s mod)) ((begin-form) (syntax-case e () ((_ e1 e2 ...) (expand-sequence #'(e1 e2 ...) r w s mod)) ((_) - (if (include-deprecated-features) - (begin - (issue-deprecation-warning - "Sequences of zero expressions are deprecated. Use *unspecified*.") - (expand-void)) - (syntax-violation #f "sequence of zero expressions" - (source-wrap e w s mod)))))) + (syntax-violation #f "sequence of zero expressions" + (source-wrap e w s mod))))) ((local-syntax-form) (expand-local-syntax value e r w s mod expand-sequence)) ((eval-when-form) @@ -1324,12 +1398,12 @@ (else (syntax-violation #f "unexpected syntax" (source-wrap e w s mod)))))) - (define expand-application + (define expand-call (lambda (x e r w s mod) (syntax-case e () ((e0 e1 ...) - (build-application s x - (map (lambda (e) (expand e r w mod)) #'(e1 ...))))))) + (build-call s x + (map (lambda (e) (expand e r w mod)) #'(e1 ...))))))) ;; (What follows is my interpretation of what's going on here -- Andy) ;; @@ -1354,7 +1428,7 @@ ;; ;; The only wrinkle is when we want a macro to expand to code in another ;; module, as is the case for the r6rs `library' form -- the body expressions - ;; should be scoped relative the new module, the one defined by the macro. + ;; should be scoped relative the the new module, the one defined by the macro. ;; For that, use `(@@ mod-name body)'. ;; ;; Part of the macro output will be from the site of the macro use and part @@ -1469,7 +1543,7 @@ (cons id var-ids) (cons var vars) (cons (cons er (wrap e w mod)) vals) (cons (make-binding 'lexical var) bindings))))) - ((define-syntax-form define-syntax-parameter-form) + ((define-syntax-form) (let ((id (wrap value w mod)) (label (gen-label)) (trans-r (macros-only-env er))) @@ -1479,12 +1553,29 @@ ;; compile-time environment immediately, so that the newly-defined ;; keywords may be used in definition context within the same ;; lexical contour. - (set-cdr! r (extend-env (list label) - (list (make-binding 'macro - (eval-local-transformer - (expand e trans-r w mod) - mod))) - (cdr r))) + (set-cdr! r (extend-env + (list label) + (list (make-binding + 'macro + (eval-local-transformer + (expand e trans-r w mod) + mod))) + (cdr r))) + (parse (cdr body) (cons id ids) labels var-ids vars vals bindings))) + ((define-syntax-parameter-form) + ;; Same as define-syntax-form, but different format of the binding. + (let ((id (wrap value w mod)) + (label (gen-label)) + (trans-r (macros-only-env er))) + (extend-ribcage! ribcage id label) + (set-cdr! r (extend-env + (list label) + (list (make-binding + 'syntax-parameter + (list (eval-local-transformer + (expand e trans-r w mod) + mod)))) + (cdr r))) (parse (cdr body) (cons id ids) labels var-ids vars vals bindings))) ((begin-form) (syntax-case e () @@ -1840,38 +1931,45 @@ (global-extend 'local-syntax 'letrec-syntax #t) (global-extend 'local-syntax 'let-syntax #f) - (global-extend 'core 'syntax-parameterize - (lambda (e r w s mod) - (syntax-case e () - ((_ ((var val) ...) e1 e2 ...) - (valid-bound-ids? #'(var ...)) - (let ((names (map (lambda (x) (id-var-name x w)) #'(var ...)))) - (for-each - (lambda (id n) - (case (binding-type (lookup n r mod)) - ((displaced-lexical) - (syntax-violation 'syntax-parameterize - "identifier out of context" - e - (source-wrap id w s mod))))) - #'(var ...) - names) - (expand-body - #'(e1 e2 ...) - (source-wrap e w s mod) - (extend-env - names - (let ((trans-r (macros-only-env r))) - (map (lambda (x) - (make-binding 'macro - (eval-local-transformer (expand x trans-r w mod) - mod))) - #'(val ...))) - r) - w - mod))) - (_ (syntax-violation 'syntax-parameterize "bad syntax" - (source-wrap e w s mod)))))) + (global-extend + 'core 'syntax-parameterize + (lambda (e r w s mod) + (syntax-case e () + ((_ ((var val) ...) e1 e2 ...) + (valid-bound-ids? #'(var ...)) + (let ((names + (map (lambda (x) + (call-with-values + (lambda () (resolve-identifier x w r mod #f)) + (lambda (type value mod) + (case type + ((displaced-lexical) + (syntax-violation 'syntax-parameterize + "identifier out of context" + e + (source-wrap x w s mod))) + ((syntax-parameter) + value) + (else + (syntax-violation 'syntax-parameterize + "invalid syntax parameter" + e + (source-wrap x w s mod))))))) + #'(var ...))) + (bindings + (let ((trans-r (macros-only-env r))) + (map (lambda (x) + (make-binding + 'macro + (eval-local-transformer (expand x trans-r w mod) mod))) + #'(val ...))))) + (expand-body #'(e1 e2 ...) + (source-wrap e w s mod) + (extend-env names bindings r) + w + mod))) + (_ (syntax-violation 'syntax-parameterize "bad syntax" + (source-wrap e w s mod)))))) (global-extend 'core 'quote (lambda (e r w s mod) @@ -1880,167 +1978,166 @@ (_ (syntax-violation 'quote "bad syntax" (source-wrap e w s mod)))))) - (global-extend 'core 'syntax - (let () - (define gen-syntax - (lambda (src e r maps ellipsis? mod) - (if (id? e) - (let ((label (id-var-name e empty-wrap))) - ;; Mod does not matter, we are looking to see if - ;; the id is lexical syntax. - (let ((b (lookup label r mod))) - (if (eq? (binding-type b) 'syntax) - (call-with-values - (lambda () - (let ((var.lev (binding-value b))) - (gen-ref src (car var.lev) (cdr var.lev) maps))) - (lambda (var maps) (values `(ref ,var) maps))) - (if (ellipsis? e) - (syntax-violation 'syntax "misplaced ellipsis" src) - (values `(quote ,e) maps))))) - (syntax-case e () - ((dots e) - (ellipsis? #'dots) - (gen-syntax src #'e r maps (lambda (x) #f) mod)) - ((x dots . y) - ;; this could be about a dozen lines of code, except that we - ;; choose to handle #'(x ... ...) forms - (ellipsis? #'dots) - (let f ((y #'y) - (k (lambda (maps) - (call-with-values - (lambda () - (gen-syntax src #'x r - (cons '() maps) ellipsis? mod)) - (lambda (x maps) - (if (null? (car maps)) - (syntax-violation 'syntax "extra ellipsis" - src) - (values (gen-map x (car maps)) - (cdr maps)))))))) - (syntax-case y () - ((dots . y) - (ellipsis? #'dots) - (f #'y - (lambda (maps) - (call-with-values - (lambda () (k (cons '() maps))) - (lambda (x maps) - (if (null? (car maps)) - (syntax-violation 'syntax "extra ellipsis" src) - (values (gen-mappend x (car maps)) - (cdr maps)))))))) - (_ (call-with-values - (lambda () (gen-syntax src y r maps ellipsis? mod)) - (lambda (y maps) - (call-with-values - (lambda () (k maps)) - (lambda (x maps) - (values (gen-append x y) maps))))))))) - ((x . y) - (call-with-values - (lambda () (gen-syntax src #'x r maps ellipsis? mod)) - (lambda (x maps) - (call-with-values - (lambda () (gen-syntax src #'y r maps ellipsis? mod)) - (lambda (y maps) (values (gen-cons x y) maps)))))) - (#(e1 e2 ...) - (call-with-values - (lambda () - (gen-syntax src #'(e1 e2 ...) r maps ellipsis? mod)) - (lambda (e maps) (values (gen-vector e) maps)))) - (_ (values `(quote ,e) maps)))))) - - (define gen-ref - (lambda (src var level maps) - (if (fx= level 0) - (values var maps) - (if (null? maps) - (syntax-violation 'syntax "missing ellipsis" src) - (call-with-values - (lambda () (gen-ref src var (fx- level 1) (cdr maps))) - (lambda (outer-var outer-maps) - (let ((b (assq outer-var (car maps)))) - (if b - (values (cdr b) maps) - (let ((inner-var (gen-var 'tmp))) - (values inner-var - (cons (cons (cons outer-var inner-var) - (car maps)) - outer-maps))))))))))) - - (define gen-mappend - (lambda (e map-env) - `(apply (primitive append) ,(gen-map e map-env)))) - - (define gen-map - (lambda (e map-env) - (let ((formals (map cdr map-env)) - (actuals (map (lambda (x) `(ref ,(car x))) map-env))) - (cond - ((eq? (car e) 'ref) - ;; identity map equivalence: - ;; (map (lambda (x) x) y) == y - (car actuals)) - ((and-map - (lambda (x) (and (eq? (car x) 'ref) (memq (cadr x) formals))) - (cdr e)) - ;; eta map equivalence: - ;; (map (lambda (x ...) (f x ...)) y ...) == (map f y ...) - `(map (primitive ,(car e)) - ,@(map (let ((r (map cons formals actuals))) - (lambda (x) (cdr (assq (cadr x) r)))) - (cdr e)))) - (else `(map (lambda ,formals ,e) ,@actuals)))))) - - (define gen-cons - (lambda (x y) - (case (car y) - ((quote) - (if (eq? (car x) 'quote) - `(quote (,(cadr x) . ,(cadr y))) - (if (eq? (cadr y) '()) - `(list ,x) - `(cons ,x ,y)))) - ((list) `(list ,x ,@(cdr y))) - (else `(cons ,x ,y))))) - - (define gen-append - (lambda (x y) - (if (equal? y '(quote ())) - x - `(append ,x ,y)))) - - (define gen-vector - (lambda (x) - (cond - ((eq? (car x) 'list) `(vector ,@(cdr x))) - ((eq? (car x) 'quote) `(quote #(,@(cadr x)))) - (else `(list->vector ,x))))) - - - (define regen - (lambda (x) - (case (car x) - ((ref) (build-lexical-reference 'value no-source (cadr x) (cadr x))) - ((primitive) (build-primref no-source (cadr x))) - ((quote) (build-data no-source (cadr x))) - ((lambda) - (if (list? (cadr x)) - (build-simple-lambda no-source (cadr x) #f (cadr x) '() (regen (caddr x))) - (error "how did we get here" x))) - (else (build-application no-source - (build-primref no-source (car x)) - (map regen (cdr x))))))) - - (lambda (e r w s mod) - (let ((e (source-wrap e w s mod))) - (syntax-case e () - ((_ x) + (global-extend + 'core 'syntax + (let () + (define gen-syntax + (lambda (src e r maps ellipsis? mod) + (if (id? e) + (call-with-values (lambda () + (resolve-identifier e empty-wrap r mod #f)) + (lambda (type value mod) + (case type + ((syntax) + (call-with-values + (lambda () (gen-ref src (car value) (cdr value) maps)) + (lambda (var maps) + (values `(ref ,var) maps)))) + (else + (if (ellipsis? e) + (syntax-violation 'syntax "misplaced ellipsis" src) + (values `(quote ,e) maps)))))) + (syntax-case e () + ((dots e) + (ellipsis? #'dots) + (gen-syntax src #'e r maps (lambda (x) #f) mod)) + ((x dots . y) + ;; this could be about a dozen lines of code, except that we + ;; choose to handle #'(x ... ...) forms + (ellipsis? #'dots) + (let f ((y #'y) + (k (lambda (maps) + (call-with-values + (lambda () + (gen-syntax src #'x r + (cons '() maps) ellipsis? mod)) + (lambda (x maps) + (if (null? (car maps)) + (syntax-violation 'syntax "extra ellipsis" + src) + (values (gen-map x (car maps)) + (cdr maps)))))))) + (syntax-case y () + ((dots . y) + (ellipsis? #'dots) + (f #'y + (lambda (maps) (call-with-values - (lambda () (gen-syntax e #'x r '() ellipsis? mod)) - (lambda (e maps) (regen e)))) - (_ (syntax-violation 'syntax "bad `syntax' form" e))))))) + (lambda () (k (cons '() maps))) + (lambda (x maps) + (if (null? (car maps)) + (syntax-violation 'syntax "extra ellipsis" src) + (values (gen-mappend x (car maps)) + (cdr maps)))))))) + (_ (call-with-values + (lambda () (gen-syntax src y r maps ellipsis? mod)) + (lambda (y maps) + (call-with-values + (lambda () (k maps)) + (lambda (x maps) + (values (gen-append x y) maps))))))))) + ((x . y) + (call-with-values + (lambda () (gen-syntax src #'x r maps ellipsis? mod)) + (lambda (x maps) + (call-with-values + (lambda () (gen-syntax src #'y r maps ellipsis? mod)) + (lambda (y maps) (values (gen-cons x y) maps)))))) + (#(e1 e2 ...) + (call-with-values + (lambda () + (gen-syntax src #'(e1 e2 ...) r maps ellipsis? mod)) + (lambda (e maps) (values (gen-vector e) maps)))) + (_ (values `(quote ,e) maps)))))) + + (define gen-ref + (lambda (src var level maps) + (if (fx= level 0) + (values var maps) + (if (null? maps) + (syntax-violation 'syntax "missing ellipsis" src) + (call-with-values + (lambda () (gen-ref src var (fx- level 1) (cdr maps))) + (lambda (outer-var outer-maps) + (let ((b (assq outer-var (car maps)))) + (if b + (values (cdr b) maps) + (let ((inner-var (gen-var 'tmp))) + (values inner-var + (cons (cons (cons outer-var inner-var) + (car maps)) + outer-maps))))))))))) + + (define gen-mappend + (lambda (e map-env) + `(apply (primitive append) ,(gen-map e map-env)))) + + (define gen-map + (lambda (e map-env) + (let ((formals (map cdr map-env)) + (actuals (map (lambda (x) `(ref ,(car x))) map-env))) + (cond + ((eq? (car e) 'ref) + ;; identity map equivalence: + ;; (map (lambda (x) x) y) == y + (car actuals)) + ((and-map + (lambda (x) (and (eq? (car x) 'ref) (memq (cadr x) formals))) + (cdr e)) + ;; eta map equivalence: + ;; (map (lambda (x ...) (f x ...)) y ...) == (map f y ...) + `(map (primitive ,(car e)) + ,@(map (let ((r (map cons formals actuals))) + (lambda (x) (cdr (assq (cadr x) r)))) + (cdr e)))) + (else `(map (lambda ,formals ,e) ,@actuals)))))) + + (define gen-cons + (lambda (x y) + (case (car y) + ((quote) + (if (eq? (car x) 'quote) + `(quote (,(cadr x) . ,(cadr y))) + (if (eq? (cadr y) '()) + `(list ,x) + `(cons ,x ,y)))) + ((list) `(list ,x ,@(cdr y))) + (else `(cons ,x ,y))))) + + (define gen-append + (lambda (x y) + (if (equal? y '(quote ())) + x + `(append ,x ,y)))) + + (define gen-vector + (lambda (x) + (cond + ((eq? (car x) 'list) `(vector ,@(cdr x))) + ((eq? (car x) 'quote) `(quote #(,@(cadr x)))) + (else `(list->vector ,x))))) + + + (define regen + (lambda (x) + (case (car x) + ((ref) (build-lexical-reference 'value no-source (cadr x) (cadr x))) + ((primitive) (build-primref no-source (cadr x))) + ((quote) (build-data no-source (cadr x))) + ((lambda) + (if (list? (cadr x)) + (build-simple-lambda no-source (cadr x) #f (cadr x) '() (regen (caddr x))) + (error "how did we get here" x))) + (else (build-primcall no-source (car x) (map regen (cdr x))))))) + + (lambda (e r w s mod) + (let ((e (source-wrap e w s mod))) + (syntax-case e () + ((_ x) + (call-with-values + (lambda () (gen-syntax e #'x r '() ellipsis? mod)) + (lambda (e maps) (regen e)))) + (_ (syntax-violation 'syntax "bad `syntax' form" e))))))) (global-extend 'core 'lambda (lambda (e r w s mod) @@ -2175,58 +2272,53 @@ (_ (syntax-violation 'letrec* "bad letrec*" (source-wrap e w s mod)))))) - (global-extend 'core 'set! - (lambda (e r w s mod) - (syntax-case e () - ((_ id val) - (id? #'id) - (let ((n (id-var-name #'id w)) - ;; Lookup id in its module - (id-mod (if (syntax-object? #'id) - (syntax-object-module #'id) - mod))) - (let ((b (lookup n r id-mod))) - (case (binding-type b) - ((lexical) - (build-lexical-assignment s - (syntax->datum #'id) - (binding-value b) - (expand #'val r w mod))) - ((global) - (build-global-assignment s n (expand #'val r w mod) id-mod)) - ((macro) - (let ((p (binding-value b))) - (if (procedure-property p 'variable-transformer) - ;; As syntax-type does, call expand-macro with - ;; the mod of the expression. Hmm. - (expand (expand-macro p e r w s #f mod) r empty-wrap mod) - (syntax-violation 'set! "not a variable transformer" - (wrap e w mod) - (wrap #'id w id-mod))))) - ((displaced-lexical) - (syntax-violation 'set! "identifier out of context" - (wrap #'id w mod))) - (else (syntax-violation 'set! "bad set!" - (source-wrap e w s mod))))))) - ((_ (head tail ...) val) - (call-with-values - (lambda () (syntax-type #'head r empty-wrap no-source #f mod #t)) - (lambda (type value formform ee ww ss modmod) - (case type - ((module-ref) - (let ((val (expand #'val r w mod))) - (call-with-values (lambda () (value #'(head tail ...) r w)) - (lambda (e r w s* mod) - (syntax-case e () - (e (id? #'e) - (build-global-assignment s (syntax->datum #'e) - val mod))))))) - (else - (build-application s - (expand #'(setter head) r w mod) - (map (lambda (e) (expand e r w mod)) - #'(tail ... val)))))))) - (_ (syntax-violation 'set! "bad set!" (source-wrap e w s mod)))))) + (global-extend + 'core 'set! + (lambda (e r w s mod) + (syntax-case e () + ((_ id val) + (id? #'id) + (call-with-values + (lambda () (resolve-identifier #'id w r mod #t)) + (lambda (type value id-mod) + (case type + ((lexical) + (build-lexical-assignment s (syntax->datum #'id) value + (expand #'val r w mod))) + ((global) + (build-global-assignment s value (expand #'val r w mod) id-mod)) + ((macro) + (if (procedure-property value 'variable-transformer) + ;; As syntax-type does, call expand-macro with + ;; the mod of the expression. Hmm. + (expand (expand-macro value e r w s #f mod) r empty-wrap mod) + (syntax-violation 'set! "not a variable transformer" + (wrap e w mod) + (wrap #'id w id-mod)))) + ((displaced-lexical) + (syntax-violation 'set! "identifier out of context" + (wrap #'id w mod))) + (else + (syntax-violation 'set! "bad set!" (source-wrap e w s mod))))))) + ((_ (head tail ...) val) + (call-with-values + (lambda () (syntax-type #'head r empty-wrap no-source #f mod #t)) + (lambda (type value ee* ee ww ss modmod) + (case type + ((module-ref) + (let ((val (expand #'val r w mod))) + (call-with-values (lambda () (value #'(head tail ...) r w)) + (lambda (e r w s* mod) + (syntax-case e () + (e (id? #'e) + (build-global-assignment s (syntax->datum #'e) + val mod))))))) + (else + (build-call s + (expand #'(setter head) r w mod) + (map (lambda (e) (expand e r w mod)) + #'(tail ... val)))))))) + (_ (syntax-violation 'set! "bad set!" (source-wrap e w s mod)))))) (global-extend 'module-ref '@ (lambda (e r w) @@ -2388,20 +2480,21 @@ (lambda (pvars exp y r mod) (let ((ids (map car pvars)) (levels (map cdr pvars))) (let ((labels (gen-labels ids)) (new-vars (map gen-var ids))) - (build-application no-source - (build-primref no-source 'apply) - (list (build-simple-lambda no-source (map syntax->datum ids) #f new-vars '() - (expand exp - (extend-env - labels - (map (lambda (var level) - (make-binding 'syntax `(,var . ,level))) - new-vars - (map cdr pvars)) - r) - (make-binding-wrap ids labels empty-wrap) - mod)) - y)))))) + (build-primcall + no-source + 'apply + (list (build-simple-lambda no-source (map syntax->datum ids) #f new-vars '() + (expand exp + (extend-env + labels + (map (lambda (var level) + (make-binding 'syntax `(,var . ,level))) + new-vars + (map cdr pvars)) + r) + (make-binding-wrap ids labels empty-wrap) + mod)) + y)))))) (define gen-clause (lambda (x keys clauses r pat fender exp mod) @@ -2416,36 +2509,32 @@ (else (let ((y (gen-var 'tmp))) ;; fat finger binding and references to temp variable y - (build-application no-source - (build-simple-lambda no-source (list 'tmp) #f (list y) '() - (let ((y (build-lexical-reference 'value no-source - 'tmp y))) - (build-conditional no-source - (syntax-case fender () - (#t y) - (_ (build-conditional no-source - y - (build-dispatch-call pvars fender y r mod) - (build-data no-source #f)))) - (build-dispatch-call pvars exp y r mod) - (gen-syntax-case x keys clauses r mod)))) - (list (if (eq? p 'any) - (build-application no-source - (build-primref no-source 'list) - (list x)) - (build-application no-source - (build-primref no-source '$sc-dispatch) - (list x (build-data no-source p))))))))))))) + (build-call no-source + (build-simple-lambda no-source (list 'tmp) #f (list y) '() + (let ((y (build-lexical-reference 'value no-source + 'tmp y))) + (build-conditional no-source + (syntax-case fender () + (#t y) + (_ (build-conditional no-source + y + (build-dispatch-call pvars fender y r mod) + (build-data no-source #f)))) + (build-dispatch-call pvars exp y r mod) + (gen-syntax-case x keys clauses r mod)))) + (list (if (eq? p 'any) + (build-primcall no-source 'list (list x)) + (build-primcall no-source '$sc-dispatch + (list x (build-data no-source p))))))))))))) (define gen-syntax-case (lambda (x keys clauses r mod) (if (null? clauses) - (build-application no-source - (build-primref no-source 'syntax-violation) - (list (build-data no-source #f) - (build-data no-source - "source expression failed to match any pattern") - x)) + (build-primcall no-source 'syntax-violation + (list (build-data no-source #f) + (build-data no-source + "source expression failed to match any pattern") + x)) (syntax-case (car clauses) () ((pat exp) (if (and (id? #'pat) @@ -2455,18 +2544,18 @@ (expand #'exp r empty-wrap mod) (let ((labels (list (gen-label))) (var (gen-var #'pat))) - (build-application no-source - (build-simple-lambda - no-source (list (syntax->datum #'pat)) #f (list var) - '() - (expand #'exp - (extend-env labels - (list (make-binding 'syntax `(,var . 0))) - r) - (make-binding-wrap #'(pat) - labels empty-wrap) - mod)) - (list x)))) + (build-call no-source + (build-simple-lambda + no-source (list (syntax->datum #'pat)) #f (list var) + '() + (expand #'exp + (extend-env labels + (list (make-binding 'syntax `(,var . 0))) + r) + (make-binding-wrap #'(pat) + labels empty-wrap) + mod)) + (list x)))) (gen-clause x keys (cdr clauses) r #'pat #t #'exp mod))) ((pat fender exp) @@ -2483,14 +2572,14 @@ #'(key ...)) (let ((x (gen-var 'tmp))) ;; fat finger binding and references to temp variable x - (build-application s - (build-simple-lambda no-source (list 'tmp) #f (list x) '() - (gen-syntax-case (build-lexical-reference 'value no-source - 'tmp x) - #'(key ...) #'(m ...) - r - mod)) - (list (expand #'val r empty-wrap mod)))) + (build-call s + (build-simple-lambda no-source (list 'tmp) #f (list x) '() + (gen-syntax-case (build-lexical-reference 'value no-source + 'tmp x) + #'(key ...) #'(m ...) + r + mod)) + (list (expand #'val r empty-wrap mod)))) (syntax-violation 'syntax-case "invalid literals list" e)))))))) ;; The portable macroexpand seeds expand-top's mode m with 'e (for @@ -2575,7 +2664,10 @@ (syntax-object-expression id) (strip-anti-mark (syntax-object-wrap id)) r - (syntax-object-module id))) + (syntax-object-module id) + ;; FIXME: come up with a better policy for + ;; resolve-syntax-parameters + #t)) (lambda (type value mod) (case type ((lexical) (values 'lexical value)) @@ -2783,7 +2875,7 @@ #((macro-type . syntax-rules) (patterns pattern ...)) (syntax-case x (k ...) - ((dummy . pattern) #'template) + ((_ . pattern) #'template) ...))) ((_ (k ...) docstring ((keyword . pattern) template) ...) (string? (syntax->datum #'docstring)) @@ -2793,7 +2885,7 @@ #((macro-type . syntax-rules) (patterns pattern ...)) (syntax-case x (k ...) - ((dummy . pattern) #'template) + ((_ . pattern) #'template) ...)))))) (define-syntax define-syntax-rule diff --git a/module/ice-9/r4rs.scm b/module/ice-9/r4rs.scm deleted file mode 100644 index bedfbdea7..000000000 --- a/module/ice-9/r4rs.scm +++ /dev/null @@ -1,243 +0,0 @@ -;;;; r4rs.scm --- definitions needed for libguile to be R4RS compliant -;;;; Jim Blandy <jimb@cyclic.com> --- October 1996 - -;;;; Copyright (C) 1996, 1997, 1998, 2000, 2001, 2006, 2010, 2011, 2012 Free Software Foundation, Inc. -;;;; -;;;; This library is free software; you can redistribute it and/or -;;;; modify it under the terms of the GNU Lesser General Public -;;;; License as published by the Free Software Foundation; either -;;;; version 3 of the License, or (at your option) any later version. -;;;; -;;;; This library is distributed in the hope that it will be useful, -;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -;;;; Lesser General Public License for more details. -;;;; -;;;; You should have received a copy of the GNU Lesser General Public -;;;; License along with this library; if not, write to the Free Software -;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - -(eval-when (compile) - (set-current-module (resolve-module '(guile)))) - - -;;;; apply and call-with-current-continuation - -;;; The deal with these is that they are the procedural wrappers around the -;;; primitives of Guile's language. There are about 20 different kinds of -;;; expression in Guile, and e.g. @apply is one of them. (It has to be that way -;;; to preserve tail recursion.) -;;; -;;; Usually we recognize (apply foo bar) to be an instance of @apply, but in the -;;; case that apply is passed to apply, or we're bootstrapping, we need a -;;; trampoline -- and here they are. -(define (apply fun . args) - (@apply fun (apply:nconc2last args))) -(define (call-with-current-continuation proc) - (@call-with-current-continuation proc)) -(define (call-with-values producer consumer) - (@call-with-values producer consumer)) -(define (dynamic-wind in thunk out) - "All three arguments must be 0-argument procedures. -Guard @var{in} is called, then @var{thunk}, then -guard @var{out}. - -If, any time during the execution of @var{thunk}, the -continuation of the @code{dynamic_wind} expression is escaped -non-locally, @var{out} is called. If the continuation of -the dynamic-wind is re-entered, @var{in} is called. Thus -@var{in} and @var{out} may be called any number of -times. -@lisp - (define x 'normal-binding) -@result{} x - (define a-cont - (call-with-current-continuation - (lambda (escape) - (let ((old-x x)) - (dynamic-wind - ;; in-guard: - ;; - (lambda () (set! x 'special-binding)) - - ;; thunk - ;; - (lambda () (display x) (newline) - (call-with-current-continuation escape) - (display x) (newline) - x) - - ;; out-guard: - ;; - (lambda () (set! x old-x))))))) - -;; Prints: -special-binding -;; Evaluates to: -@result{} a-cont -x -@result{} normal-binding - (a-cont #f) -;; Prints: -special-binding -;; Evaluates to: -@result{} a-cont ;; the value of the (define a-cont...) -x -@result{} normal-binding -a-cont -@result{} special-binding -@end lisp" - (@dynamic-wind in (thunk) out)) - - -;;;; Basic Port Code - -;;; Specifically, the parts of the low-level port code that are written in -;;; Scheme rather than C. -;;; -;;; WARNING: the parts of this interface that refer to file ports -;;; are going away. It would be gone already except that it is used -;;; "internally" in a few places. - - -;;; OPEN_READ, OPEN_WRITE, and OPEN_BOTH are used to request the -;;; proper mode to open files in. -;;; -;;; If we want to support systems that do CRLF->LF translation, like -;;; Windows, then we should have a symbol in scmconfig.h made visible -;;; to the Scheme level that we can test here, and autoconf magic to -;;; #define it when appropriate. Windows will probably just have a -;;; hand-generated scmconfig.h file. -(define OPEN_READ "r") -(define OPEN_WRITE "w") -(define OPEN_BOTH "r+") - -(define *null-device* "/dev/null") - -(define (open-input-file str) - "Takes a string naming an existing file and returns an input port -capable of delivering characters from the file. If the file -cannot be opened, an error is signalled." - (open-file str OPEN_READ)) - -(define (open-output-file str) - "Takes a string naming an output file to be created and returns an -output port capable of writing characters to a new file by that -name. If the file cannot be opened, an error is signalled. If a -file with the given name already exists, the effect is unspecified." - (open-file str OPEN_WRITE)) - -(define (open-io-file str) - "Open file with name STR for both input and output." - (open-file str OPEN_BOTH)) - -(define (call-with-input-file str proc) - "PROC should be a procedure of one argument, and STR should be a -string naming a file. The file must -already exist. These procedures call PROC -with one argument: the port obtained by opening the named file for -input or output. If the file cannot be opened, an error is -signalled. If the procedure returns, then the port is closed -automatically and the values yielded by the procedure are returned. -If the procedure does not return, then the port will not be closed -automatically unless it is possible to prove that the port will -never again be used for a read or write operation." - (let ((p (open-input-file str))) - (call-with-values - (lambda () (proc p)) - (lambda vals - (close-input-port p) - (apply values vals))))) - -(define (call-with-output-file str proc) - "PROC should be a procedure of one argument, and STR should be a -string naming a file. The behaviour is unspecified if the file -already exists. These procedures call PROC -with one argument: the port obtained by opening the named file for -input or output. If the file cannot be opened, an error is -signalled. If the procedure returns, then the port is closed -automatically and the values yielded by the procedure are returned. -If the procedure does not return, then the port will not be closed -automatically unless it is possible to prove that the port will -never again be used for a read or write operation." - (let ((p (open-output-file str))) - (call-with-values - (lambda () (proc p)) - (lambda vals - (close-output-port p) - (apply values vals))))) - -(define (with-input-from-port port thunk) - (let* ((swaports (lambda () (set! port (set-current-input-port port))))) - (dynamic-wind swaports thunk swaports))) - -(define (with-output-to-port port thunk) - (let* ((swaports (lambda () (set! port (set-current-output-port port))))) - (dynamic-wind swaports thunk swaports))) - -(define (with-error-to-port port thunk) - (let* ((swaports (lambda () (set! port (set-current-error-port port))))) - (dynamic-wind swaports thunk swaports))) - -(define (with-input-from-file file thunk) - "THUNK must be a procedure of no arguments, and FILE must be a -string naming a file. The file must already exist. The file is opened for -input, an input port connected to it is made -the default value returned by `current-input-port', -and the THUNK is called with no arguments. -When the THUNK returns, the port is closed and the previous -default is restored. Returns the values yielded by THUNK. If an -escape procedure is used to escape from the continuation of these -procedures, their behavior is implementation dependent." - (call-with-input-file file - (lambda (p) (with-input-from-port p thunk)))) - -(define (with-output-to-file file thunk) - "THUNK must be a procedure of no arguments, and FILE must be a -string naming a file. The effect is unspecified if the file already exists. -The file is opened for output, an output port connected to it is made -the default value returned by `current-output-port', -and the THUNK is called with no arguments. -When the THUNK returns, the port is closed and the previous -default is restored. Returns the values yielded by THUNK. If an -escape procedure is used to escape from the continuation of these -procedures, their behavior is implementation dependent." - (call-with-output-file file - (lambda (p) (with-output-to-port p thunk)))) - -(define (with-error-to-file file thunk) - "THUNK must be a procedure of no arguments, and FILE must be a -string naming a file. The effect is unspecified if the file already exists. -The file is opened for output, an output port connected to it is made -the default value returned by `current-error-port', -and the THUNK is called with no arguments. -When the THUNK returns, the port is closed and the previous -default is restored. Returns the values yielded by THUNK. If an -escape procedure is used to escape from the continuation of these -procedures, their behavior is implementation dependent." - (call-with-output-file file - (lambda (p) (with-error-to-port p thunk)))) - -(define (with-input-from-string string thunk) - "THUNK must be a procedure of no arguments. -The test of STRING is opened for -input, an input port connected to it is made, -and the THUNK is called with no arguments. -When the THUNK returns, the port is closed. -Returns the values yielded by THUNK. If an -escape procedure is used to escape from the continuation of these -procedures, their behavior is implementation dependent." - (call-with-input-string string - (lambda (p) (with-input-from-port p thunk)))) - -(define (with-output-to-string thunk) - "Calls THUNK and returns its output as a string." - (call-with-output-string - (lambda (p) (with-output-to-port p thunk)))) - -(define (with-error-to-string thunk) - "Calls THUNK and returns its error output as a string." - (call-with-output-string - (lambda (p) (with-error-to-port p thunk)))) - -(define the-eof-object (call-with-input-string "" (lambda (p) (read-char p)))) diff --git a/module/ice-9/weak-vector.scm b/module/ice-9/weak-vector.scm index 09e2e0a8d..31d79ec6f 100644 --- a/module/ice-9/weak-vector.scm +++ b/module/ice-9/weak-vector.scm @@ -1,6 +1,6 @@ ;;; installed-scm-file -;;;; Copyright (C) 2003, 2006 Free Software Foundation, Inc. +;;;; Copyright (C) 2003, 2006, 2011 Free Software Foundation, Inc. ;;;; ;;;; This library is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Lesser General Public @@ -19,13 +19,8 @@ (define-module (ice-9 weak-vector) - :export (make-weak-vector list->weak-vector weak-vector weak-vector? - make-weak-key-alist-vector - make-weak-value-alist-vector - make-doubly-weak-alist-vector - weak-key-alist-vector? - weak-value-alist-vector? - doubly-weak-alist-vector?) ; C - ) + #:export (make-weak-vector list->weak-vector weak-vector weak-vector?)) -(%init-weaks-builtins) ; defined in libguile/weaks.c +(eval-when (load eval compile) + (load-extension (string-append "libguile-" (effective-version)) + "scm_init_weak_vector_builtins")) diff --git a/module/language/assembly/compile-bytecode.scm b/module/language/assembly/compile-bytecode.scm index 181fb06ab..d54186e16 100644 --- a/module/language/assembly/compile-bytecode.scm +++ b/module/language/assembly/compile-bytecode.scm @@ -133,6 +133,8 @@ ((br-if-not-eq ,l) (write-break l)) ((br-if-null ,l) (write-break l)) ((br-if-not-null ,l) (write-break l)) + ((br-if-nil ,l) (write-break l)) + ((br-if-not-nil ,l) (write-break l)) ((br-if-nargs-ne ,hi ,lo ,l) (write-byte hi) (write-byte lo) (write-break l)) ((br-if-nargs-lt ,hi ,lo ,l) (write-byte hi) (write-byte lo) (write-break l)) ((br-if-nargs-gt ,hi ,lo ,l) (write-byte hi) (write-byte lo) (write-break l)) diff --git a/module/language/assembly/disassemble.scm b/module/language/assembly/disassemble.scm index 5d30be391..dcdd78073 100644 --- a/module/language/assembly/disassemble.scm +++ b/module/language/assembly/disassemble.scm @@ -125,7 +125,9 @@ (case inst ((list vector) (list "~a element~:p" (apply make-int16 args))) - ((br br-if br-if-eq br-if-not br-if-not-eq br-if-not-null br-if-null) + ((br + br-if br-if-eq br-if-not br-if-not-eq br-if-not-null br-if-null + br-if-nil br-if-not-nil) (list "-> ~A" (assq-ref labels (car args)))) ((br-if-nargs-ne br-if-nargs-lt br-if-nargs-gt) (list "-> ~A" (assq-ref labels (caddr args)))) diff --git a/module/language/brainfuck/compile-tree-il.scm b/module/language/brainfuck/compile-tree-il.scm index 33d563490..f9dd036e8 100644 --- a/module/language/brainfuck/compile-tree-il.scm +++ b/module/language/brainfuck/compile-tree-il.scm @@ -1,6 +1,6 @@ ;;; Brainfuck for GNU Guile -;; Copyright (C) 2009 Free Software Foundation, Inc. +;; Copyright (C) 2009, 2011 Free Software Foundation, Inc. ;; This library is free software; you can redistribute it and/or ;; modify it under the terms of the GNU Lesser General Public @@ -94,7 +94,7 @@ (parse-tree-il `(let (pointer tape) (pointer tape) ((const 0) - (apply (primitive make-vector) (const ,tape-size) (const 0))) + (call (primitive make-vector) (const ,tape-size) (const 0))) ,(compile-body exp))) env env)) @@ -109,11 +109,11 @@ (cond ((null? in) ;; No more input, build our output. - (cond - ((null? out) '(void)) ; no output - ((null? (cdr out)) (car out)) ; single expression - (else `(begin ,@(reverse out)))) ; sequence - ) + (cond + ((null? out) '(void)) ; no output + ((null? (cdr out)) (car out)) ; single expression + (else `(begin ,@(reverse out)))) ; sequence + ) (else (pmatch (car in) @@ -121,34 +121,34 @@ ;; (set! pointer (+ pointer +-1)) ((<bf-move> ,dir) (emit `(set! (lexical pointer) - (apply (primitive +) (lexical pointer) (const ,dir))))) + (call (primitive +) (lexical pointer) (const ,dir))))) ;; Cell increment +- is done as: ;; (vector-set! tape pointer (+ (vector-ref tape pointer) +-1)) ((<bf-increment> ,inc) - (emit `(apply (primitive vector-set!) (lexical tape) (lexical pointer) - (apply (primitive +) - (apply (primitive vector-ref) - (lexical tape) (lexical pointer)) - (const ,inc))))) + (emit `(call (primitive vector-set!) (lexical tape) (lexical pointer) + (call (primitive +) + (call (primitive vector-ref) + (lexical tape) (lexical pointer)) + (const ,inc))))) ;; Output . is done by converting the cell's integer value to a ;; character first and then printing out this character: ;; (write-char (integer->char (vector-ref tape pointer))) ((<bf-print>) - (emit `(apply (primitive write-char) - (apply (primitive integer->char) - (apply (primitive vector-ref) - (lexical tape) (lexical pointer)))))) + (emit `(call (primitive write-char) + (call (primitive integer->char) + (call (primitive vector-ref) + (lexical tape) (lexical pointer)))))) ;; Input , is done similarly, read in a character, get its ASCII ;; code and store it into the current cell: ;; (vector-set! tape pointer (char->integer (read-char))) ((<bf-read>) - (emit `(apply (primitive vector-set!) - (lexical tape) (lexical pointer) - (apply (primitive char->integer) - (apply (primitive read-char)))))) + (emit `(call (primitive vector-set!) + (lexical tape) (lexical pointer) + (call (primitive char->integer) + (call (primitive read-char)))))) ;; For loops [...] we use a letrec construction to execute the body until ;; the current cell gets zero. The body is compiled via a recursive call @@ -171,14 +171,14 @@ ((lambda () (lambda-case ((() #f #f #f () ()) - (if (apply (primitive =) - (apply (primitive vector-ref) - (lexical tape) (lexical pointer)) - (const 0)) + (if (call (primitive =) + (call (primitive vector-ref) + (lexical tape) (lexical pointer)) + (const 0)) (void) (begin ,(compile-body body) - (apply (lexical ,iterate))))) + (call (lexical ,iterate))))) #f))) - (apply (lexical ,iterate)))))) + (call (lexical ,iterate)))))) (else (error "unknown brainfuck instruction" (car in)))))))) diff --git a/module/language/bytecode/spec.scm b/module/language/bytecode/spec.scm index 1d7e79b57..ca703c33c 100644 --- a/module/language/bytecode/spec.scm +++ b/module/language/bytecode/spec.scm @@ -1,6 +1,6 @@ ;;; Guile Lowlevel Intermediate Language -;; Copyright (C) 2001, 2009, 2010, 2013 Free Software Foundation, Inc. +;; Copyright (C) 2001, 2009, 2010, 2012, 2013 Free Software Foundation, Inc. ;;;; This library is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Lesser General Public @@ -20,14 +20,15 @@ (define-module (language bytecode spec) #:use-module (system base language) + #:use-module (system base target) #:use-module (system vm objcode) #:export (bytecode)) (define (compile-objcode x e opts) - (values (bytecode->objcode x) e e)) + (values (bytecode->objcode x (target-endianness)) e e)) (define (decompile-objcode x e opts) - (values (objcode->bytecode x) e)) + (values (objcode->bytecode x (target-endianness)) e)) (define-language bytecode #:title "Guile Bytecode Vectors" diff --git a/module/language/ecmascript/compile-tree-il.scm b/module/language/ecmascript/compile-tree-il.scm index b5f0a3528..2fe0d924e 100644 --- a/module/language/ecmascript/compile-tree-il.scm +++ b/module/language/ecmascript/compile-tree-il.scm @@ -32,7 +32,7 @@ (-> (@ '(language ecmascript impl) 'sym))) (define-syntax-rule (@impl sym arg ...) - (-> (apply (@implv sym) arg ...))) + (-> (call (@implv sym) arg ...))) (define (empty-lexical-environment) '()) @@ -82,7 +82,7 @@ (parameterize ((current-return-tag (-> (lexical 'return tag)))) (-> (let '(return) (list tag) - (list (-> (apply (-> (primitive 'make-prompt-tag))))) + (list (-> (primcall 'make-prompt-tag))) (-> (prompt (current-return-tag) (body-thunk) (let ((val (gensym "val"))) @@ -115,23 +115,23 @@ (this (@impl get-this)) ((+ ,a) - (-> (apply (-> (primitive '+)) - (@impl ->number (comp a e)) - (-> (const 0))))) + (-> (call (-> (primitive '+)) + (@impl ->number (comp a e)) + (-> (const 0))))) ((- ,a) - (-> (apply (-> (primitive '-)) (-> (const 0)) (comp a e)))) + (-> (call (-> (primitive '-)) (-> (const 0)) (comp a e)))) ((~ ,a) (@impl bitwise-not (comp a e))) ((! ,a) (@impl logical-not (comp a e))) ((+ ,a ,b) - (-> (apply (-> (primitive '+)) (comp a e) (comp b e)))) + (-> (call (-> (primitive '+)) (comp a e) (comp b e)))) ((- ,a ,b) - (-> (apply (-> (primitive '-)) (comp a e) (comp b e)))) + (-> (call (-> (primitive '-)) (comp a e) (comp b e)))) ((/ ,a ,b) - (-> (apply (-> (primitive '/)) (comp a e) (comp b e)))) + (-> (call (-> (primitive '/)) (comp a e) (comp b e)))) ((* ,a ,b) - (-> (apply (-> (primitive '*)) (comp a e) (comp b e)))) + (-> (call (-> (primitive '*)) (comp a e) (comp b e)))) ((% ,a ,b) (@impl mod (comp a e) (comp b e))) ((<< ,a ,b) @@ -139,27 +139,27 @@ ((>> ,a ,b) (@impl shift (comp a e) (comp `(- ,b) e))) ((< ,a ,b) - (-> (apply (-> (primitive '<)) (comp a e) (comp b e)))) + (-> (call (-> (primitive '<)) (comp a e) (comp b e)))) ((<= ,a ,b) - (-> (apply (-> (primitive '<=)) (comp a e) (comp b e)))) + (-> (call (-> (primitive '<=)) (comp a e) (comp b e)))) ((> ,a ,b) - (-> (apply (-> (primitive '>)) (comp a e) (comp b e)))) + (-> (call (-> (primitive '>)) (comp a e) (comp b e)))) ((>= ,a ,b) - (-> (apply (-> (primitive '>=)) (comp a e) (comp b e)))) + (-> (call (-> (primitive '>=)) (comp a e) (comp b e)))) ((in ,a ,b) (@impl has-property? (comp a e) (comp b e))) ((== ,a ,b) - (-> (apply (-> (primitive 'equal?)) (comp a e) (comp b e)))) + (-> (call (-> (primitive 'equal?)) (comp a e) (comp b e)))) ((!= ,a ,b) - (-> (apply (-> (primitive 'not)) - (-> (apply (-> (primitive 'equal?)) - (comp a e) (comp b e)))))) + (-> (call (-> (primitive 'not)) + (-> (call (-> (primitive 'equal?)) + (comp a e) (comp b e)))))) ((=== ,a ,b) - (-> (apply (-> (primitive 'eqv?)) (comp a e) (comp b e)))) + (-> (call (-> (primitive 'eqv?)) (comp a e) (comp b e)))) ((!== ,a ,b) - (-> (apply (-> (primitive 'not)) - (-> (apply (-> (primitive 'eqv?)) - (comp a e) (comp b e)))))) + (-> (call (-> (primitive 'not)) + (-> (call (-> (primitive 'eqv?)) + (comp a e) (comp b e)))))) ((& ,a ,b) (@impl band (comp a e) (comp b e))) ((^ ,a ,b) @@ -188,9 +188,9 @@ (begin1 (comp `(ref ,foo) e) (lambda (var) (-> (set! (lookup foo e) - (-> (apply (-> (primitive '+)) - (-> (lexical var var)) - (-> (const 1))))))))) + (-> (call (-> (primitive '+)) + (-> (lexical var var)) + (-> (const 1))))))))) ((postinc (pref ,obj ,prop)) (let1 (comp obj e) (lambda (objvar) @@ -201,9 +201,9 @@ (@impl pput (-> (lexical objvar objvar)) (-> (const prop)) - (-> (apply (-> (primitive '+)) - (-> (lexical tmpvar tmpvar)) - (-> (const 1)))))))))) + (-> (call (-> (primitive '+)) + (-> (lexical tmpvar tmpvar)) + (-> (const 1)))))))))) ((postinc (aref ,obj ,prop)) (let1 (comp obj e) (lambda (objvar) @@ -216,16 +216,16 @@ (@impl pput (-> (lexical objvar objvar)) (-> (lexical propvar propvar)) - (-> (apply (-> (primitive '+)) - (-> (lexical tmpvar tmpvar)) - (-> (const 1)))))))))))) + (-> (call (-> (primitive '+)) + (-> (lexical tmpvar tmpvar)) + (-> (const 1)))))))))))) ((postdec (ref ,foo)) (begin1 (comp `(ref ,foo) e) (lambda (var) (-> (set (lookup foo e) - (-> (apply (-> (primitive '-)) - (-> (lexical var var)) - (-> (const 1))))))))) + (-> (call (-> (primitive '-)) + (-> (lexical var var)) + (-> (const 1))))))))) ((postdec (pref ,obj ,prop)) (let1 (comp obj e) (lambda (objvar) @@ -236,9 +236,9 @@ (@impl pput (-> (lexical objvar objvar)) (-> (const prop)) - (-> (apply (-> (primitive '-)) - (-> (lexical tmpvar tmpvar)) - (-> (const 1)))))))))) + (-> (call (-> (primitive '-)) + (-> (lexical tmpvar tmpvar)) + (-> (const 1)))))))))) ((postdec (aref ,obj ,prop)) (let1 (comp obj e) (lambda (objvar) @@ -258,18 +258,18 @@ (let ((v (lookup foo e))) (-> (begin (-> (set! v - (-> (apply (-> (primitive '+)) - v - (-> (const 1)))))) + (-> (call (-> (primitive '+)) + v + (-> (const 1)))))) v)))) ((preinc (pref ,obj ,prop)) (let1 (comp obj e) (lambda (objvar) - (begin1 (-> (apply (-> (primitive '+)) - (@impl pget - (-> (lexical objvar objvar)) - (-> (const prop))) - (-> (const 1)))) + (begin1 (-> (call (-> (primitive '+)) + (@impl pget + (-> (lexical objvar objvar)) + (-> (const prop))) + (-> (const 1)))) (lambda (tmpvar) (@impl pput (-> (lexical objvar objvar)) (-> (const prop)) @@ -279,11 +279,11 @@ (lambda (objvar) (let1 (comp prop e) (lambda (propvar) - (begin1 (-> (apply (-> (primitive '+)) - (@impl pget - (-> (lexical objvar objvar)) - (-> (lexical propvar propvar))) - (-> (const 1)))) + (begin1 (-> (call (-> (primitive '+)) + (@impl pget + (-> (lexical objvar objvar)) + (-> (lexical propvar propvar))) + (-> (const 1)))) (lambda (tmpvar) (@impl pput (-> (lexical objvar objvar)) @@ -293,18 +293,18 @@ (let ((v (lookup foo e))) (-> (begin (-> (set! v - (-> (apply (-> (primitive '-)) + (-> (call (-> (primitive '-)) v (-> (const 1)))))) v)))) ((predec (pref ,obj ,prop)) (let1 (comp obj e) (lambda (objvar) - (begin1 (-> (apply (-> (primitive '-)) - (@impl pget - (-> (lexical objvar objvar)) - (-> (const prop))) - (-> (const 1)))) + (begin1 (-> (call (-> (primitive '-)) + (@impl pget + (-> (lexical objvar objvar)) + (-> (const prop))) + (-> (const 1)))) (lambda (tmpvar) (@impl pput (-> (lexical objvar objvar)) @@ -315,11 +315,11 @@ (lambda (objvar) (let1 (comp prop e) (lambda (propvar) - (begin1 (-> (apply (-> (primitive '-)) - (@impl pget - (-> (lexical objvar objvar)) - (-> (lexical propvar propvar))) - (-> (const 1)))) + (begin1 (-> (call (-> (primitive '-)) + (@impl pget + (-> (lexical objvar objvar)) + (-> (lexical propvar propvar))) + (-> (const 1)))) (lambda (tmpvar) (@impl pput (-> (lexical objvar objvar)) @@ -359,7 +359,7 @@ (-> (lambda '() `(lambda-case ((() #f #f #f () ()) - (apply ,(@impl pget obj prop) ,@args))))))) + (call ,(@impl pget obj prop) ,@args))))))) ((call (pref ,obj ,prop) ,args) (comp `(call/this ,(comp obj e) ,(-> (const prop)) @@ -371,24 +371,24 @@ ,@(map (lambda (x) (comp x e)) args)) e)) ((call ,proc ,args) - `(apply ,(comp proc e) - ,@(map (lambda (x) (comp x e)) args))) + `(call ,(comp proc e) + ,@(map (lambda (x) (comp x e)) args))) ((return ,expr) (return (comp expr e))) ((array . ,args) - `(apply ,(@implv new-array) - ,@(map (lambda (x) (comp x e)) args))) + `(call ,(@implv new-array) + ,@(map (lambda (x) (comp x e)) args))) ((object . ,args) - `(apply ,(@implv new-object) - ,@(map (lambda (x) - (pmatch x - ((,prop ,val) - (-> (apply (-> (primitive 'cons)) - (-> (const prop)) - (comp val e)))) - (else - (error "bad prop-val pair" x)))) - args))) + `(call ,(@implv new-object) + ,@(map (lambda (x) + (pmatch x + ((,prop ,val) + (-> (call (-> (primitive 'cons)) + (-> (const prop)) + (comp val e)))) + (else + (error "bad prop-val pair" x)))) + args))) ((pref ,obj ,prop) (@impl pget (comp obj e) @@ -463,14 +463,14 @@ `((() #f #f #f () ()) ,(-> (begin (comp statement e) - (-> (apply (-> (lexical '%continue %continue))))))))))) + (-> (call (-> (lexical '%continue %continue))))))))))) (-> (lambda '() (-> (lambda-case `((() #f #f #f () ()) ,(-> (if (@impl ->boolean (comp test e)) - (-> (apply (-> (lexical '%loop %loop)))) + (-> (call (-> (lexical '%loop %loop)))) (@implv *undefined*))))))))) - (-> (apply (-> (lexical '%loop %loop))))))))) + (-> (call (-> (lexical '%loop %loop))))))))) ((while ,test ,statement) (let ((%continue (gensym "%continue "))) (let ((e (econs '%continue %continue e))) @@ -480,9 +480,9 @@ `((() #f #f #f () ()) ,(-> (if (@impl ->boolean (comp test e)) (-> (begin (comp statement e) - (-> (apply (-> (lexical '%continue %continue)))))) + (-> (call (-> (lexical '%continue %continue)))))) (@implv *undefined*))))))))) - (-> (apply (-> (lexical '%continue %continue))))))))) + (-> (call (-> (lexical '%continue %continue))))))))) ((for ,init ,test ,inc ,statement) (let ((%continue (gensym "%continue "))) @@ -496,10 +496,10 @@ (comp 'true e)) (-> (begin (comp statement e) (comp (or inc '(begin)) e) - (-> (apply (-> (lexical '%continue %continue)))))) + (-> (call (-> (lexical '%continue %continue)))))) (@implv *undefined*))))))))) (-> (begin (comp (or init '(begin)) e) - (-> (apply (-> (lexical '%continue %continue))))))))))) + (-> (call (-> (lexical '%continue %continue))))))))))) ((for-in ,var ,object ,statement) (let ((%enum (gensym "%enum ")) @@ -519,9 +519,9 @@ ,(-> (const 'pop)))) e) (comp statement e) - (-> (apply (-> (lexical '%continue %continue)))))) + (-> (call (-> (lexical '%continue %continue)))))) (@implv *undefined*))))))))) - (-> (apply (-> (lexical '%continue %continue))))))))) + (-> (call (-> (lexical '%continue %continue))))))))) ((block ,x) (comp x e)) diff --git a/module/language/elisp/bindings.scm b/module/language/elisp/bindings.scm index 6ff56fdcd..9fabddfc4 100644 --- a/module/language/elisp/bindings.scm +++ b/module/language/elisp/bindings.scm @@ -19,21 +19,22 @@ ;;; Code: (define-module (language elisp bindings) + #:use-module (srfi srfi-1) + #:use-module (srfi srfi-8) + #:use-module (srfi srfi-9) + #:use-module (srfi srfi-26) #:export (make-bindings - mark-global-needed! - map-globals-needed with-lexical-bindings with-dynamic-bindings - get-lexical-binding)) + with-function-bindings + get-lexical-binding + get-function-binding)) ;;; This module defines routines to handle analysis of symbol bindings ;;; used during elisp compilation. This data allows to collect the ;;; symbols, for which globals need to be created, or mark certain ;;; symbols as lexically bound. ;;; -;;; Needed globals are stored in an association-list that stores a list -;;; of symbols for each module they are needed in. -;;; ;;; The lexical bindings of symbols are stored in a hash-table that ;;; associates symbols to fluids; those fluids are used in the ;;; with-lexical-binding and with-dynamic-binding routines to associate @@ -41,64 +42,32 @@ ;;; Record type used to hold the data necessary. -(define bindings-type - (make-record-type 'bindings '(needed-globals lexical-bindings))) +(define-record-type bindings + (%make-bindings lexical-bindings function-bindings) + bindings? + (lexical-bindings lexical-bindings) + (function-bindings function-bindings)) ;;; Construct an 'empty' instance of the bindings data structure to be ;;; used at the start of a fresh compilation. (define (make-bindings) - ((record-constructor bindings-type) '() (make-hash-table))) - -;;; Mark that a given symbol is needed as global in the specified -;;; slot-module. - -(define (mark-global-needed! bindings sym module) - (let* ((old-needed ((record-accessor bindings-type 'needed-globals) - bindings)) - (old-in-module (or (assoc-ref old-needed module) '())) - (new-in-module (if (memq sym old-in-module) - old-in-module - (cons sym old-in-module))) - (new-needed (assoc-set! old-needed module new-in-module))) - ((record-modifier bindings-type 'needed-globals) - bindings - new-needed))) - -;;; Cycle through all globals needed in order to generate the code for -;;; their creation or some other analysis. - -(define (map-globals-needed bindings proc) - (let ((needed ((record-accessor bindings-type 'needed-globals) - bindings))) - (let iterate-modules ((mod-tail needed) - (mod-result '())) - (if (null? mod-tail) - mod-result - (iterate-modules - (cdr mod-tail) - (let* ((aentry (car mod-tail)) - (module (car aentry)) - (symbols (cdr aentry))) - (let iterate-symbols ((sym-tail symbols) - (sym-result mod-result)) - (if (null? sym-tail) - sym-result - (iterate-symbols (cdr sym-tail) - (cons (proc module (car sym-tail)) - sym-result)))))))))) + (%make-bindings (make-hash-table) (make-hash-table))) ;;; Get the current lexical binding (gensym it should refer to in the ;;; current scope) for a symbol or #f if it is dynamically bound. (define (get-lexical-binding bindings sym) - (let* ((lex ((record-accessor bindings-type 'lexical-bindings) - bindings)) + (let* ((lex (lexical-bindings bindings)) (slot (hash-ref lex sym #f))) (if slot (fluid-ref slot) #f))) +(define (get-function-binding bindings symbol) + (and=> (hash-ref (function-bindings bindings) symbol) + fluid-ref)) + ;;; Establish a binding or mark a symbol as dynamically bound for the ;;; extent of calling proc. @@ -106,8 +75,7 @@ (if (or (not (list? syms)) (not (and-map symbol? syms))) (error "can't bind non-symbols" syms)) - (let ((lex ((record-accessor bindings-type 'lexical-bindings) - bindings))) + (let ((lex (lexical-bindings bindings))) (for-each (lambda (sym) (if (not (hash-ref lex sym)) (hash-set! lex sym (make-fluid)))) @@ -127,3 +95,13 @@ syms (map (lambda (el) #f) syms) proc)) + +(define (with-function-bindings bindings symbols gensyms thunk) + (let ((fb (function-bindings bindings))) + (for-each (lambda (symbol) + (if (not (hash-ref fb symbol)) + (hash-set! fb symbol (make-fluid)))) + symbols) + (with-fluids* (map (cut hash-ref fb <>) symbols) + gensyms + thunk))) diff --git a/module/language/elisp/boot.el b/module/language/elisp/boot.el new file mode 100644 index 000000000..f55722a9a --- /dev/null +++ b/module/language/elisp/boot.el @@ -0,0 +1,617 @@ +;;; Guile Emacs Lisp -*- lexical-binding: t -*- + +;;; Copyright (C) 2011 Free Software Foundation, Inc. + +;;; This library is free software; you can redistribute it and/or modify +;;; it under the terms of the GNU Lesser General Public License as +;;; published by the Free Software Foundation; either version 3 of the +;;; License, or (at your option) any later version. +;;; +;;; This library is distributed in the hope that it will be useful, but +;;; WITHOUT ANY WARRANTY; without even the implied warranty of +;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +;;; Lesser General Public License for more details. +;;; +;;; You should have received a copy of the GNU Lesser General Public +;;; License along with this library; if not, write to the Free Software +;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +;;; 02110-1301 USA + +;;; Code: + +(defmacro @ (module symbol) + `(guile-ref ,module ,symbol)) + +(defmacro eval-and-compile (&rest body) + `(progn + (eval-when-compile ,@body) + (progn ,@body))) + +(eval-and-compile + (defun null (object) + (if object nil t)) + (defun consp (object) + (%funcall (@ (guile) pair?) object)) + (defun listp (object) + (if object (consp object) t)) + (defun car (list) + (if list (%funcall (@ (guile) car) list) nil)) + (defun cdr (list) + (if list (%funcall (@ (guile) cdr) list) nil)) + (defun make-symbol (name) + (%funcall (@ (guile) make-symbol) name)) + (defun signal (error-symbol data) + (%funcall (@ (guile) throw) 'elisp-condition error-symbol data))) + +(defmacro lambda (&rest cdr) + `#'(lambda ,@cdr)) + +(defmacro prog1 (first &rest body) + (let ((temp (make-symbol "prog1-temp"))) + `(let ((,temp ,first)) + (declare (lexical ,temp)) + ,@body + ,temp))) + +(defmacro prog2 (form1 form2 &rest body) + `(progn ,form1 (prog1 ,form2 ,@body))) + +(defmacro cond (&rest clauses) + (if (null clauses) + nil + (let ((first (car clauses)) + (rest (cdr clauses))) + (if (listp first) + (let ((condition (car first)) + (body (cdr first))) + (if (null body) + (let ((temp (make-symbol "cond-temp"))) + `(let ((,temp ,condition)) + (declare (lexical ,temp)) + (if ,temp + ,temp + (cond ,@rest)))) + `(if ,condition + (progn ,@body) + (cond ,@rest)))) + (signal 'wrong-type-argument `(listp ,first)))))) + +(defmacro and (&rest conditions) + (cond ((null conditions) t) + ((null (cdr conditions)) (car conditions)) + (t `(if ,(car conditions) + (and ,@(cdr conditions)) + nil)))) + +(defmacro or (&rest conditions) + (cond ((null conditions) nil) + ((null (cdr conditions)) (car conditions)) + (t (let ((temp (make-symbol "or-temp"))) + `(let ((,temp ,(car conditions))) + (declare (lexical ,temp)) + (if ,temp + ,temp + (or ,@(cdr conditions)))))))) + +(defmacro lexical-let (bindings &rest body) + (labels ((loop (list vars) + (if (null list) + `(let ,bindings + (declare (lexical ,@vars)) + ,@body) + (loop (cdr list) + (if (consp (car list)) + `(,(car (car list)) ,@vars) + `(,(car list) ,@vars)))))) + (loop bindings '()))) + +(defmacro lexical-let* (bindings &rest body) + (labels ((loop (list vars) + (if (null list) + `(let* ,bindings + (declare (lexical ,@vars)) + ,@body) + (loop (cdr list) + (if (consp (car list)) + (cons (car (car list)) vars) + (cons (car list) vars)))))) + (loop bindings '()))) + +(defmacro while (test &rest body) + (let ((loop (make-symbol "loop"))) + `(labels ((,loop () + (if ,test + (progn ,@body (,loop)) + nil))) + (,loop)))) + +(defmacro unwind-protect (bodyform &rest unwindforms) + `(funcall (@ (guile) dynamic-wind) + #'(lambda () nil) + #'(lambda () ,bodyform) + #'(lambda () ,@unwindforms))) + +(defmacro when (cond &rest body) + `(if ,cond + (progn ,@body))) + +(defmacro unless (cond &rest body) + `(when (not ,cond) + ,@body)) + +(defun symbolp (object) + (%funcall (@ (guile) symbol?) object)) + +(defun functionp (object) + (%funcall (@ (guile) procedure?) object)) + +(defun symbol-function (symbol) + (let ((f (%funcall (@ (language elisp runtime) symbol-function) + symbol))) + (if (%funcall (@ (language elisp falias) falias?) f) + (%funcall (@ (language elisp falias) falias-object) f) + f))) + +(defun eval (form) + (%funcall (@ (system base compile) compile) + form + (%funcall (@ (guile) symbol->keyword) 'from) + 'elisp + (%funcall (@ (guile) symbol->keyword) 'to) + 'value)) + +(defun %indirect-function (object) + (cond + ((functionp object) + object) + ((symbolp object) ;++ cycle detection + (%indirect-function (symbol-function object))) + ((listp object) + (eval `(function ,object))) + (t + (signal 'invalid-function `(,object))))) + +(defun apply (function &rest arguments) + (%funcall (@ (guile) apply) + (@ (guile) apply) + (%indirect-function function) + arguments)) + +(defun funcall (function &rest arguments) + (%funcall (@ (guile) apply) + (%indirect-function function) + arguments)) + +(defun fset (symbol definition) + (funcall (@ (language elisp runtime) set-symbol-function!) + symbol + (if (functionp definition) + definition + (funcall (@ (language elisp falias) make-falias) + #'(lambda (&rest args) (apply definition args)) + definition))) + definition) + +(defun load (file) + (funcall (@ (system base compile) compile-file) + file + (funcall (@ (guile) symbol->keyword) 'from) + 'elisp + (funcall (@ (guile) symbol->keyword) 'to) + 'value) + t) + +;;; Equality predicates + +(defun eq (obj1 obj2) + (if obj1 + (funcall (@ (guile) eq?) obj1 obj2) + (null obj2))) + +(defun eql (obj1 obj2) + (if obj1 + (funcall (@ (guile) eqv?) obj1 obj2) + (null obj2))) + +(defun equal (obj1 obj2) + (if obj1 + (funcall (@ (guile) equal?) obj1 obj2) + (null obj2))) + +;;; Symbols + +;;; `symbolp' and `symbol-function' are defined above. + +(fset 'symbol-name (@ (guile) symbol->string)) +(fset 'symbol-value (@ (language elisp runtime) symbol-value)) +(fset 'set (@ (language elisp runtime) set-symbol-value!)) +(fset 'makunbound (@ (language elisp runtime) makunbound!)) +(fset 'fmakunbound (@ (language elisp runtime) fmakunbound!)) +(fset 'boundp (@ (language elisp runtime) symbol-bound?)) +(fset 'fboundp (@ (language elisp runtime) symbol-fbound?)) +(fset 'intern (@ (guile) string->symbol)) + +(defun defvaralias (new-alias base-variable &optional docstring) + (let ((fluid (funcall (@ (language elisp runtime) symbol-fluid) + base-variable))) + (funcall (@ (language elisp runtime) set-symbol-fluid!) + new-alias + fluid) + base-variable)) + +;;; Numerical type predicates + +(defun floatp (object) + (and (funcall (@ (guile) real?) object) + (or (funcall (@ (guile) inexact?) object) + (null (funcall (@ (guile) integer?) object))))) + +(defun integerp (object) + (and (funcall (@ (guile) integer?) object) + (funcall (@ (guile) exact?) object))) + +(defun numberp (object) + (funcall (@ (guile) real?) object)) + +(defun wholenump (object) + (and (integerp object) (>= object 0))) + +(defun zerop (object) + (= object 0)) + +;;; Numerical comparisons + +(fset '= (@ (guile) =)) + +(defun /= (num1 num2) + (null (= num1 num2))) + +(fset '< (@ (guile) <)) +(fset '<= (@ (guile) <=)) +(fset '> (@ (guile) >)) +(fset '>= (@ (guile) >=)) + +(defun max (&rest numbers) + (apply (@ (guile) max) numbers)) + +(defun min (&rest numbers) + (apply (@ (guile) min) numbers)) + +;;; Arithmetic functions + +(fset '1+ (@ (guile) 1+)) +(fset '1- (@ (guile) 1-)) +(fset '+ (@ (guile) +)) +(fset '- (@ (guile) -)) +(fset '* (@ (guile) *)) +(fset '% (@ (guile) modulo)) +(fset 'abs (@ (guile) abs)) + +;;; Floating-point rounding + +(fset 'ffloor (@ (guile) floor)) +(fset 'fceiling (@ (guile) ceiling)) +(fset 'ftruncate (@ (guile) truncate)) +(fset 'fround (@ (guile) round)) + +;;; Numeric conversion + +(defun float (arg) + (if (numberp arg) + (funcall (@ (guile) exact->inexact) arg) + (signal 'wrong-type-argument `(numberp ,arg)))) + +;;; List predicates + +(fset 'not #'null) + +(defun atom (object) + (null (consp object))) + +(defun nlistp (object) + (null (listp object))) + +;;; Lists + +(fset 'cons (@ (guile) cons)) +(fset 'list (@ (guile) list)) +(fset 'make-list (@ (guile) make-list)) +(fset 'append (@ (guile) append)) +(fset 'reverse (@ (guile) reverse)) +(fset 'nreverse (@ (guile) reverse!)) + +(defun car-safe (object) + (if (consp object) + (car object) + nil)) + +(defun cdr-safe (object) + (if (consp object) + (cdr object) + nil)) + +(defun setcar (cell newcar) + (if (consp cell) + (progn + (funcall (@ (guile) set-car!) cell newcar) + newcar) + (signal 'wrong-type-argument `(consp ,cell)))) + +(defun setcdr (cell newcdr) + (if (consp cell) + (progn + (funcall (@ (guile) set-cdr!) cell newcdr) + newcdr) + (signal 'wrong-type-argument `(consp ,cell)))) + +(defun nthcdr (n list) + (let ((i 0)) + (while (< i n) + (setq list (cdr list) + i (+ i 1))) + list)) + +(defun nth (n list) + (car (nthcdr n list))) + +(defun %member (elt list test) + (cond + ((null list) nil) + ((consp list) + (if (funcall test elt (car list)) + list + (%member elt (cdr list) test))) + (t (signal 'wrong-type-argument `(listp ,list))))) + +(defun member (elt list) + (%member elt list #'equal)) + +(defun memql (elt list) + (%member elt list #'eql)) + +(defun memq (elt list) + (%member elt list #'eq)) + +(defun assoc (key list) + (funcall (@ (srfi srfi-1) assoc) key list #'equal)) + +(defun assq (key list) + (funcall (@ (srfi srfi-1) assoc) key list #'eq)) + +(defun rplaca (cell newcar) + (funcall (@ (guile) set-car!) cell newcar) + newcar) + +(defun rplacd (cell newcdr) + (funcall (@ (guile) set-cdr!) cell newcdr) + newcdr) + +(defun caar (x) + (car (car x))) + +(defun cadr (x) + (car (cdr x))) + +(defun cdar (x) + (cdr (car x))) + +(defun cddr (x) + (cdr (cdr x))) + +(defmacro dolist (spec &rest body) + (apply #'(lambda (var list &optional result) + `(mapc #'(lambda (,var) + ,@body + ,result) + ,list)) + spec)) + +;;; Strings + +(defun string (&rest characters) + (funcall (@ (guile) list->string) + (mapcar (@ (guile) integer->char) characters))) + +(defun stringp (object) + (funcall (@ (guile) string?) object)) + +(defun string-equal (s1 s2) + (let ((s1 (if (symbolp s1) (symbol-name s1) s1)) + (s2 (if (symbolp s2) (symbol-name s2) s2))) + (funcall (@ (guile) string=?) s1 s2))) + +(fset 'string= 'string-equal) + +(defun substring (string from &optional to) + (apply (@ (guile) substring) string from (if to (list to) nil))) + +(defun upcase (obj) + (funcall (@ (guile) string-upcase) obj)) + +(defun downcase (obj) + (funcall (@ (guile) string-downcase) obj)) + +(defun string-match (regexp string &optional start) + (let ((m (funcall (@ (ice-9 regex) string-match) + regexp + string + (or start 0)))) + (if m + (funcall (@ (ice-9 regex) match:start) m 0) + nil))) + +;; Vectors + +(defun make-vector (length init) + (funcall (@ (guile) make-vector) length init)) + +;;; Sequences + +(defun length (sequence) + (funcall (if (listp sequence) + (@ (guile) length) + (@ (guile) generalized-vector-length)) + sequence)) + +(defun mapcar (function sequence) + (funcall (@ (guile) map) function sequence)) + +(defun mapc (function sequence) + (funcall (@ (guile) for-each) function sequence) + sequence) + +(defun aref (array idx) + (funcall (@ (guile) generalized-vector-ref) array idx)) + +(defun aset (array idx newelt) + (funcall (@ (guile) generalized-vector-set!) array idx newelt) + newelt) + +(defun concat (&rest sequences) + (apply (@ (guile) string-append) sequences)) + +;;; Property lists + +(defun %plist-member (plist property test) + (cond + ((null plist) nil) + ((consp plist) + (if (funcall test (car plist) property) + (cdr plist) + (%plist-member (cdr (cdr plist)) property test))) + (t (signal 'wrong-type-argument `(listp ,plist))))) + +(defun %plist-get (plist property test) + (car (%plist-member plist property test))) + +(defun %plist-put (plist property value test) + (let ((x (%plist-member plist property test))) + (if x + (progn (setcar x value) plist) + (cons property (cons value plist))))) + +(defun plist-get (plist property) + (%plist-get plist property #'eq)) + +(defun plist-put (plist property value) + (%plist-put plist property value #'eq)) + +(defun plist-member (plist property) + (%plist-member plist property #'eq)) + +(defun lax-plist-get (plist property) + (%plist-get plist property #'equal)) + +(defun lax-plist-put (plist property value) + (%plist-put plist property value #'equal)) + +(defvar plist-function (funcall (@ (guile) make-object-property))) + +(defun symbol-plist (symbol) + (funcall plist-function symbol)) + +(defun setplist (symbol plist) + (funcall (funcall (@ (guile) setter) plist-function) symbol plist)) + +(defun get (symbol propname) + (plist-get (symbol-plist symbol) propname)) + +(defun put (symbol propname value) + (setplist symbol (plist-put (symbol-plist symbol) propname value))) + +;;; Nonlocal exits + +(defmacro condition-case (var bodyform &rest handlers) + (let ((key (make-symbol "key")) + (error-symbol (make-symbol "error-symbol")) + (data (make-symbol "data")) + (conditions (make-symbol "conditions"))) + (flet ((handler->cond-clause (handler) + `((or ,@(mapcar #'(lambda (c) `(memq ',c ,conditions)) + (if (consp (car handler)) + (car handler) + (list (car handler))))) + ,@(cdr handler)))) + `(funcall (@ (guile) catch) + 'elisp-condition + #'(lambda () ,bodyform) + #'(lambda (,key ,error-symbol ,data) + (declare (lexical ,key ,error-symbol ,data)) + (let ((,conditions + (get ,error-symbol 'error-conditions)) + ,@(if var + `((,var (cons ,error-symbol ,data))) + '())) + (declare (lexical ,conditions + ,@(if var `(,var) '()))) + (cond ,@(mapcar #'handler->cond-clause handlers) + (t (signal ,error-symbol ,data))))))))) + +(put 'error 'error-conditions '(error)) +(put 'wrong-type-argument 'error-conditions '(wrong-type-argument error)) +(put 'invalid-function 'error-conditions '(invalid-function error)) +(put 'no-catch 'error-conditions '(no-catch error)) +(put 'throw 'error-conditions '(throw)) + +(defvar %catch nil) + +(defmacro catch (tag &rest body) + (let ((tag-value (make-symbol "tag-value")) + (c (make-symbol "c")) + (data (make-symbol "data"))) + `(let ((,tag-value ,tag)) + (declare (lexical ,tag-value)) + (condition-case ,c + (let ((%catch t)) + ,@body) + (throw + (let ((,data (cdr ,c))) + (declare (lexical ,data)) + (if (eq (car ,data) ,tag-value) + (car (cdr ,data)) + (apply #'throw ,data)))))))) + +(defun throw (tag value) + (signal (if %catch 'throw 'no-catch) (list tag value))) + +;;; I/O + +(defun princ (object) + (funcall (@ (guile) display) object)) + +(defun print (object) + (funcall (@ (guile) write) object)) + +(defun terpri () + (funcall (@ (guile) newline))) + +(defun format* (stream string &rest args) + (apply (@ (guile) format) stream string args)) + +(defun send-string-to-terminal (string) + (princ string)) + +(defun read-from-minibuffer (prompt &rest ignore) + (princ prompt) + (let ((value (funcall (@ (ice-9 rdelim) read-line)))) + (if (funcall (@ (guile) eof-object?) value) + "" + value))) + +(defun prin1-to-string (object) + (format* nil "~S" object)) + +;; Random number generation + +(defvar %random-state (funcall (@ (guile) copy-random-state) + (@ (guile) *random-state*))) + +(defun random (&optional limit) + (if (eq limit t) + (setq %random-state + (funcall (@ (guile) random-state-from-platform)))) + (funcall (@ (guile) random) + (if (wholenump limit) + limit + (@ (guile) most-positive-fixnum)) + %random-state)) diff --git a/module/language/elisp/compile-tree-il.scm b/module/language/elisp/compile-tree-il.scm index 0df21c7e6..1a4d00faa 100644 --- a/module/language/elisp/compile-tree-il.scm +++ b/module/language/elisp/compile-tree-il.scm @@ -1,6 +1,6 @@ ;;; Guile Emacs Lisp -;; Copyright (C) 2009, 2010 Free Software Foundation, Inc. +;; Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc. ;; This program is free software; you can redistribute it and/or modify ;; it under the terms of the GNU General Public License as published by @@ -31,26 +31,24 @@ #:use-module (srfi srfi-26) #:export (compile-tree-il compile-progn + compile-eval-when-compile compile-if compile-defconst compile-defvar compile-setq compile-let - compile-lexical-let compile-flet + compile-labels compile-let* - compile-lexical-let* - compile-flet* - compile-without-void-checks - compile-with-always-lexical compile-guile-ref compile-guile-primitive - compile-while compile-function compile-defmacro compile-defun #{compile-`}# - compile-quote)) + compile-quote + compile-%funcall + compile-%set-lexical-binding-mode)) ;;; Certain common parameters (like the bindings data structure or ;;; compiler options) are not always passed around but accessed using @@ -61,14 +59,7 @@ (define bindings-data (make-fluid)) -;;; Store for which symbols (or all/none) void checks are disabled. - -(define disable-void-check (make-fluid)) - -;;; Store which symbols (or all/none) should always be bound lexically, -;;; even with ordinary let and as lambda arguments. - -(define always-lexical (make-fluid)) +(define lexical-binding (make-fluid)) ;;; Find the source properties of some parsed expression if there are ;;; any associated with it. @@ -109,7 +100,7 @@ ;;; Build a call to a primitive procedure nicely. (define (call-primitive loc sym . args) - (make-application loc (make-primitive-ref loc sym) args)) + (make-primcall loc sym args)) ;;; Error reporting routine for syntax/compilation problems or build ;;; code for a runtime-error output. @@ -117,422 +108,253 @@ (define (report-error loc . args) (apply error args)) -(define (runtime-error loc msg . args) - (make-application loc - (make-primitive-ref loc 'error) - (cons (make-const loc msg) args))) - -;;; Generate code to ensure a global symbol is there for further use of -;;; a given symbol. In general during the compilation, those needed are -;;; only tracked with the bindings data structure. Afterwards, however, -;;; for all those needed symbols the globals are really generated with -;;; this routine. - -(define (generate-ensure-global loc sym module) - (make-application loc - (make-module-ref loc runtime 'ensure-fluid! #t) - (list (make-const loc module) - (make-const loc sym)))) - -(define (ensuring-globals loc bindings body) - (make-sequence - loc - `(,@(map-globals-needed (fluid-ref bindings) - (lambda (mod sym) - (generate-ensure-global loc sym mod))) - ,body))) - -;;; Build a construct that establishes dynamic bindings for certain -;;; variables. We may want to choose between binding with fluids and -;;; with-fluids* and using just ordinary module symbols and -;;; setting/reverting their values with a dynamic-wind. - -(define (let-dynamic loc syms module vals body) - (call-primitive - loc - 'with-fluids* - (make-application loc - (make-primitive-ref loc 'list) - (map (lambda (sym) - (make-module-ref loc module sym #t)) - syms)) - (make-application loc (make-primitive-ref loc 'list) vals) - (make-lambda loc - '() - (make-lambda-case #f '() #f #f #f '() '() body #f)))) - -;;; Handle access to a variable (reference/setting) correctly depending -;;; on whether it is currently lexically or dynamically bound. lexical -;;; access is done only for references to the value-slot module! - -(define (access-variable loc - sym - module - handle-global - handle-lexical - handle-dynamic) - (let ((lexical (get-lexical-binding (fluid-ref bindings-data) sym))) - (cond - (lexical (handle-lexical lexical)) - ((equal? module function-slot) (handle-global)) - (else (handle-dynamic))))) - -;;; Generate code to reference a variable. For references in the -;;; value-slot module, we may want to generate a lexical reference -;;; instead if the variable has a lexical binding. +(define (access-variable loc symbol handle-lexical handle-dynamic) + (cond + ((get-lexical-binding (fluid-ref bindings-data) symbol) + => handle-lexical) + (else + (handle-dynamic)))) -(define (reference-variable loc sym module) +(define (reference-variable loc symbol) (access-variable loc - sym - module - (lambda () (make-module-ref loc module sym #t)) - (lambda (lexical) (make-lexical-ref loc lexical lexical)) + symbol + (lambda (lexical) + (make-lexical-ref loc lexical lexical)) (lambda () - (mark-global-needed! (fluid-ref bindings-data) sym module) (call-primitive loc 'fluid-ref - (make-module-ref loc module sym #t))))) - -;;; Generate code to set a variable. Just as with reference-variable, in -;;; case of a reference to value-slot, we want to generate a lexical set -;;; when the variable has a lexical binding. - -(define (set-variable! loc sym module value) + (make-module-ref loc value-slot symbol #t))))) + +(define (global? module symbol) + (module-variable module symbol)) + +(define (ensure-globals! loc names body) + (if (and (every (cut global? (resolve-module value-slot) <>) names) + (every symbol-interned? names)) + body + (list->seq + loc + `(,@(map + (lambda (name) + (ensure-fluid! value-slot name) + (make-call loc + (make-module-ref loc runtime 'ensure-fluid! #t) + (list (make-const loc value-slot) + (make-const loc name)))) + names) + ,body)))) + +(define (set-variable! loc symbol value) (access-variable loc - sym - module + symbol + (lambda (lexical) + (make-lexical-set loc lexical lexical value)) (lambda () - (make-application + (ensure-globals! loc - (make-module-ref loc runtime 'set-variable! #t) - (list (make-const loc module) (make-const loc sym) value))) - (lambda (lexical) (make-lexical-set loc lexical lexical value)) + (list symbol) + (call-primitive loc + 'fluid-set! + (make-module-ref loc value-slot symbol #t) + value))))) + +(define (access-function loc symbol handle-lexical handle-global) + (cond + ((get-function-binding (fluid-ref bindings-data) symbol) + => handle-lexical) + (else + (handle-global)))) + +(define (reference-function loc symbol) + (access-function + loc + symbol + (lambda (gensym) (make-lexical-ref loc symbol gensym)) + (lambda () (make-module-ref loc function-slot symbol #t)))) + +(define (set-function! loc symbol value) + (access-function + loc + symbol + (lambda (gensym) (make-lexical-set loc symbol gensym value)) (lambda () - (mark-global-needed! (fluid-ref bindings-data) sym module) - (call-primitive loc - 'fluid-set! - (make-module-ref loc module sym #t) - value)))) - -;;; Process the bindings part of a let or let* expression; that is, -;;; check for correctness and bring it to the form ((sym1 . val1) (sym2 -;;; . val2) ...). - -(define (process-let-bindings loc bindings) - (map - (lambda (b) - (if (symbol? b) - (cons b 'nil) - (if (or (not (list? b)) - (not (= (length b) 2))) - (report-error - loc - "expected symbol or list of 2 elements in let") - (if (not (symbol? (car b))) - (report-error loc "expected symbol in let") - (cons (car b) (cadr b)))))) - bindings)) - -;;; Split the let bindings into a list to be done lexically and one -;;; dynamically. A symbol will be bound lexically if and only if: We're -;;; processing a lexical-let (i.e. module is 'lexical), OR we're -;;; processing a value-slot binding AND the symbol is already lexically -;;; bound or is always lexical, OR we're processing a function-slot -;;; binding. - -(define (bind-lexically? sym module) - (or (eq? module 'lexical) - (eq? module function-slot) - (and (equal? module value-slot) - (let ((always (fluid-ref always-lexical))) - (or (eq? always 'all) - (memq sym always) - (get-lexical-binding (fluid-ref bindings-data) sym)))))) - -(define (split-let-bindings bindings module) - (let iterate ((tail bindings) - (lexical '()) - (dynamic '())) - (if (null? tail) - (values (reverse lexical) (reverse dynamic)) - (if (bind-lexically? (caar tail) module) - (iterate (cdr tail) (cons (car tail) lexical) dynamic) - (iterate (cdr tail) lexical (cons (car tail) dynamic)))))) - -;;; Compile let and let* expressions. The code here is used both for -;;; let/let* and flet/flet*, just with a different bindings module. -;;; -;;; A special module value 'lexical means that we're doing a lexical-let -;;; instead and the bindings should not be saved to globals at all but -;;; be done with the lexical framework instead. - -;;; Let is done with a single call to let-dynamic binding them locally -;;; to new values all "at once". If there is at least one variable to -;;; bind lexically among the bindings, we first do a let for all of them -;;; to evaluate all values before any bindings take place, and then call -;;; let-dynamic for the variables to bind dynamically. - -(define (generate-let loc module bindings body) - (let ((bind (process-let-bindings loc bindings))) - (call-with-values - (lambda () (split-let-bindings bind module)) - (lambda (lexical dynamic) - (for-each (lambda (sym) - (mark-global-needed! (fluid-ref bindings-data) - sym - module)) - (map car dynamic)) - (let ((make-values (lambda (for) - (map (lambda (el) (compile-expr (cdr el))) - for))) - (make-body (lambda () - (make-sequence loc (map compile-expr body))))) - (if (null? lexical) - (let-dynamic loc (map car dynamic) module - (make-values dynamic) (make-body)) - (let* ((lexical-syms (map (lambda (el) (gensym)) lexical)) - (dynamic-syms (map (lambda (el) (gensym)) dynamic)) - (all-syms (append lexical-syms dynamic-syms)) - (vals (append (make-values lexical) - (make-values dynamic)))) - (make-let loc - all-syms - all-syms - vals - (with-lexical-bindings - (fluid-ref bindings-data) - (map car lexical) lexical-syms - (lambda () - (if (null? dynamic) - (make-body) - (let-dynamic loc - (map car dynamic) - module - (map - (lambda (sym) - (make-lexical-ref loc - sym - sym)) - dynamic-syms) - (make-body))))))))))))) - -;;; Let* is compiled to a cascaded set of "small lets" for each binding -;;; in turn so that each one already sees the preceding bindings. - -(define (generate-let* loc module bindings body) - (let ((bind (process-let-bindings loc bindings))) - (begin - (for-each (lambda (sym) - (if (not (bind-lexically? sym module)) - (mark-global-needed! (fluid-ref bindings-data) - sym - module))) - (map car bind)) - (let iterate ((tail bind)) - (if (null? tail) - (make-sequence loc (map compile-expr body)) - (let ((sym (caar tail)) - (value (compile-expr (cdar tail)))) - (if (bind-lexically? sym module) - (let ((target (gensym))) - (make-let loc - `(,target) - `(,target) - `(,value) - (with-lexical-bindings - (fluid-ref bindings-data) - `(,sym) - `(,target) - (lambda () (iterate (cdr tail)))))) - (let-dynamic loc - `(,(caar tail)) - module - `(,value) - (iterate (cdr tail)))))))))) - -;;; Split the argument list of a lambda expression into required, -;;; optional and rest arguments and also check it is actually valid. -;;; Additionally, we create a list of all "local variables" (that is, -;;; required, optional and rest arguments together) and also this one -;;; split into those to be bound lexically and dynamically. Returned is -;;; as multiple values: required optional rest lexical dynamic - -(define (bind-arg-lexical? arg) - (let ((always (fluid-ref always-lexical))) - (or (eq? always 'all) - (memq arg always)))) - -(define (split-lambda-arguments loc args) - (let iterate ((tail args) - (mode 'required) - (required '()) - (optional '()) - (lexical '()) - (dynamic '())) - (cond - ((null? tail) - (let ((final-required (reverse required)) - (final-optional (reverse optional)) - (final-lexical (reverse lexical)) - (final-dynamic (reverse dynamic))) - (values final-required - final-optional - #f - final-lexical - final-dynamic))) - ((and (eq? mode 'required) - (eq? (car tail) '&optional)) - (iterate (cdr tail) 'optional required optional lexical dynamic)) - ((eq? (car tail) '&rest) - (if (or (null? (cdr tail)) - (not (null? (cddr tail)))) - (report-error loc "expected exactly one symbol after &rest") - (let* ((rest (cadr tail)) - (rest-lexical (bind-arg-lexical? rest)) - (final-required (reverse required)) - (final-optional (reverse optional)) - (final-lexical (reverse (if rest-lexical - (cons rest lexical) - lexical))) - (final-dynamic (reverse (if rest-lexical - dynamic - (cons rest dynamic))))) - (values final-required - final-optional - rest - final-lexical - final-dynamic)))) - (else - (if (not (symbol? (car tail))) - (report-error loc - "expected symbol in argument list, got" - (car tail)) - (let* ((arg (car tail)) - (bind-lexical (bind-arg-lexical? arg)) - (new-lexical (if bind-lexical - (cons arg lexical) - lexical)) - (new-dynamic (if bind-lexical - dynamic - (cons arg dynamic)))) - (case mode - ((required) (iterate (cdr tail) mode - (cons arg required) optional - new-lexical new-dynamic)) - ((optional) (iterate (cdr tail) mode - required (cons arg optional) - new-lexical new-dynamic)) - (else - (error "invalid mode in split-lambda-arguments" - mode))))))))) - -;;; Compile a lambda expression. One thing we have to be aware of is -;;; that lambda arguments are usually dynamically bound, even when a -;;; lexical binding is intact for a symbol. For symbols that are marked -;;; as 'always lexical,' however, we lexically bind here as well, and -;;; thus we get them out of the let-dynamic call and register a lexical -;;; binding for them (the lexical target variable is already there, -;;; namely the real lambda argument from TreeIL). - -(define (compile-lambda loc args body) - (if (not (list? args)) - (report-error loc "expected list for argument-list" args)) - (if (null? body) - (report-error loc "function body must not be empty")) - (receive (required optional rest lexical dynamic) - (split-lambda-arguments loc args) - (define (process-args args) - (define (find-pairs pairs filter) - (lset-intersection (lambda (name+sym x) - (eq? (car name+sym) x)) - pairs - filter)) - (let* ((syms (map (lambda (x) (gensym)) args)) - (pairs (map cons args syms)) - (lexical-pairs (find-pairs pairs lexical)) - (dynamic-pairs (find-pairs pairs dynamic))) - (values syms pairs lexical-pairs dynamic-pairs))) - (let*-values (((required-syms - required-pairs - required-lex-pairs - required-dyn-pairs) - (process-args required)) - ((optional-syms - optional-pairs - optional-lex-pairs - optional-dyn-pairs) - (process-args optional)) - ((rest-syms rest-pairs rest-lex-pairs rest-dyn-pairs) - (process-args (if rest (list rest) '()))) - ((the-rest-sym) (if rest (car rest-syms) #f)) - ((all-syms) (append required-syms - optional-syms - rest-syms)) - ((all-lex-pairs) (append required-lex-pairs - optional-lex-pairs - rest-lex-pairs)) - ((all-dyn-pairs) (append required-dyn-pairs - optional-dyn-pairs - rest-dyn-pairs))) - (for-each (lambda (sym) - (mark-global-needed! (fluid-ref bindings-data) - sym - value-slot)) - dynamic) - (with-dynamic-bindings - (fluid-ref bindings-data) - dynamic - (lambda () - (with-lexical-bindings - (fluid-ref bindings-data) - (map car all-lex-pairs) - (map cdr all-lex-pairs) - (lambda () - (make-lambda - loc - '() - (make-lambda-case - #f - required - optional - rest - #f - (map (lambda (x) (nil-value loc)) optional) - all-syms - (let ((compiled-body - (make-sequence loc (map compile-expr body)))) - (make-sequence - loc - (list - (if rest - (make-conditional - loc - (call-primitive loc - 'null? - (make-lexical-ref loc - rest - the-rest-sym)) - (make-lexical-set loc - rest - the-rest-sym - (nil-value loc)) - (make-void loc)) - (make-void loc)) - (if (null? dynamic) - compiled-body - (let-dynamic loc - dynamic - value-slot - (map (lambda (name-sym) - (make-lexical-ref - loc - (car name-sym) - (cdr name-sym))) - all-dyn-pairs) - compiled-body))))) - #f))))))))) + (make-call + loc + (make-module-ref loc runtime 'set-symbol-function! #t) + (list (make-const loc symbol) value))))) + +(define (bind-lexically? sym module decls) + (or (eq? module function-slot) + (let ((decl (assq-ref decls sym))) + (and (equal? module value-slot) + (or + (eq? decl 'lexical) + (and + (fluid-ref lexical-binding) + (not (global? (resolve-module module) sym)))))))) + +(define (parse-let-binding loc binding) + (pmatch binding + ((unquote var) + (guard (symbol? var)) + (cons var #nil)) + ((,var) + (guard (symbol? var)) + (cons var #nil)) + ((,var ,val) + (guard (symbol? var)) + (cons var val)) + (else + (report-error loc "malformed variable binding" binding)))) + +(define (parse-flet-binding loc binding) + (pmatch binding + ((,var ,args . ,body) + (guard (symbol? var)) + (cons var `(function (lambda ,args ,@body)))) + (else + (report-error loc "malformed function binding" binding)))) + +(define (parse-declaration expr) + (pmatch expr + ((lexical . ,vars) + (map (cut cons <> 'lexical) vars)) + (else + '()))) + +(define (parse-body-1 body lambda?) + (let loop ((lst body) + (decls '()) + (intspec #f) + (doc #f)) + (pmatch lst + (((declare . ,x) . ,tail) + (loop tail (append-reverse x decls) intspec doc)) + (((interactive . ,x) . ,tail) + (guard lambda? (not intspec)) + (loop tail decls x doc)) + ((,x . ,tail) + (guard lambda? (string? x) (not doc) (not (null? tail))) + (loop tail decls intspec x)) + (else + (values (append-map parse-declaration decls) + intspec + doc + lst))))) + +(define (parse-lambda-body body) + (parse-body-1 body #t)) + +(define (parse-body body) + (receive (decls intspec doc body) (parse-body-1 body #f) + (values decls body))) + +;;; Partition the argument list of a lambda expression into required, +;;; optional and rest arguments. + +(define (parse-lambda-list lst) + (define (%match lst null optional rest symbol) + (pmatch lst + (() (null)) + ((&optional . ,tail) (optional tail)) + ((&rest . ,tail) (rest tail)) + ((,arg . ,tail) (guard (symbol? arg)) (symbol arg tail)) + (else (fail)))) + (define (return rreq ropt rest) + (values #t (reverse rreq) (reverse ropt) rest)) + (define (fail) + (values #f #f #f #f)) + (define (parse-req lst rreq) + (%match lst + (lambda () (return rreq '() #f)) + (lambda (tail) (parse-opt tail rreq '())) + (lambda (tail) (parse-rest tail rreq '())) + (lambda (arg tail) (parse-req tail (cons arg rreq))))) + (define (parse-opt lst rreq ropt) + (%match lst + (lambda () (return rreq ropt #f)) + (lambda (tail) (fail)) + (lambda (tail) (parse-rest tail rreq ropt)) + (lambda (arg tail) (parse-opt tail rreq (cons arg ropt))))) + (define (parse-rest lst rreq ropt) + (%match lst + (lambda () (fail)) + (lambda (tail) (fail)) + (lambda (tail) (fail)) + (lambda (arg tail) (parse-post-rest tail rreq ropt arg)))) + (define (parse-post-rest lst rreq ropt rest) + (%match lst + (lambda () (return rreq ropt rest)) + (lambda () (fail)) + (lambda () (fail)) + (lambda (arg tail) (fail)))) + (parse-req lst '())) + +(define (make-simple-lambda loc meta req opt init rest vars body) + (make-lambda loc + meta + (make-lambda-case #f req opt rest #f init vars body #f))) + +(define (compile-lambda loc meta args body) + (receive (valid? req-ids opt-ids rest-id) + (parse-lambda-list args) + (if valid? + (let* ((all-ids (append req-ids + opt-ids + (or (and=> rest-id list) '()))) + (all-vars (map (lambda (ignore) (gensym)) all-ids))) + (let*-values (((decls intspec doc forms) + (parse-lambda-body body)) + ((lexical dynamic) + (partition + (compose (cut bind-lexically? <> value-slot decls) + car) + (map list all-ids all-vars))) + ((lexical-ids lexical-vars) (unzip2 lexical)) + ((dynamic-ids dynamic-vars) (unzip2 dynamic))) + (with-dynamic-bindings + (fluid-ref bindings-data) + dynamic-ids + (lambda () + (with-lexical-bindings + (fluid-ref bindings-data) + lexical-ids + lexical-vars + (lambda () + (ensure-globals! + loc + dynamic-ids + (let* ((tree-il + (compile-expr + (if rest-id + `(let ((,rest-id (if ,rest-id + ,rest-id + nil))) + ,@forms) + `(progn ,@forms)))) + (full-body + (if (null? dynamic) + tree-il + (make-dynlet + loc + (map (cut make-module-ref loc value-slot <> #t) + dynamic-ids) + (map (cut make-lexical-ref loc <> <>) + dynamic-ids + dynamic-vars) + tree-il)))) + (make-simple-lambda loc + meta + req-ids + opt-ids + (map (const (nil-value loc)) + opt-ids) + rest-id + all-vars + full-body))))))))) + (report-error "invalid function" `(lambda ,args ,@body))))) ;;; Handle the common part of defconst and defvar, that is, checking for ;;; a correct doc string and arguments as well as maybe in the future @@ -550,12 +372,11 @@ ;;; Handle macro and special operator bindings. -(define (find-operator sym type) +(define (find-operator name type) (and - (symbol? sym) - (module-defined? (resolve-interface function-slot) sym) - (let* ((op (module-ref (resolve-module function-slot) sym)) - (op (if (fluid? op) (fluid-ref op) op))) + (symbol? name) + (module-defined? (resolve-interface function-slot) name) + (let ((op (module-ref (resolve-module function-slot) name))) (if (and (pair? op) (eq? (car op) type)) (cdr op) #f)))) @@ -611,87 +432,67 @@ expr)) (make-const loc expr))) -;;; Temporarily update a list of symbols that are handled specially -;;; (disabled void check or always lexical) for compiling body. We need -;;; to handle special cases for already all / set to all and the like. - -(define (with-added-symbols loc fluid syms body) - (if (null? body) - (report-error loc "symbol-list construct has empty body")) - (if (not (or (eq? syms 'all) - (and (list? syms) (and-map symbol? syms)))) - (report-error loc "invalid symbol list" syms)) - (let ((old (fluid-ref fluid)) - (make-body (lambda () - (make-sequence loc (map compile-expr body))))) - (if (eq? old 'all) - (make-body) - (let ((new (if (eq? syms 'all) - 'all - (append syms old)))) - (with-fluids ((fluid new)) - (make-body)))))) - ;;; Special operators (defspecial progn (loc args) - (make-sequence loc (map compile-expr args))) + (list->seq loc + (if (null? args) + (list (nil-value loc)) + (map compile-expr args)))) + +(defspecial eval-when-compile (loc args) + (make-const loc (compile `(progn ,@args) #:from 'elisp #:to 'value))) (defspecial if (loc args) (pmatch args ((,cond ,then . ,else) - (make-conditional loc - (compile-expr cond) - (compile-expr then) - (if (null? else) - (nil-value loc) - (make-sequence loc - (map compile-expr else))))))) + (make-conditional + loc + (call-primitive loc 'not + (call-primitive loc 'nil? (compile-expr cond))) + (compile-expr then) + (compile-expr `(progn ,@else)))))) (defspecial defconst (loc args) (pmatch args ((,sym ,value . ,doc) (if (handle-var-def loc sym doc) - (make-sequence loc - (list (set-variable! loc - sym - value-slot - (compile-expr value)) - (make-const loc sym))))))) + (make-seq loc + (set-variable! loc sym (compile-expr value)) + (make-const loc sym)))))) (defspecial defvar (loc args) (pmatch args ((,sym) (make-const loc sym)) ((,sym ,value . ,doc) (if (handle-var-def loc sym doc) - (make-sequence + (make-seq loc - (list + (make-conditional + loc (make-conditional loc - (make-conditional + (call-primitive loc - (call-primitive - loc - 'module-bound? - (call-primitive loc - 'resolve-interface - (make-const loc value-slot)) - (make-const loc sym)) + 'module-bound? (call-primitive loc - 'fluid-bound? - (make-module-ref loc value-slot sym #t)) - (make-const loc #f)) - (make-void loc) - (set-variable! loc sym value-slot (compile-expr value))) - (make-const loc sym))))))) + 'resolve-interface + (make-const loc value-slot)) + (make-const loc sym)) + (call-primitive loc + 'fluid-bound? + (make-module-ref loc value-slot sym #t)) + (make-const loc #f)) + (make-void loc) + (set-variable! loc sym (compile-expr value))) + (make-const loc sym)))))) (defspecial setq (loc args) (define (car* x) (if (null? x) '() (car x))) (define (cdr* x) (if (null? x) '() (cdr x))) (define (cadr* x) (car* (cdr* x))) (define (cddr* x) (cdr* (cdr* x))) - (make-sequence + (list->seq loc (let loop ((args args) (last (nil-value loc))) (if (null? args) @@ -701,47 +502,141 @@ (if (not (symbol? sym)) (report-error loc "expected symbol in setq") (cons - (set-variable! loc sym value-slot val) + (set-variable! loc sym val) (loop (cddr* args) - (reference-variable loc sym value-slot))))))))) + (reference-variable loc sym))))))))) (defspecial let (loc args) (pmatch args - ((,bindings . ,body) - (generate-let loc value-slot bindings body)))) - -(defspecial lexical-let (loc args) - (pmatch args - ((,bindings . ,body) - (generate-let loc 'lexical bindings body)))) - -(defspecial flet (loc args) - (pmatch args - ((,bindings . ,body) - (generate-let loc function-slot bindings body)))) + ((,varlist . ,body) + (let ((bindings (map (cut parse-let-binding loc <>) varlist))) + (receive (decls forms) (parse-body body) + (receive (lexical dynamic) + (partition + (compose (cut bind-lexically? <> value-slot decls) + car) + bindings) + (let ((make-values (lambda (for) + (map (lambda (el) (compile-expr (cdr el))) + for))) + (make-body (lambda () (compile-expr `(progn ,@forms))))) + (ensure-globals! + loc + (map car dynamic) + (if (null? lexical) + (make-dynlet loc + (map (compose (cut make-module-ref + loc + value-slot + <> + #t) + car) + dynamic) + (map (compose compile-expr cdr) + dynamic) + (make-body)) + (let* ((lexical-syms (map (lambda (el) (gensym)) lexical)) + (dynamic-syms (map (lambda (el) (gensym)) dynamic)) + (all-syms (append lexical-syms dynamic-syms)) + (vals (append (make-values lexical) + (make-values dynamic)))) + (make-let loc + all-syms + all-syms + vals + (with-lexical-bindings + (fluid-ref bindings-data) + (map car lexical) + lexical-syms + (lambda () + (if (null? dynamic) + (make-body) + (make-dynlet loc + (map + (compose + (cut make-module-ref + loc + value-slot + <> + #t) + car) + dynamic) + (map + (lambda (sym) + (make-lexical-ref + loc + sym + sym)) + dynamic-syms) + (make-body)))))))))))))))) (defspecial let* (loc args) (pmatch args - ((,bindings . ,body) - (generate-let* loc value-slot bindings body)))) + ((,varlist . ,body) + (let ((bindings (map (cut parse-let-binding loc <>) varlist))) + (receive (decls forms) (parse-body body) + (let iterate ((tail bindings)) + (if (null? tail) + (compile-expr `(progn ,@forms)) + (let ((sym (caar tail)) + (value (compile-expr (cdar tail)))) + (if (bind-lexically? sym value-slot decls) + (let ((target (gensym))) + (make-let loc + `(,target) + `(,target) + `(,value) + (with-lexical-bindings + (fluid-ref bindings-data) + `(,sym) + `(,target) + (lambda () (iterate (cdr tail)))))) + (ensure-globals! + loc + (list sym) + (make-dynlet loc + (list (make-module-ref loc value-slot sym #t)) + (list value) + (iterate (cdr tail))))))))))))) -(defspecial lexical-let* (loc args) +(defspecial flet (loc args) (pmatch args ((,bindings . ,body) - (generate-let* loc 'lexical bindings body)))) - -(defspecial flet* (loc args) + (let ((names+vals (map (cut parse-flet-binding loc <>) bindings))) + (receive (decls forms) (parse-body body) + (let ((names (map car names+vals)) + (vals (map cdr names+vals)) + (gensyms (map (lambda (x) (gensym)) names+vals))) + (with-function-bindings + (fluid-ref bindings-data) + names + gensyms + (lambda () + (make-let loc + names + gensyms + (map compile-expr vals) + (compile-expr `(progn ,@forms))))))))))) + +(defspecial labels (loc args) (pmatch args ((,bindings . ,body) - (generate-let* loc function-slot bindings body)))) - -;;; Temporarily set symbols as always lexical only for the lexical scope -;;; of a construct. - -(defspecial with-always-lexical (loc args) - (pmatch args - ((,syms . ,body) - (with-added-symbols loc always-lexical syms body)))) + (let ((names+vals (map (cut parse-flet-binding loc <>) bindings))) + (receive (decls forms) (parse-body body) + (let ((names (map car names+vals)) + (vals (map cdr names+vals)) + (gensyms (map (lambda (x) (gensym)) names+vals))) + (with-function-bindings + (fluid-ref bindings-data) + names + gensyms + (lambda () + (make-letrec #f + loc + names + gensyms + (map compile-expr vals) + (compile-expr `(progn ,@forms))))))))))) ;;; guile-ref allows building TreeIL's module references from within ;;; elisp as a way to access data within the Guile universe. The module @@ -761,59 +656,12 @@ ((,sym) (make-primitive-ref loc sym)))) -;;; A while construct is transformed into a tail-recursive loop like -;;; this: -;;; -;;; (letrec ((iterate (lambda () -;;; (if condition -;;; (begin body -;;; (iterate)) -;;; #nil)))) -;;; (iterate)) -;;; -;;; As letrec is not directly accessible from elisp, while is -;;; implemented here instead of with a macro. - -(defspecial while (loc args) - (pmatch args - ((,condition . ,body) - (let* ((itersym (gensym)) - (compiled-body (map compile-expr body)) - (iter-call (make-application loc - (make-lexical-ref loc - 'iterate - itersym) - (list))) - (full-body (make-sequence loc - `(,@compiled-body ,iter-call))) - (lambda-body (make-conditional loc - (compile-expr condition) - full-body - (nil-value loc))) - (iter-thunk (make-lambda loc - '() - (make-lambda-case #f - '() - #f - #f - #f - '() - '() - lambda-body - #f)))) - (make-letrec loc - #f - '(iterate) - (list itersym) - (list iter-thunk) - iter-call))))) - (defspecial function (loc args) (pmatch args (((lambda ,args . ,body)) - (compile-lambda loc args body)) + (compile-lambda loc '() args body)) ((,sym) (guard (symbol? sym)) - (reference-variable loc sym function-slot)))) + (reference-function loc sym)))) (defspecial defmacro (loc args) (pmatch args @@ -821,22 +669,21 @@ (if (not (symbol? name)) (report-error loc "expected symbol as macro name" name) (let* ((tree-il - (make-sequence + (make-seq loc - (list - (set-variable! + (set-function! + loc + name + (make-call loc - name - function-slot - (make-application - loc - (make-module-ref loc '(guile) 'cons #t) - (list (make-const loc 'macro) - (compile-lambda loc args body)))) - (make-const loc name))))) - (compile (ensuring-globals loc bindings-data tree-il) - #:from 'tree-il - #:to 'value) + (make-module-ref loc '(guile) 'cons #t) + (list (make-const loc 'macro) + (compile-lambda loc + `((name . ,name)) + args + body)))) + (make-const loc name)))) + (compile tree-il #:from 'tree-il #:to 'value) tree-il))))) (defspecial defun (loc args) @@ -844,14 +691,14 @@ ((,name ,args . ,body) (if (not (symbol? name)) (report-error loc "expected symbol as function name" name) - (make-sequence loc - (list (set-variable! loc - name - function-slot - (compile-lambda loc - args - body)) - (make-const loc name))))))) + (make-seq loc + (set-function! loc + name + (compile-lambda loc + `((name . ,name)) + args + body)) + (make-const loc name)))))) (defspecial #{`}# (loc args) (pmatch args @@ -863,6 +710,19 @@ ((,val) (make-const loc val)))) +(defspecial %funcall (loc args) + (pmatch args + ((,function . ,arguments) + (make-call loc + (compile-expr function) + (map compile-expr arguments))))) + +(defspecial %set-lexical-binding-mode (loc args) + (pmatch args + ((,val) + (fluid-set! lexical-binding val) + (make-void loc)))) + ;;; Compile a compound expression to Tree-IL. (define (compile-pair loc expr) @@ -876,13 +736,7 @@ => (lambda (macro-function) (compile-expr (apply macro-function arguments)))) (else - (make-application loc - (if (symbol? operator) - (reference-variable loc - operator - function-slot) - (compile-expr operator)) - (map compile-expr arguments)))))) + (compile-expr `(%funcall (function ,operator) ,@arguments)))))) ;;; Compile a symbol expression. This is a variable reference or maybe ;;; some special value like nil. @@ -891,7 +745,7 @@ (case sym ((nil) (nil-value loc)) ((t) (t-value loc)) - (else (reference-variable loc sym value-slot)))) + (else (reference-variable loc sym)))) ;;; Compile a single expression to TreeIL. @@ -921,28 +775,14 @@ (case key ((#:warnings) ; ignore #f) - ((#:always-lexical) - (if (valid-symbol-list-arg? value) - (fluid-set! always-lexical value) - (report-error #f - "Invalid value for #:always-lexical" - value))) (else (report-error #f "Invalid compiler option" key))))))) -;;; Entry point for compilation to TreeIL. This creates the bindings -;;; data structure, and after compiling the main expression we need to -;;; make sure all globals for symbols used during the compilation are -;;; created using the generate-ensure-global function. - (define (compile-tree-il expr env opts) (values - (with-fluids ((bindings-data (make-bindings)) - (disable-void-check '()) - (always-lexical '())) + (with-fluids ((bindings-data (make-bindings))) (process-options! opts) - (let ((compiled (compile-expr expr))) - (ensuring-globals (location expr) bindings-data compiled))) + (compile-expr expr)) env env)) diff --git a/module/language/elisp/falias.scm b/module/language/elisp/falias.scm new file mode 100644 index 000000000..f043548fb --- /dev/null +++ b/module/language/elisp/falias.scm @@ -0,0 +1,27 @@ +(define-module (language elisp falias) + #:export (falias? + make-falias + falias-function + falias-object)) + +(define <falias-vtable> + (make-struct <applicable-struct-vtable> + 0 + (make-struct-layout "pwpw") + (lambda (object port) + (format port "#<falias ~S>" (falias-object object))))) + +(set-struct-vtable-name! <falias-vtable> 'falias) + +(define (falias? object) + (and (struct? object) + (eq? (struct-vtable object) <falias-vtable>))) + +(define (make-falias f object) + (make-struct <falias-vtable> 0 f object)) + +(define (falias-function object) + (struct-ref object 0)) + +(define (falias-object object) + (struct-ref object 1)) diff --git a/module/language/elisp/lexer.scm b/module/language/elisp/lexer.scm index af7e02add..1933ff34d 100644 --- a/module/language/elisp/lexer.scm +++ b/module/language/elisp/lexer.scm @@ -252,7 +252,15 @@ ;;; Main lexer routine, which is given a port and does look for the next ;;; token. +(define lexical-binding-regexp + (make-regexp + "-\\*-(|.*;)[ \t]*lexical-binding:[ \t]*([^;]*[^ \t;]).*-\\*-")) + (define (lex port) + (define (lexical-binding-value string) + (and=> (regexp-exec lexical-binding-regexp string) + (lambda (match) + (not (member (match:substring match 2) '("nil" "()")))))) (let ((return (let ((file (if (file-port? port) (port-filename port) #f)) @@ -283,11 +291,19 @@ (case c ;; A line comment, skip until end-of-line is found. ((#\;) - (let iterate () - (let ((cur (read-char port))) - (if (or (eof-object? cur) (char=? cur #\newline)) - (lex port) - (iterate))))) + (if (= (port-line port) 0) + (let iterate ((chars '())) + (let ((cur (read-char port))) + (if (or (eof-object? cur) (char=? cur #\newline)) + (let ((string (list->string (reverse chars)))) + (return 'set-lexical-binding-mode! + (lexical-binding-value string))) + (iterate (cons cur chars))))) + (let iterate () + (let ((cur (read-char port))) + (if (or (eof-object? cur) (char=? cur #\newline)) + (lex port) + (iterate)))))) ;; A character literal. ((#\?) (return 'character (get-character port #f))) @@ -321,7 +337,12 @@ (let ((mark (get-circular-marker port))) (return (car mark) (cdr mark)))) ((#\') - (return 'function #f))))) + (return 'function #f)) + ((#\:) + (call-with-values + (lambda () (get-symbol-or-number port)) + (lambda (type str) + (return 'symbol (make-symbol str)))))))) ;; Parentheses and other special-meaning single characters. ((#\() (return 'paren-open #f)) ((#\)) (return 'paren-close #f)) diff --git a/module/language/elisp/parser.scm b/module/language/elisp/parser.scm index df825eb4e..e83f136bb 100644 --- a/module/language/elisp/parser.scm +++ b/module/language/elisp/parser.scm @@ -201,6 +201,8 @@ (setter expr) (force-promises! expr) expr)) + ((set-lexical-binding-mode!) + (return `(%set-lexical-binding-mode ,(cdr token)))) (else (parse-error token "expected expression, got" token))))) diff --git a/module/language/elisp/runtime.scm b/module/language/elisp/runtime.scm index 0c84d102b..6f6a22074 100644 --- a/module/language/elisp/runtime.scm +++ b/module/language/elisp/runtime.scm @@ -25,11 +25,17 @@ function-slot-module elisp-bool ensure-fluid! - reference-variable - set-variable! - runtime-error - macro-error) - #:export-syntax (built-in-func built-in-macro defspecial prim)) + symbol-fluid + set-symbol-fluid! + symbol-value + set-symbol-value! + symbol-function + set-symbol-function! + symbol-bound? + symbol-fbound? + makunbound! + fmakunbound!) + #:export-syntax (defspecial prim)) ;;; This module provides runtime support for the Elisp front-end. @@ -47,22 +53,6 @@ (define function-slot-module '(language elisp runtime function-slot)) -;;; Report an error during macro compilation, that means some special -;;; compilation (syntax) error; or report a simple runtime-error from a -;;; built-in function. - -(define (macro-error msg . args) - (apply error msg args)) - -(define runtime-error macro-error) - -;;; Convert a scheme boolean to Elisp. - -(define (elisp-bool b) - (if b - t-value - nil-value)) - ;;; Routines for access to elisp dynamically bound symbols. This is ;;; used for runtime access using functions like symbol-value or set, ;;; where the symbol accessed might not be known at compile-time. These @@ -77,39 +67,68 @@ (module-define! resolved sym fluid) (module-export! resolved `(,sym)))))) -(define (reference-variable module sym) - (let ((resolved (resolve-module module))) - (cond - ((equal? module function-slot-module) - (module-ref resolved sym)) - (else - (ensure-fluid! module sym) - (fluid-ref (module-ref resolved sym)))))) +(define (symbol-fluid symbol) + (let ((module (resolve-module value-slot-module))) + (ensure-fluid! value-slot-module symbol) ;++ implicit special proclamation + (module-ref module symbol))) -(define (set-variable! module sym value) - (let ((intf (resolve-interface module)) - (resolved (resolve-module module))) - (cond - ((equal? module function-slot-module) - (cond - ((module-defined? intf sym) - (module-set! resolved sym value)) - (else - (module-define! resolved sym value) - (module-export! resolved `(,sym))))) - (else - (ensure-fluid! module sym) - (fluid-set! (module-ref resolved sym) value)))) +(define (set-symbol-fluid! symbol fluid) + (let ((module (resolve-module value-slot-module))) + (module-define! module symbol fluid) + (module-export! module (list symbol))) + fluid) + +(define (symbol-value symbol) + (fluid-ref (symbol-fluid symbol))) + +(define (set-symbol-value! symbol value) + (fluid-set! (symbol-fluid symbol) value) value) -;;; Define a predefined function or predefined macro for use in the -;;; function-slot and macro-slot modules, respectively. +(define (symbol-function symbol) + (let ((module (resolve-module function-slot-module))) + (module-ref module symbol))) + +(define (set-symbol-function! symbol value) + (let ((module (resolve-module function-slot-module))) + (module-define! module symbol value) + (module-export! module (list symbol))) + value) -(define-syntax built-in-func - (syntax-rules () - ((_ name value) - (begin - (define-public name value))))) +(define (symbol-bound? symbol) + (and + (module-bound? (resolve-interface value-slot-module) symbol) + (let ((var (module-variable (resolve-module value-slot-module) + symbol))) + (and (variable-bound? var) + (if (fluid? (variable-ref var)) + (fluid-bound? (variable-ref var)) + #t))))) + +(define (symbol-fbound? symbol) + (and + (module-bound? (resolve-interface function-slot-module) symbol) + (variable-bound? + (module-variable (resolve-module function-slot-module) + symbol)))) + +(define (makunbound! symbol) + (if (module-bound? (resolve-interface value-slot-module) symbol) + (let ((var (module-variable (resolve-module value-slot-module) + symbol))) + (if (and (variable-bound? var) (fluid? (variable-ref var))) + (fluid-unset! (variable-ref var)) + (variable-unset! var)))) + symbol) + +(define (fmakunbound! symbol) + (if (module-bound? (resolve-interface function-slot-module) symbol) + (variable-unset! (module-variable + (resolve-module function-slot-module) + symbol))) + symbol) + +;;; Define a predefined macro for use in the function-slot module. (define (make-id template-id . data) (let ((append-symbols @@ -125,30 +144,10 @@ datum)) data))))) -(define-syntax built-in-macro - (lambda (x) - (syntax-case x () - ((_ name value) - (with-syntax ((scheme-name (make-id #'name 'macro- #'name))) - #'(begin - (define-public scheme-name - (make-fluid (cons 'macro value))))))))) - (define-syntax defspecial (lambda (x) (syntax-case x () ((_ name args body ...) (with-syntax ((scheme-name (make-id #'name 'compile- #'name))) - #'(begin - (define scheme-name - (make-fluid - (cons 'special-operator - (lambda args body ...)))))))))) - -;;; Call a guile-primitive that may be rebound for elisp and thus needs -;;; absolute addressing. - -(define-syntax prim - (syntax-rules () - ((_ sym args ...) - ((@ (guile) sym) args ...)))) + #'(define scheme-name + (cons 'special-operator (lambda args body ...)))))))) diff --git a/module/language/elisp/runtime/function-slot.scm b/module/language/elisp/runtime/function-slot.scm index 896e3cece..3b10205c1 100644 --- a/module/language/elisp/runtime/function-slot.scm +++ b/module/language/elisp/runtime/function-slot.scm @@ -17,142 +17,47 @@ ;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA (define-module (language elisp runtime function-slot) - #:use-module (language elisp runtime subrs) - #:use-module ((language elisp runtime macros) - #:select - ((macro-lambda . lambda) - (macro-prog1 . prog1) - (macro-prog2 . prog2) - (macro-when . when) - (macro-unless . unless) - (macro-cond . cond) - (macro-and . and) - (macro-or . or) - (macro-dotimes . dotimes) - (macro-dolist . dolist) - (macro-catch . catch) - (macro-unwind-protect . unwind-protect) - (macro-pop . pop) - (macro-push . push))) #:use-module ((language elisp compile-tree-il) #:select ((compile-progn . progn) + (compile-eval-when-compile . eval-when-compile) (compile-if . if) (compile-defconst . defconst) (compile-defvar . defvar) (compile-setq . setq) (compile-let . let) - (compile-lexical-let . lexical-let) (compile-flet . flet) + (compile-labels . labels) (compile-let* . let*) - (compile-lexical-let* . lexical-let*) - (compile-flet* . flet*) - (compile-with-always-lexical . with-always-lexical) (compile-guile-ref . guile-ref) (compile-guile-primitive . guile-primitive) - (compile-while . while) (compile-function . function) (compile-defun . defun) (compile-defmacro . defmacro) (#{compile-`}# . #{`}#) - (compile-quote . quote))) + (compile-quote . quote) + (compile-%funcall . %funcall) + (compile-%set-lexical-binding-mode + . %set-lexical-binding-mode))) #:duplicates (last) ;; special operators #:re-export (progn + eval-when-compile if defconst defvar setq let - lexical-let flet + labels let* - lexical-let* - flet* - with-always-lexical guile-ref guile-primitive - while function defun defmacro #{`}# - quote) - ;; macros - #:re-export (lambda - prog1 - prog2 - when - unless - cond - and - or - dotimes - dolist - catch - unwind-protect - pop - push) - ;; functions - #:re-export (eq - equal - floatp - integerp - numberp - wholenump - zerop - = - /= - < - <= - > - >= - max - min - abs - float - 1+ - 1- - + - - - * - % - ffloor - fceiling - ftruncate - fround - consp - atomp - listp - nlistp - null - car - cdr - car-safe - cdr-safe - nth - nthcdr - length - cons - list - make-list - append - reverse - copy-tree - number-sequence - setcar - setcdr - symbol-value - symbol-function - set - fset - makunbound - fmakunbound - boundp - fboundp - apply - funcall - throw - not - eval - load)) + quote + %funcall + %set-lexical-binding-mode) + #:pure) diff --git a/module/language/elisp/runtime/macros.scm b/module/language/elisp/runtime/macros.scm deleted file mode 100644 index b28706781..000000000 --- a/module/language/elisp/runtime/macros.scm +++ /dev/null @@ -1,208 +0,0 @@ -;;; Guile Emacs Lisp - -;;; Copyright (C) 2009, 2010 Free Software Foundation, Inc. -;;; -;;; This library is free software; you can redistribute it and/or -;;; modify it under the terms of the GNU Lesser General Public -;;; License as published by the Free Software Foundation; either -;;; version 3 of the License, or (at your option) any later version. -;;; -;;; This library is distributed in the hope that it will be useful, -;;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -;;; Lesser General Public License for more details. -;;; -;;; You should have received a copy of the GNU Lesser General Public -;;; License along with this library; if not, write to the Free Software -;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - -;;; Code: - -(define-module (language elisp runtime macros) - #:use-module (language elisp runtime)) - -;;; This module contains the macro definitions of elisp symbols. In -;;; contrast to the other runtime modules, those are used directly -;;; during compilation, of course, so not really in runtime. But I -;;; think it fits well to the others here. - -(built-in-macro lambda - (lambda cdr - `(function (lambda ,@cdr)))) - -;;; The prog1 and prog2 constructs can easily be defined as macros using -;;; progn and some lexical-let's to save the intermediate value to -;;; return at the end. - -(built-in-macro prog1 - (lambda (form1 . rest) - (let ((temp (gensym))) - `(lexical-let ((,temp ,form1)) - ,@rest - ,temp)))) - -(built-in-macro prog2 - (lambda (form1 form2 . rest) - `(progn ,form1 (prog1 ,form2 ,@rest)))) - -;;; Define the conditionals when and unless as macros. - -(built-in-macro when - (lambda (condition . thens) - `(if ,condition (progn ,@thens) nil))) - -(built-in-macro unless - (lambda (condition . elses) - `(if ,condition nil (progn ,@elses)))) - -;;; Impement the cond form as nested if's. A special case is a -;;; (condition) subform, in which case we need to return the condition -;;; itself if it is true and thus save it in a local variable before -;;; testing it. - -(built-in-macro cond - (lambda (. clauses) - (let iterate ((tail clauses)) - (if (null? tail) - 'nil - (let ((cur (car tail)) - (rest (iterate (cdr tail)))) - (prim cond - ((prim or (not (list? cur)) (null? cur)) - (macro-error "invalid clause in cond" cur)) - ((null? (cdr cur)) - (let ((var (gensym))) - `(lexical-let ((,var ,(car cur))) - (if ,var - ,var - ,rest)))) - (else - `(if ,(car cur) - (progn ,@(cdr cur)) - ,rest)))))))) - -;;; The `and' and `or' forms can also be easily defined with macros. - -(built-in-macro and - (case-lambda - (() 't) - ((x) x) - ((x . args) - (let iterate ((x x) (tail args)) - (if (null? tail) - x - `(if ,x - ,(iterate (car tail) (cdr tail)) - nil)))))) - -(built-in-macro or - (case-lambda - (() 'nil) - ((x) x) - ((x . args) - (let iterate ((x x) (tail args)) - (if (null? tail) - x - (let ((var (gensym))) - `(lexical-let ((,var ,x)) - (if ,var - ,var - ,(iterate (car tail) (cdr tail)))))))))) - -;;; Define the dotimes and dolist iteration macros. - -(built-in-macro dotimes - (lambda (args . body) - (if (prim or - (not (list? args)) - (< (length args) 2) - (> (length args) 3)) - (macro-error "invalid dotimes arguments" args) - (let ((var (car args)) - (count (cadr args))) - (if (not (symbol? var)) - (macro-error "expected symbol as dotimes variable")) - `(let ((,var 0)) - (while ((guile-primitive <) ,var ,count) - ,@body - (setq ,var ((guile-primitive 1+) ,var))) - ,@(if (= (length args) 3) - (list (caddr args)) - '())))))) - -(built-in-macro dolist - (lambda (args . body) - (if (prim or - (not (list? args)) - (< (length args) 2) - (> (length args) 3)) - (macro-error "invalid dolist arguments" args) - (let ((var (car args)) - (iter-list (cadr args)) - (tailvar (gensym))) - (if (not (symbol? var)) - (macro-error "expected symbol as dolist variable") - `(let (,var) - (lexical-let ((,tailvar ,iter-list)) - (while ((guile-primitive not) - ((guile-primitive null?) ,tailvar)) - (setq ,var ((guile-primitive car) ,tailvar)) - ,@body - (setq ,tailvar ((guile-primitive cdr) ,tailvar))) - ,@(if (= (length args) 3) - (list (caddr args)) - '())))))))) - -;;; Exception handling. unwind-protect and catch are implemented as -;;; macros (throw is a built-in function). - -;;; catch and throw can mainly be implemented directly using Guile's -;;; primitives for exceptions, the only difficulty is that the keys used -;;; within Guile must be symbols, while elisp allows any value and -;;; checks for matches using eq (eq?). We handle this by using always #t -;;; as key for the Guile primitives and check for matches inside the -;;; handler; if the elisp keys are not eq?, we rethrow the exception. - -(built-in-macro catch - (lambda (tag . body) - (if (null? body) - (macro-error "catch with empty body")) - (let ((tagsym (gensym))) - `(lexical-let ((,tagsym ,tag)) - ((guile-primitive catch) - #t - (lambda () ,@body) - ,(let* ((dummy-key (gensym)) - (elisp-key (gensym)) - (value (gensym)) - (arglist `(,dummy-key ,elisp-key ,value))) - `(with-always-lexical - ,arglist - (lambda ,arglist - (if (eq ,elisp-key ,tagsym) - ,value - ((guile-primitive throw) ,dummy-key ,elisp-key - ,value)))))))))) - -;;; unwind-protect is just some weaker construct as dynamic-wind, so -;;; straight-forward to implement. - -(built-in-macro unwind-protect - (lambda (body . clean-ups) - (if (null? clean-ups) - (macro-error "unwind-protect without cleanup code")) - `((guile-primitive dynamic-wind) - (lambda () nil) - (lambda () ,body) - (lambda () ,@clean-ups)))) - -;;; Pop off the first element from a list or push one to it. - -(built-in-macro pop - (lambda (list-name) - `(prog1 (car ,list-name) - (setq ,list-name (cdr ,list-name))))) - -(built-in-macro push - (lambda (new-el list-name) - `(setq ,list-name (cons ,new-el ,list-name)))) diff --git a/module/language/elisp/runtime/subrs.scm b/module/language/elisp/runtime/subrs.scm deleted file mode 100644 index b03a510a1..000000000 --- a/module/language/elisp/runtime/subrs.scm +++ /dev/null @@ -1,383 +0,0 @@ -;;; Guile Emacs Lisp - -;;; Copyright (C) 2009 Free Software Foundation, Inc. -;;; -;;; This library is free software; you can redistribute it and/or modify -;;; it under the terms of the GNU Lesser General Public License as -;;; published by the Free Software Foundation; either version 3 of the -;;; License, or (at your option) any later version. -;;; -;;; This library is distributed in the hope that it will be useful, but -;;; WITHOUT ANY WARRANTY; without even the implied warranty of -;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -;;; Lesser General Public License for more details. -;;; -;;; You should have received a copy of the GNU Lesser General Public -;;; License along with this library; if not, write to the Free Software -;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA -;;; 02110-1301 USA - -;;; Code: - -(define-module (language elisp runtime subrs) - #:use-module (language elisp runtime) - #:use-module (system base compile)) - -;;; This module contains the function-slots of elisp symbols. Elisp -;;; built-in functions are implemented as predefined function bindings -;;; here. - -;;; Equivalence and equalness predicates. - -(built-in-func eq - (lambda (a b) - (elisp-bool (eq? a b)))) - -(built-in-func equal - (lambda (a b) - (elisp-bool (equal? a b)))) - -;;; Number predicates. - -(built-in-func floatp - (lambda (num) - (elisp-bool (and (real? num) - (or (inexact? num) - (prim not (integer? num))))))) - -(built-in-func integerp - (lambda (num) - (elisp-bool (and (exact? num) - (integer? num))))) - -(built-in-func numberp - (lambda (num) - (elisp-bool (real? num)))) - -(built-in-func wholenump - (lambda (num) - (elisp-bool (and (exact? num) - (integer? num) - (prim >= num 0))))) - -(built-in-func zerop - (lambda (num) - (elisp-bool (prim = num 0)))) - -;;; Number comparisons. - -(built-in-func = - (lambda (num1 num2) - (elisp-bool (prim = num1 num2)))) - -(built-in-func /= - (lambda (num1 num2) - (elisp-bool (prim not (prim = num1 num2))))) - -(built-in-func < - (lambda (num1 num2) - (elisp-bool (prim < num1 num2)))) - -(built-in-func <= - (lambda (num1 num2) - (elisp-bool (prim <= num1 num2)))) - -(built-in-func > - (lambda (num1 num2) - (elisp-bool (prim > num1 num2)))) - -(built-in-func >= - (lambda (num1 num2) - (elisp-bool (prim >= num1 num2)))) - -(built-in-func max - (lambda (. nums) - (prim apply (@ (guile) max) nums))) - -(built-in-func min - (lambda (. nums) - (prim apply (@ (guile) min) nums))) - -(built-in-func abs - (@ (guile) abs)) - -;;; Number conversion. - -(built-in-func float - (lambda (num) - (if (exact? num) - (exact->inexact num) - num))) - -;;; TODO: truncate, floor, ceiling, round. - -;;; Arithmetic functions. - -(built-in-func 1+ (@ (guile) 1+)) - -(built-in-func 1- (@ (guile) 1-)) - -(built-in-func + (@ (guile) +)) - -(built-in-func - (@ (guile) -)) - -(built-in-func * (@ (guile) *)) - -(built-in-func % (@ (guile) modulo)) - -;;; TODO: / with correct integer/real behaviour, mod (for floating-piont -;;; values). - -;;; Floating-point rounding operations. - -(built-in-func ffloor (@ (guile) floor)) - -(built-in-func fceiling (@ (guile) ceiling)) - -(built-in-func ftruncate (@ (guile) truncate)) - -(built-in-func fround (@ (guile) round)) - -;;; List predicates. - -(built-in-func consp - (lambda (el) - (elisp-bool (pair? el)))) - -(built-in-func atomp - (lambda (el) - (elisp-bool (prim not (pair? el))))) - -(built-in-func listp - (lambda (el) - (elisp-bool (or (pair? el) (null? el))))) - -(built-in-func nlistp - (lambda (el) - (elisp-bool (and (prim not (pair? el)) - (prim not (null? el)))))) - -(built-in-func null - (lambda (el) - (elisp-bool (null? el)))) - -;;; Accessing list elements. - -(built-in-func car - (lambda (el) - (if (null? el) - nil-value - (prim car el)))) - -(built-in-func cdr - (lambda (el) - (if (null? el) - nil-value - (prim cdr el)))) - -(built-in-func car-safe - (lambda (el) - (if (pair? el) - (prim car el) - nil-value))) - -(built-in-func cdr-safe - (lambda (el) - (if (pair? el) - (prim cdr el) - nil-value))) - -(built-in-func nth - (lambda (n lst) - (if (negative? n) - (prim car lst) - (let iterate ((i n) - (tail lst)) - (cond - ((null? tail) nil-value) - ((zero? i) (prim car tail)) - (else (iterate (prim 1- i) (prim cdr tail)))))))) - -(built-in-func nthcdr - (lambda (n lst) - (if (negative? n) - lst - (let iterate ((i n) - (tail lst)) - (cond - ((null? tail) nil-value) - ((zero? i) tail) - (else (iterate (prim 1- i) (prim cdr tail)))))))) - -(built-in-func length (@ (guile) length)) - -;;; Building lists. - -(built-in-func cons (@ (guile) cons)) - -(built-in-func list (@ (guile) list)) - -(built-in-func make-list - (lambda (len obj) - (prim make-list len obj))) - -(built-in-func append (@ (guile) append)) - -(built-in-func reverse (@ (guile) reverse)) - -(built-in-func copy-tree (@ (guile) copy-tree)) - -(built-in-func number-sequence - (lambda (from . rest) - (if (prim > (prim length rest) 2) - (runtime-error "too many arguments for number-sequence" - (prim cdddr rest)) - (if (null? rest) - `(,from) - (let ((to (prim car rest)) - (sep (if (or (null? (prim cdr rest)) - (eq? nil-value (prim cadr rest))) - 1 - (prim cadr rest)))) - (cond - ((or (eq? nil-value to) (prim = to from)) `(,from)) - ((and (zero? sep) (prim not (prim = from to))) - (runtime-error "infinite list in number-sequence")) - ((prim < (prim * to sep) (prim * from sep)) '()) - (else - (let iterate ((i (prim + - from - (prim * - sep - (prim quotient - (prim abs - (prim - - to - from)) - (prim abs sep))))) - (result '())) - (if (prim = i from) - (prim cons i result) - (iterate (prim - i sep) - (prim cons i result))))))))))) - -;;; Changing lists. - -(built-in-func setcar - (lambda (cell val) - (if (and (null? cell) (null? val)) - #nil - (prim set-car! cell val)) - val)) - -(built-in-func setcdr - (lambda (cell val) - (if (and (null? cell) (null? val)) - #nil - (prim set-cdr! cell val)) - val)) - -;;; Accessing symbol bindings for symbols known only at runtime. - -(built-in-func symbol-value - (lambda (sym) - (reference-variable value-slot-module sym))) - -(built-in-func symbol-function - (lambda (sym) - (reference-variable function-slot-module sym))) - -(built-in-func set - (lambda (sym value) - (set-variable! value-slot-module sym value))) - -(built-in-func fset - (lambda (sym value) - (set-variable! function-slot-module sym value))) - -(built-in-func makunbound - (lambda (sym) - (if (module-bound? (resolve-interface value-slot-module) sym) - (let ((var (module-variable (resolve-module value-slot-module) - sym))) - (if (and (variable-bound? var) (fluid? (variable-ref var))) - (fluid-unset! (variable-ref var)) - (variable-unset! var)))) - sym)) - -(built-in-func fmakunbound - (lambda (sym) - (if (module-bound? (resolve-interface function-slot-module) sym) - (let ((var (module-variable - (resolve-module function-slot-module) - sym))) - (if (and (variable-bound? var) (fluid? (variable-ref var))) - (fluid-unset! (variable-ref var)) - (variable-unset! var)))) - sym)) - -(built-in-func boundp - (lambda (sym) - (elisp-bool - (and - (module-bound? (resolve-interface value-slot-module) sym) - (let ((var (module-variable (resolve-module value-slot-module) - sym))) - (and (variable-bound? var) - (if (fluid? (variable-ref var)) - (fluid-bound? (variable-ref var)) - #t))))))) - -(built-in-func fboundp - (lambda (sym) - (elisp-bool - (and - (module-bound? (resolve-interface function-slot-module) sym) - (let* ((var (module-variable (resolve-module function-slot-module) - sym))) - (and (variable-bound? var) - (if (fluid? (variable-ref var)) - (fluid-bound? (variable-ref var)) - #t))))))) - -;;; Function calls. These must take care of special cases, like using -;;; symbols or raw lambda-lists as functions! - -(built-in-func apply - (lambda (func . args) - (let ((real-func (cond - ((symbol? func) - (reference-variable function-slot-module func)) - ((list? func) - (if (and (prim not (null? func)) - (eq? (prim car func) 'lambda)) - (compile func #:from 'elisp #:to 'value) - (runtime-error "list is not a function" - func))) - (else func)))) - (prim apply (@ (guile) apply) real-func args)))) - -(built-in-func funcall - (lambda (func . args) - (apply func args))) - -;;; Throw can be implemented as built-in function. - -(built-in-func throw - (lambda (tag value) - (prim throw 'elisp-exception tag value))) - -;;; Miscellaneous. - -(built-in-func not - (lambda (x) - (if x nil-value t-value))) - -(built-in-func eval - (lambda (form) - (compile form #:from 'elisp #:to 'value))) - -(built-in-func load - (lambda* (file) - (compile-file file #:from 'elisp #:to 'value) - #t)) diff --git a/module/language/elisp/runtime/value-slot.scm b/module/language/elisp/runtime/value-slot.scm index c6cc3b46f..c2f3666cc 100644 --- a/module/language/elisp/runtime/value-slot.scm +++ b/module/language/elisp/runtime/value-slot.scm @@ -18,6 +18,7 @@ ;;; Code: -(define-module (language elisp runtime value-slot)) +(define-module (language elisp runtime value-slot) + #:pure) ;;; This module contains the value-slots of elisp symbols. diff --git a/module/language/elisp/spec.scm b/module/language/elisp/spec.scm index 3da368093..38a32c2df 100644 --- a/module/language/elisp/spec.scm +++ b/module/language/elisp/spec.scm @@ -22,6 +22,7 @@ #:use-module (language elisp compile-tree-il) #:use-module (language elisp parser) #:use-module (system base language) + #:use-module (system base compile) #:export (elisp)) (define-language elisp @@ -29,3 +30,6 @@ #:reader (lambda (port env) (read-elisp port)) #:printer write #:compilers `((tree-il . ,compile-tree-il))) + +(compile-and-load (%search-load-path "language/elisp/boot.el") + #:from 'elisp) diff --git a/module/language/objcode/elf.scm b/module/language/objcode/elf.scm new file mode 100644 index 000000000..9654c0861 --- /dev/null +++ b/module/language/objcode/elf.scm @@ -0,0 +1,94 @@ +;;; Embedding bytecode in ELF + +;; Copyright (C) 2012 Free Software Foundation, Inc. + +;;;; This library is free software; you can redistribute it and/or +;;;; modify it under the terms of the GNU Lesser General Public +;;;; License as published by the Free Software Foundation; either +;;;; version 3 of the License, or (at your option) any later version. +;;;; +;;;; This library is distributed in the hope that it will be useful, +;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +;;;; Lesser General Public License for more details. +;;;; +;;;; You should have received a copy of the GNU Lesser General Public +;;;; License along with this library; if not, write to the Free Software +;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +;;; Code: + +;; The eval-when is because (language objcode elf) will not be loaded +;; yet when we go to compile it, but later passes of the +;; compiler need it. So we have to be sure that the module is present +;; at compile time, with all of its definitions. The easiest way to do +;; that is just to go ahead and resolve it now. +;; +(define-module (language objcode elf) + #:use-module (system vm objcode) + #:use-module (system base target) + #:use-module (rnrs bytevectors) + #:use-module (ice-9 binary-ports) + #:use-module (system vm elf) + #:export (write-objcode)) + +(define (bytecode->elf bv) + (let ((string-table (make-elf-string-table))) + (define (intern-string! string) + (call-with-values + (lambda () (elf-string-table-intern string-table string)) + (lambda (table idx) + (set! string-table table) + idx))) + (define (make-object name bv relocs . kwargs) + (let ((name-idx (intern-string! (symbol->string name)))) + (make-elf-object (apply make-elf-section + #:name name-idx + #:size (bytevector-length bv) + kwargs) + bv relocs + (list (make-elf-symbol name 0))))) + (define (make-dynamic-section word-size endianness) + (define (make-dynamic-section/32) + (let ((bv (make-bytevector 24 0))) + (bytevector-u32-set! bv 0 DT_GUILE_RTL_VERSION endianness) + (bytevector-u32-set! bv 4 #x02000000 endianness) + (bytevector-u32-set! bv 8 DT_GUILE_ENTRY endianness) + (bytevector-u32-set! bv 12 0 endianness) + (bytevector-u32-set! bv 16 DT_NULL endianness) + (bytevector-u32-set! bv 20 0 endianness) + (values bv (make-elf-reloc 'abs32/1 12 0 '.rtl-text)))) + (define (make-dynamic-section/64) + (let ((bv (make-bytevector 48 0))) + (bytevector-u64-set! bv 0 DT_GUILE_RTL_VERSION endianness) + (bytevector-u64-set! bv 8 #x02000000 endianness) + (bytevector-u64-set! bv 16 DT_GUILE_ENTRY endianness) + (bytevector-u64-set! bv 24 0 endianness) + (bytevector-u64-set! bv 32 DT_NULL endianness) + (bytevector-u64-set! bv 40 0 endianness) + (values bv (make-elf-reloc 'abs64/1 24 0 '.rtl-text)))) + (call-with-values (lambda () + (case word-size + ((4) (make-dynamic-section/32)) + ((8) (make-dynamic-section/64)) + (else (error "unexpected word size" word-size)))) + (lambda (bv reloc) + (make-object '.dynamic bv (list reloc) + #:type SHT_DYNAMIC #:flags SHF_ALLOC)))) + (define (link-string-table) + (intern-string! ".shstrtab") + (make-object '.shstrtab (link-elf-string-table string-table) '() + #:type SHT_STRTAB #:flags 0)) + (let* ((word-size (target-word-size)) + (endianness (target-endianness)) + (text (make-object '.rtl-text bv '())) + (dt (make-dynamic-section word-size endianness)) + ;; This needs to be linked last, because linking other + ;; sections adds entries to the string table. + (shstrtab (link-string-table))) + (link-elf (list text dt shstrtab) + #:endianness endianness #:word-size word-size)))) + +(define (write-objcode objcode port) + (let ((bv (objcode->bytecode objcode (target-endianness)))) + (put-bytevector port (bytecode->elf bv)))) diff --git a/module/language/objcode/spec.scm b/module/language/objcode/spec.scm index bf0649a54..16f52410a 100644 --- a/module/language/objcode/spec.scm +++ b/module/language/objcode/spec.scm @@ -22,6 +22,7 @@ #:use-module (system base language) #:use-module (system vm objcode) #:use-module (system vm program) + #:use-module (language objcode elf) #:export (objcode)) (define (objcode->value x e opts) diff --git a/module/language/scheme/decompile-tree-il.scm b/module/language/scheme/decompile-tree-il.scm index 9191b2f96..f5bb699b2 100644 --- a/module/language/scheme/decompile-tree-il.scm +++ b/module/language/scheme/decompile-tree-il.scm @@ -219,10 +219,12 @@ exp `(quote ,exp))) - ((<sequence> exps) - (build-begin (map recurse exps))) + ((<seq> head tail) + (build-begin (cons (recurse head) + (build-begin-body + (recurse tail))))) - ((<application> proc args) + ((<call> proc args) (match `(,(recurse proc) ,@(map recurse args)) ((('lambda (formals ...) body ...) args ...) (=> failure) @@ -231,6 +233,9 @@ (failure))) (e e))) + ((<primcall> name args) + `(,name ,@(map recurse args))) + ((<primitive-ref> name) name) @@ -656,7 +661,7 @@ ((<void>) (primitive 'if)) ; (if #f #f) ((<const>) (primitive 'quote)) - ((<application> proc args) + ((<call> proc args) (if (lexical-ref? proc) (let* ((gensym (lexical-ref-gensym proc)) (name (source-name gensym))) @@ -671,6 +676,7 @@ (for-each recurse args)) ((<primitive-ref> name) (primitive name)) + ((<primcall> name args) (primitive name) (for-each recurse args)) ((<lexical-ref> gensym) (lexical gensym)) ((<lexical-set> gensym exp) @@ -693,7 +699,9 @@ (primitive 'if) (recurse test) (recurse consequent) (recurse alternate)) - ((<sequence> exps) (primitive 'begin) (for-each recurse exps)) + ((<seq> head tail) + (primitive 'begin) (recurse head) (recurse tail)) + ((<lambda> body) (recurse body)) ((<lambda-case> req opt rest kw inits gensyms body alternate) diff --git a/module/language/tree-il.scm b/module/language/tree-il.scm index 1ac1809fb..a3991b61f 100644 --- a/module/language/tree-il.scm +++ b/module/language/tree-il.scm @@ -34,8 +34,9 @@ <toplevel-set> toplevel-set? make-toplevel-set toplevel-set-src toplevel-set-name toplevel-set-exp <toplevel-define> toplevel-define? make-toplevel-define toplevel-define-src toplevel-define-name toplevel-define-exp <conditional> conditional? make-conditional conditional-src conditional-test conditional-consequent conditional-alternate - <application> application? make-application application-src application-proc application-args - <sequence> sequence? make-sequence sequence-src sequence-exps + <call> call? make-call call-src call-proc call-args + <primcall> primcall? make-primcall primcall-src primcall-name primcall-args + <seq> seq? make-seq seq-src seq-head seq-tail <lambda> lambda? make-lambda lambda-src lambda-meta lambda-body <lambda-case> lambda-case? make-lambda-case lambda-case-src lambda-case-req lambda-case-opt lambda-case-rest lambda-case-kw @@ -45,13 +46,15 @@ <letrec> letrec? make-letrec letrec-src letrec-in-order? letrec-names letrec-gensyms letrec-vals letrec-body <fix> fix? make-fix fix-src fix-names fix-gensyms fix-vals fix-body <let-values> let-values? make-let-values let-values-src let-values-exp let-values-body - <dynwind> dynwind? make-dynwind dynwind-src dynwind-winder dynwind-body dynwind-unwinder + <dynwind> dynwind? make-dynwind dynwind-src dynwind-winder dynwind-pre dynwind-body dynwind-post dynwind-unwinder <dynlet> dynlet? make-dynlet dynlet-src dynlet-fluids dynlet-vals dynlet-body <dynref> dynref? make-dynref dynref-src dynref-fluid <dynset> dynset? make-dynset dynset-src dynset-fluid dynset-exp <prompt> prompt? make-prompt prompt-src prompt-tag prompt-body prompt-handler <abort> abort? make-abort abort-src abort-tag abort-args abort-tail + list->seq + parse-tree-il unparse-tree-il tree-il->scheme @@ -121,8 +124,9 @@ ;; (<toplevel-set> name exp) ;; (<toplevel-define> name exp) ;; (<conditional> test consequent alternate) - ;; (<application> proc args) - ;; (<sequence> exps) + ;; (<call> proc args) + ;; (<primcall> name args) + ;; (<seq> head tail) ;; (<lambda> meta body) ;; (<lambda-case> req opt rest kw inits gensyms body alternate) ;; (<let> names gensyms vals body) @@ -132,7 +136,7 @@ (define-type (<tree-il> #:common-slots (src) #:printer print-tree-il) (<fix> names gensyms vals body) (<let-values> exp body) - (<dynwind> winder body unwinder) + (<dynwind> winder pre body post unwinder) (<dynref> fluid) (<dynset> fluid exp) (<prompt> tag body handler) @@ -140,6 +144,14 @@ +;; A helper. +(define (list->seq loc exps) + (if (null? (cdr exps)) + (car exps) + (make-seq loc (car exps) (list->seq #f (cdr exps))))) + + + (define (location x) (and (pair? x) (let ((props (source-properties x))) @@ -152,8 +164,11 @@ ((void) (make-void loc)) - ((apply ,proc . ,args) - (make-application loc (retrans proc) (map retrans args))) + ((call ,proc . ,args) + (make-call loc (retrans proc) (map retrans args))) + + ((primcall ,name . ,args) + (make-primcall loc name (map retrans args))) ((if ,test ,consequent ,alternate) (make-conditional loc (retrans test) (retrans consequent) (retrans alternate))) @@ -212,8 +227,12 @@ ((const ,exp) (make-const loc exp)) + ((seq ,head ,tail) + (make-seq loc (retrans head) (retrans tail))) + + ;; Convenience. ((begin . ,exps) - (make-sequence loc (map retrans exps))) + (list->seq loc (map retrans exps))) ((let ,names ,gensyms ,vals ,body) (make-let loc names gensyms (map retrans vals) (retrans body))) @@ -230,8 +249,10 @@ ((let-values ,exp ,body) (make-let-values loc (retrans exp) (retrans body))) - ((dynwind ,winder ,body ,unwinder) - (make-dynwind loc (retrans winder) (retrans body) (retrans unwinder))) + ((dynwind ,winder ,pre ,body ,post ,unwinder) + (make-dynwind loc (retrans winder) (retrans pre) + (retrans body) + (retrans post) (retrans unwinder))) ((dynlet ,fluids ,vals ,body) (make-dynlet loc (map retrans fluids) (map retrans vals) (retrans body))) @@ -256,8 +277,11 @@ ((<void>) '(void)) - ((<application> proc args) - `(apply ,(unparse-tree-il proc) ,@(map unparse-tree-il args))) + ((<call> proc args) + `(call ,(unparse-tree-il proc) ,@(map unparse-tree-il args))) + + ((<primcall> name args) + `(primcall ,name ,@(map unparse-tree-il args))) ((<conditional> test consequent alternate) `(if ,(unparse-tree-il test) ,(unparse-tree-il consequent) ,(unparse-tree-il alternate))) @@ -297,9 +321,9 @@ ((<const> exp) `(const ,exp)) - ((<sequence> exps) - `(begin ,@(map unparse-tree-il exps))) - + ((<seq> head tail) + `(seq ,(unparse-tree-il head) ,(unparse-tree-il tail))) + ((<let> names gensyms vals body) `(let ,names ,gensyms ,(map unparse-tree-il vals) ,(unparse-tree-il body))) @@ -313,9 +337,10 @@ ((<let-values> exp body) `(let-values ,(unparse-tree-il exp) ,(unparse-tree-il body))) - ((<dynwind> winder body unwinder) - `(dynwind ,(unparse-tree-il winder) ,(unparse-tree-il body) - ,(unparse-tree-il unwinder))) + ((<dynwind> winder pre body post unwinder) + `(dynwind ,(unparse-tree-il winder) ,(unparse-tree-il pre) + ,(unparse-tree-il body) + ,(unparse-tree-il post) ,(unparse-tree-il unwinder))) ((<dynlet> fluids vals body) `(dynlet ,(map unparse-tree-il fluids) ,(map unparse-tree-il vals) @@ -347,7 +372,7 @@ invoked as `(PROC TREE SEED)', where TREE is the sub-tree or leaf considered and SEED is the current result, intially seeded with SEED. This is an implementation of `foldts' as described by Andy Wingo in -``Applications of fold to XML transformation''." +``Calls of fold to XML transformation''." (let loop ((tree tree) (result seed)) (if (or (null? tree) (pair? tree)) @@ -365,10 +390,12 @@ This is an implementation of `foldts' as described by Andy Wingo in (up tree (loop alternate (loop consequent (loop test (down tree result)))))) - ((<application> proc args) + ((<call> proc args) (up tree (loop (cons proc args) (down tree result)))) - ((<sequence> exps) - (up tree (loop exps (down tree result)))) + ((<primcall> name args) + (up tree (loop args (down tree result)))) + ((<seq> head tail) + (up tree (loop tail (loop head (down tree result))))) ((<lambda> body) (up tree (loop body (down tree result)))) ((<lambda-case> inits body alternate) @@ -390,10 +417,13 @@ This is an implementation of `foldts' as described by Andy Wingo in (down tree result))))) ((<let-values> exp body) (up tree (loop body (loop exp (down tree result))))) - ((<dynwind> body winder unwinder) + ((<dynwind> winder pre body post unwinder) (up tree (loop unwinder - (loop winder - (loop body (down tree result)))))) + (loop post + (loop body + (loop pre + (loop winder + (down tree result)))))))) ((<dynlet> fluids vals body) (up tree (loop body (loop vals @@ -436,11 +466,14 @@ This is an implementation of `foldts' as described by Andy Wingo in (let*-values (((seed ...) (foldts test seed ...)) ((seed ...) (foldts consequent seed ...))) (foldts alternate seed ...))) - ((<application> proc args) + ((<call> proc args) (let-values (((seed ...) (foldts proc seed ...))) (fold-values foldts args seed ...))) - ((<sequence> exps) - (fold-values foldts exps seed ...)) + ((<primcall> name args) + (fold-values foldts args seed ...)) + ((<seq> head tail) + (let-values (((seed ...) (foldts head seed ...))) + (foldts tail seed ...))) ((<lambda> body) (foldts body seed ...)) ((<lambda-case> inits body alternate) @@ -461,9 +494,11 @@ This is an implementation of `foldts' as described by Andy Wingo in ((<let-values> exp body) (let*-values (((seed ...) (foldts exp seed ...))) (foldts body seed ...))) - ((<dynwind> body winder unwinder) - (let*-values (((seed ...) (foldts body seed ...)) - ((seed ...) (foldts winder seed ...))) + ((<dynwind> winder pre body post unwinder) + (let*-values (((seed ...) (foldts winder seed ...)) + ((seed ...) (foldts pre seed ...)) + ((seed ...) (foldts body seed ...)) + ((seed ...) (foldts post seed ...))) (foldts unwinder seed ...))) ((<dynlet> fluids vals body) (let*-values (((seed ...) (fold-values foldts fluids seed ...)) @@ -489,9 +524,12 @@ This is an implementation of `foldts' as described by Andy Wingo in (define (post-order! f x) (let lp ((x x)) (record-case x - ((<application> proc args) - (set! (application-proc x) (lp proc)) - (set! (application-args x) (map lp args))) + ((<call> proc args) + (set! (call-proc x) (lp proc)) + (set! (call-args x) (map lp args))) + + ((<primcall> name args) + (set! (primcall-args x) (map lp args))) ((<conditional> test consequent alternate) (set! (conditional-test x) (lp test)) @@ -519,9 +557,10 @@ This is an implementation of `foldts' as described by Andy Wingo in (if alternate (set! (lambda-case-alternate x) (lp alternate)))) - ((<sequence> exps) - (set! (sequence-exps x) (map lp exps))) - + ((<seq> head tail) + (set! (seq-head x) (lp head)) + (set! (seq-tail x) (lp tail))) + ((<let> gensyms vals body) (set! (let-vals x) (map lp vals)) (set! (let-body x) (lp body))) @@ -538,9 +577,11 @@ This is an implementation of `foldts' as described by Andy Wingo in (set! (let-values-exp x) (lp exp)) (set! (let-values-body x) (lp body))) - ((<dynwind> body winder unwinder) - (set! (dynwind-body x) (lp body)) + ((<dynwind> winder pre body post unwinder) (set! (dynwind-winder x) (lp winder)) + (set! (dynwind-pre x) (lp pre)) + (set! (dynwind-body x) (lp body)) + (set! (dynwind-post x) (lp post)) (set! (dynwind-unwinder x) (lp unwinder))) ((<dynlet> fluids vals body) @@ -573,9 +614,12 @@ This is an implementation of `foldts' as described by Andy Wingo in (let lp ((x x)) (let ((x (or (f x) x))) (record-case x - ((<application> proc args) - (set! (application-proc x) (lp proc)) - (set! (application-args x) (map lp args))) + ((<call> proc args) + (set! (call-proc x) (lp proc)) + (set! (call-args x) (map lp args))) + + ((<primcall> name args) + (set! (primcall-args x) (map lp args))) ((<conditional> test consequent alternate) (set! (conditional-test x) (lp test)) @@ -602,9 +646,10 @@ This is an implementation of `foldts' as described by Andy Wingo in (set! (lambda-case-body x) (lp body)) (if alternate (set! (lambda-case-alternate x) (lp alternate)))) - ((<sequence> exps) - (set! (sequence-exps x) (map lp exps))) - + ((<seq> head tail) + (set! (seq-head x) (lp head)) + (set! (seq-tail x) (lp tail))) + ((<let> vals body) (set! (let-vals x) (map lp vals)) (set! (let-body x) (lp body))) @@ -621,9 +666,11 @@ This is an implementation of `foldts' as described by Andy Wingo in (set! (let-values-exp x) (lp exp)) (set! (let-values-body x) (lp body))) - ((<dynwind> body winder unwinder) - (set! (dynwind-body x) (lp body)) + ((<dynwind> winder pre body post unwinder) (set! (dynwind-winder x) (lp winder)) + (set! (dynwind-pre x) (lp pre)) + (set! (dynwind-body x) (lp body)) + (set! (dynwind-post x) (lp post)) (set! (dynwind-unwinder x) (lp unwinder))) ((<dynlet> fluids vals body) diff --git a/module/language/tree-il/analyze.scm b/module/language/tree-il/analyze.scm index badce9f77..f5890b25a 100644 --- a/module/language/tree-il/analyze.scm +++ b/module/language/tree-il/analyze.scm @@ -180,10 +180,13 @@ (analyze! x new-proc (append labels labels-in-proc) #t #f)) (define (recur x new-proc) (analyze! x new-proc '() tail? #f)) (record-case x - ((<application> proc args) + ((<call> proc args) (apply lset-union eq? (step-tail-call proc args) (map step args))) + ((<primcall> args) + (apply lset-union eq? (map step args))) + ((<conditional> test consequent alternate) (lset-union eq? (step test) (step-tail consequent) (step-tail alternate))) @@ -222,13 +225,8 @@ ((<toplevel-define> exp) (step exp)) - ((<sequence> exps) - (let lp ((exps exps) (ret '())) - (cond ((null? exps) '()) - ((null? (cdr exps)) - (lset-union eq? ret (step-tail (car exps)))) - (else - (lp (cdr exps) (lset-union eq? ret (step (car exps)))))))) + ((<seq> head tail) + (lset-union eq? (step head) (step-tail tail))) ((<lambda> body) ;; order is important here @@ -339,8 +337,10 @@ ((<let-values> exp body) (lset-union eq? (step exp) (step body))) - ((<dynwind> body winder unwinder) - (lset-union eq? (step body) (step winder) (step unwinder))) + ((<dynwind> winder pre body post unwinder) + (lset-union eq? (step winder) (step pre) + (step body) + (step post) (step unwinder))) ((<dynlet> fluids vals body) (apply lset-union eq? (step body) (map step (append fluids vals)))) @@ -367,9 +367,12 @@ (define (allocate! x proc n) (define (recur y) (allocate! y proc n)) (record-case x - ((<application> proc args) + ((<call> proc args) (apply max (recur proc) (map recur args))) + ((<primcall> args) + (apply max n (map recur args))) + ((<conditional> test consequent alternate) (max (recur test) (recur consequent) (recur alternate))) @@ -385,8 +388,9 @@ ((<toplevel-define> exp) (recur exp)) - ((<sequence> exps) - (apply max (map recur exps))) + ((<seq> head tail) + (max (recur head) + (recur tail))) ((<lambda> body) ;; allocate closure vars in order @@ -509,8 +513,10 @@ ((<let-values> exp body) (max (recur exp) (recur body))) - ((<dynwind> body winder unwinder) - (max (recur body) (recur winder) (recur unwinder))) + ((<dynwind> winder pre body post unwinder) + (max (recur winder) (recur pre) + (recur body) + (recur post) (recur unwinder))) ((<dynlet> fluids vals body) (apply max (recur body) (map recur (append fluids vals)))) @@ -866,7 +872,7 @@ accurate information is missing from a given `tree-il' element." (defs toplevel-info-defs)) ;; (VARIABLE-NAME ...) (define (goops-toplevel-definition proc args env) - ;; If application of PROC to ARGS is a GOOPS top-level definition, return + ;; If call of PROC to ARGS is a GOOPS top-level definition, return ;; the name of the variable being defined; otherwise return #f. This ;; assumes knowledge of the current implementation of `define-class' et al. (define (toplevel-define-arg args) @@ -927,7 +933,7 @@ accurate information is missing from a given `tree-il' element." (make-toplevel-info (vhash-delq name refs) (vhash-consq name #t defs))) - ((<application> proc args) + ((<call> proc args) ;; Check for a dynamic top-level definition, as is ;; done by code expanded from GOOPS macros. (let ((name (goops-toplevel-definition proc args @@ -965,12 +971,12 @@ accurate information is missing from a given `tree-il' element." (define-record-type <arity-info> (make-arity-info toplevel-calls lexical-lambdas toplevel-lambdas) arity-info? - (toplevel-calls toplevel-procedure-calls) ;; ((NAME . APPLICATION) ...) + (toplevel-calls toplevel-procedure-calls) ;; ((NAME . CALL) ...) (lexical-lambdas lexical-lambdas) ;; ((GENSYM . DEFINITION) ...) (toplevel-lambdas toplevel-lambdas)) ;; ((NAME . DEFINITION) ...) -(define (validate-arity proc application lexical?) - ;; Validate the argument count of APPLICATION, a tree-il application of +(define (validate-arity proc call lexical?) + ;; Validate the argument count of CALL, a tree-il call of ;; PROC, emitting a warning in case of argument count mismatch. (define (filter-keyword-args keywords allow-other-keys? args) @@ -1034,8 +1040,8 @@ accurate information is missing from a given `tree-il' element." (else (values #f #f)))))))) - (let ((args (application-args application)) - (src (tree-il-src application))) + (let ((args (call-args call)) + (src (tree-il-src call))) (call-with-values (lambda () (arities proc)) (lambda (name arities) (define matches? @@ -1122,7 +1128,7 @@ accurate information is missing from a given `tree-il' element." ((<fix> gensyms vals) (fold extend info gensyms vals)) - ((<application> proc args src) + ((<call> proc args src) (record-case proc ((<lambda> body) (validate-arity proc x #t) @@ -1182,9 +1188,9 @@ accurate information is missing from a given `tree-il' element." (let ((toplevel-calls (toplevel-procedure-calls result)) (toplevel-lambdas (toplevel-lambdas result))) (vlist-for-each - (lambda (name+application) - (let* ((name (car name+application)) - (application (cdr name+application)) + (lambda (name+call) + (let* ((name (car name+call)) + (call (cdr name+call)) (proc (or (and=> (vhash-assq name toplevel-lambdas) cdr) (and (module? env) @@ -1199,9 +1205,9 @@ accurate information is missing from a given `tree-il' element." (module-ref env name)))) proc))) (cond ((lambda? proc*) - (validate-arity proc* application #t)) + (validate-arity proc* call #t)) ((procedure? proc*) - (validate-arity proc* application #f))))) + (validate-arity proc* call #f))))) toplevel-calls))) (make-arity-info vlist-null vlist-null vlist-null))) @@ -1395,11 +1401,11 @@ resort, return #t when EXP refers to the global variable SPECIAL-NAME." (match x (($ <const> _ (? string? exp)) exp) - (($ <application> _ (? (cut gettext? <> env)) + (($ <call> _ (? (cut gettext? <> env)) (($ <const> _ (? string? fmt)))) ;; Gettexted literals, like `(_ "foo")'. fmt) - (($ <application> _ (? (cut ngettext? <> env)) + (($ <call> _ (? (cut ngettext? <> env)) (($ <const> _ (? string? fmt)) ($ <const> _ (? string?)) _ ..1)) ;; Plural gettextized literals, like `(N_ "singular" "plural" n)'. @@ -1490,17 +1496,17 @@ resort, return #t when EXP refers to the global variable SPECIAL-NAME." (false-if-exception (module-ref env name)))) (match x - (($ <application> src ($ <toplevel-ref> _ name) args) + (($ <call> src ($ <toplevel-ref> _ name) args) (let ((proc (resolve-toplevel name))) (if (or (and (eq? proc (@ (guile) simple-format)) (check-simple-format-args args (or src (find pair? locs)))) (eq? proc (@ (ice-9 format) format))) (check-format-args args (or src (find pair? locs)))))) - (($ <application> src ($ <module-ref> _ '(ice-9 format) 'format) args) + (($ <call> src ($ <module-ref> _ '(ice-9 format) 'format) args) (check-format-args args (or src (find pair? locs)))) - (($ <application> src ($ <module-ref> _ '(guile) - (or 'format 'simple-format)) + (($ <call> src ($ <module-ref> _ '(guile) + (or 'format 'simple-format)) args) (and (check-simple-format-args args (or src (find pair? locs))) diff --git a/module/language/tree-il/canonicalize.scm b/module/language/tree-il/canonicalize.scm index c3229cab1..2536a7155 100644 --- a/module/language/tree-il/canonicalize.scm +++ b/module/language/tree-il/canonicalize.scm @@ -36,16 +36,6 @@ (post-order! (lambda (x) (match x - (($ <sequence> src (tail)) - tail) - (($ <sequence> src exps) - (and (any sequence? exps) - (make-sequence src - (append-map (lambda (x) - (if (sequence? x) - (sequence-exps x) - (list x))) - exps)))) (($ <let> src () () () body) body) (($ <letrec> src _ () () () body) @@ -65,7 +55,7 @@ (else #f))) (define (thunk-application? x) (match x - (($ <application> _ + (($ <call> _ ($ <lambda> _ _ ($ <lambda-case> _ () #f #f #f)) ()) #t) (_ #f))) @@ -73,7 +63,7 @@ (define thunk (make-lambda #f '() (make-lambda-case #f '() #f #f #f '() '() body #f))) - (make-application #f thunk '())) + (make-call #f thunk '())) ;; This code has a nasty job to do: to ensure that either the ;; handler is escape-only, or the body is the application of a diff --git a/module/language/tree-il/compile-glil.scm b/module/language/tree-il/compile-glil.scm index a9f6df938..79f4ff9e1 100644 --- a/module/language/tree-il/compile-glil.scm +++ b/module/language/tree-il/compile-glil.scm @@ -110,11 +110,15 @@ ((list? . 1) . list?) ((symbol? . 1) . symbol?) ((vector? . 1) . vector?) + ((nil? . 1) . nil?) (list . list) (vector . vector) ((class-of . 1) . class-of) ((@slot-ref . 2) . slot-ref) ((@slot-set! . 3) . slot-set) + ((string-length . 1) . string-length) + ((string-ref . 2) . string-ref) + ((vector-length . 1) . vector-length) ((vector-ref . 2) . vector-ref) ((vector-set! . 3) . vector-set) ((variable-ref . 1) . variable-ref) @@ -268,199 +272,12 @@ (emit-code src (make-glil-const exp)))) (maybe-emit-return)) - ;; FIXME: should represent sequence as exps tail - ((<sequence> exps) - (let lp ((exps exps)) - (if (null? (cdr exps)) - (comp-tail (car exps)) - (begin - (comp-drop (car exps)) - (lp (cdr exps)))))) - - ((<application> src proc args) - ;; FIXME: need a better pattern-matcher here + ((<seq> head tail) + (comp-drop head) + (comp-tail tail)) + + ((<call> src proc args) (cond - ((and (primitive-ref? proc) - (eq? (primitive-ref-name proc) '@apply) - (>= (length args) 1)) - (let ((proc (car args)) - (args (cdr args))) - (cond - ((and (primitive-ref? proc) (eq? (primitive-ref-name proc) 'values) - (not (eq? context 'push)) (not (eq? context 'vals))) - ;; tail: (lambda () (apply values '(1 2))) - ;; drop: (lambda () (apply values '(1 2)) 3) - ;; push: (lambda () (list (apply values '(10 12)) 1)) - (case context - ((drop) (for-each comp-drop args) (maybe-emit-return)) - ((tail) - (for-each comp-push args) - (emit-code src (make-glil-call 'return/values* (length args)))))) - - (else - (case context - ((tail) - (comp-push proc) - (for-each comp-push args) - (emit-code src (make-glil-call 'tail-apply (1+ (length args))))) - ((push) - (emit-code src (make-glil-call 'new-frame 0)) - (comp-push proc) - (for-each comp-push args) - (emit-code src (make-glil-call 'apply (1+ (length args)))) - (maybe-emit-return)) - ((vals) - (comp-vals - (make-application src (make-primitive-ref #f 'apply) - (cons proc args)) - MVRA) - (maybe-emit-return)) - ((drop) - ;; Well, shit. The proc might return any number of - ;; values (including 0), since it's in a drop context, - ;; yet apply does not create a MV continuation. So we - ;; mv-call out to our trampoline instead. - (comp-drop - (make-application src (make-primitive-ref #f 'apply) - (cons proc args))) - (maybe-emit-return))))))) - - ((and (primitive-ref? proc) (eq? (primitive-ref-name proc) 'values)) - ;; tail: (lambda () (values '(1 2))) - ;; drop: (lambda () (values '(1 2)) 3) - ;; push: (lambda () (list (values '(10 12)) 1)) - ;; vals: (let-values (((a b ...) (values 1 2 ...))) ...) - (case context - ((drop) (for-each comp-drop args) (maybe-emit-return)) - ((push) - (case (length args) - ((0) - ;; FIXME: This is surely an error. We need to add a - ;; values-mismatch warning pass. - (emit-code src (make-glil-call 'new-frame 0)) - (comp-push proc) - (emit-code src (make-glil-call 'call 0)) - (maybe-emit-return)) - (else - ;; Taking advantage of unspecified order of evaluation of - ;; arguments. - (for-each comp-drop (cdr args)) - (comp-push (car args)) - (maybe-emit-return)))) - ((vals) - (for-each comp-push args) - (emit-code #f (make-glil-const (length args))) - (emit-branch src 'br MVRA)) - ((tail) - (for-each comp-push args) - (emit-code src (let ((len (length args))) - (if (= len 1) - (make-glil-call 'return 1) - (make-glil-call 'return/values len))))))) - - ((and (primitive-ref? proc) - (eq? (primitive-ref-name proc) '@call-with-values) - (= (length args) 2)) - ;; CONSUMER - ;; PRODUCER - ;; (mv-call MV) - ;; ([tail]-call 1) - ;; goto POST - ;; MV: [tail-]call/nargs - ;; POST: (maybe-drop) - (case context - ((vals) - ;; Fall back. - (comp-vals - (make-application src (make-primitive-ref #f 'call-with-values) - args) - MVRA) - (maybe-emit-return)) - (else - (let ((MV (make-label)) (POST (make-label)) - (producer (car args)) (consumer (cadr args))) - (if (not (eq? context 'tail)) - (emit-code src (make-glil-call 'new-frame 0))) - (comp-push consumer) - (emit-code src (make-glil-call 'new-frame 0)) - (comp-push producer) - (emit-code src (make-glil-mv-call 0 MV)) - (case context - ((tail) (emit-code src (make-glil-call 'tail-call 1))) - (else (emit-code src (make-glil-call 'call 1)) - (emit-branch #f 'br POST))) - (emit-label MV) - (case context - ((tail) (emit-code src (make-glil-call 'tail-call/nargs 0))) - (else (emit-code src (make-glil-call 'call/nargs 0)) - (emit-label POST) - (if (eq? context 'drop) - (emit-code #f (make-glil-call 'drop 1))) - (maybe-emit-return))))))) - - ((and (primitive-ref? proc) - (eq? (primitive-ref-name proc) '@call-with-current-continuation) - (= (length args) 1)) - (case context - ((tail) - (comp-push (car args)) - (emit-code src (make-glil-call 'tail-call/cc 1))) - ((vals) - (comp-vals - (make-application - src (make-primitive-ref #f 'call-with-current-continuation) - args) - MVRA) - (maybe-emit-return)) - ((push) - (comp-push (car args)) - (emit-code src (make-glil-call 'call/cc 1)) - (maybe-emit-return)) - ((drop) - ;; Crap. Just like `apply' in drop context. - (comp-drop - (make-application - src (make-primitive-ref #f 'call-with-current-continuation) - args)) - (maybe-emit-return)))) - - ;; A hack for variable-set, the opcode for which takes its args - ;; reversed, relative to the variable-set! function - ((and (primitive-ref? proc) - (eq? (primitive-ref-name proc) 'variable-set!) - (= (length args) 2)) - (comp-push (cadr args)) - (comp-push (car args)) - (emit-code src (make-glil-call 'variable-set 2)) - (case context - ((tail push vals) (emit-code #f (make-glil-void)))) - (maybe-emit-return)) - - ((and (primitive-ref? proc) - (or (hash-ref *primcall-ops* - (cons (primitive-ref-name proc) (length args))) - (hash-ref *primcall-ops* (primitive-ref-name proc)))) - => (lambda (op) - (for-each comp-push args) - (emit-code src (make-glil-call op (length args))) - (case (instruction-pushes op) - ((0) - (case context - ((tail push vals) (emit-code #f (make-glil-void)))) - (maybe-emit-return)) - ((1) - (case context - ((drop) (emit-code #f (make-glil-call 'drop 1)))) - (maybe-emit-return)) - ((-1) - ;; A control instruction, like return/values. Here we - ;; just have to hope that the author of the tree-il - ;; knew what they were doing. - *unspecified*) - (else - (error "bad primitive op: too many pushes" - op (instruction-pushes op)))))) - ;; call to the same lambda-case in tail position ((and (lexical-ref? proc) self-label (eq? (lexical-ref-gensym proc) self-label) @@ -542,6 +359,157 @@ (emit-branch #f 'br RA) (emit-label POST))))))))) + ((<primcall> src name args) + (pmatch (cons name args) + ((@apply ,proc . ,args) + (cond + ((and (primitive-ref? proc) (eq? (primitive-ref-name proc) 'values) + (not (eq? context 'push)) (not (eq? context 'vals))) + ;; tail: (lambda () (apply values '(1 2))) + ;; drop: (lambda () (apply values '(1 2)) 3) + ;; push: (lambda () (list (apply values '(10 12)) 1)) + (case context + ((drop) (for-each comp-drop args) (maybe-emit-return)) + ((tail) + (for-each comp-push args) + (emit-code src (make-glil-call 'return/values* (length args)))))) + + (else + (case context + ((tail) + (comp-push proc) + (for-each comp-push args) + (emit-code src (make-glil-call 'tail-apply (1+ (length args))))) + ((push) + (emit-code src (make-glil-call 'new-frame 0)) + (comp-push proc) + (for-each comp-push args) + (emit-code src (make-glil-call 'apply (1+ (length args)))) + (maybe-emit-return)) + (else + (comp-tail (make-primcall src 'apply (cons proc args)))))))) + + ((values . _) + ;; tail: (lambda () (values '(1 2))) + ;; drop: (lambda () (values '(1 2)) 3) + ;; push: (lambda () (list (values '(10 12)) 1)) + ;; vals: (let-values (((a b ...) (values 1 2 ...))) ...) + (case context + ((drop) (for-each comp-drop args) (maybe-emit-return)) + ((push) + (case (length args) + ((0) + ;; FIXME: This is surely an error. We need to add a + ;; values-mismatch warning pass. + (comp-push (make-call src (make-primitive-ref #f 'values) + '()))) + (else + ;; Taking advantage of unspecified order of evaluation of + ;; arguments. + (for-each comp-drop (cdr args)) + (comp-push (car args)) + (maybe-emit-return)))) + ((vals) + (for-each comp-push args) + (emit-code #f (make-glil-const (length args))) + (emit-branch src 'br MVRA)) + ((tail) + (for-each comp-push args) + (emit-code src (let ((len (length args))) + (if (= len 1) + (make-glil-call 'return 1) + (make-glil-call 'return/values len))))))) + + ((@call-with-values ,producer ,consumer) + ;; CONSUMER + ;; PRODUCER + ;; (mv-call MV) + ;; ([tail]-call 1) + ;; goto POST + ;; MV: [tail-]call/nargs + ;; POST: (maybe-drop) + (case context + ((vals) + ;; Fall back. + (comp-tail (make-primcall src 'call-with-values args))) + (else + (let ((MV (make-label)) (POST (make-label))) + (if (not (eq? context 'tail)) + (emit-code src (make-glil-call 'new-frame 0))) + (comp-push consumer) + (emit-code src (make-glil-call 'new-frame 0)) + (comp-push producer) + (emit-code src (make-glil-mv-call 0 MV)) + (case context + ((tail) (emit-code src (make-glil-call 'tail-call 1))) + (else (emit-code src (make-glil-call 'call 1)) + (emit-branch #f 'br POST))) + (emit-label MV) + (case context + ((tail) (emit-code src (make-glil-call 'tail-call/nargs 0))) + (else (emit-code src (make-glil-call 'call/nargs 0)) + (emit-label POST) + (if (eq? context 'drop) + (emit-code #f (make-glil-call 'drop 1))) + (maybe-emit-return))))))) + + ((@call-with-current-continuation ,proc) + (case context + ((tail) + (comp-push proc) + (emit-code src (make-glil-call 'tail-call/cc 1))) + ((vals) + (comp-vals + (make-primcall src 'call-with-current-continuation args) + MVRA) + (maybe-emit-return)) + ((push) + (comp-push proc) + (emit-code src (make-glil-call 'call/cc 1)) + (maybe-emit-return)) + ((drop) + ;; Fall back. + (comp-tail + (make-primcall src 'call-with-current-continuation args))))) + + ;; A hack for variable-set, the opcode for which takes its args + ;; reversed, relative to the variable-set! function + ((variable-set! ,var ,val) + (comp-push val) + (comp-push var) + (emit-code src (make-glil-call 'variable-set 2)) + (case context + ((tail push vals) (emit-code #f (make-glil-void)))) + (maybe-emit-return)) + + (else + (cond + ((or (hash-ref *primcall-ops* (cons name (length args))) + (hash-ref *primcall-ops* name)) + => (lambda (op) + (for-each comp-push args) + (emit-code src (make-glil-call op (length args))) + (case (instruction-pushes op) + ((0) + (case context + ((tail push vals) (emit-code #f (make-glil-void)))) + (maybe-emit-return)) + ((1) + (case context + ((drop) (emit-code #f (make-glil-call 'drop 1)))) + (maybe-emit-return)) + ((-1) + ;; A control instruction, like return/values. Here we + ;; just have to hope that the author of the tree-il + ;; knew what they were doing. + *unspecified*) + (else + (error "bad primitive op: too many pushes" + op (instruction-pushes op)))))) + (else + ;; Fall back to the normal compilation strategy. + (comp-tail (make-call src (make-primitive-ref #f name) args))))))) + ((<conditional> src test consequent alternate) ;; TEST ;; (br-if-not L1) @@ -550,54 +518,39 @@ ;; L1: alternate ;; L2: (let ((L1 (make-label)) (L2 (make-label))) - ;; need a pattern matcher (record-case test - ((<application> proc args) - (record-case proc - ((<primitive-ref> name) - (let ((len (length args))) - (cond - - ((and (eq? name 'eq?) (= len 2)) - (comp-push (car args)) - (comp-push (cadr args)) - (emit-branch src 'br-if-not-eq L1)) - - ((and (eq? name 'null?) (= len 1)) - (comp-push (car args)) - (emit-branch src 'br-if-not-null L1)) - - ((and (eq? name 'not) (= len 1)) - (let ((app (car args))) - (record-case app - ((<application> proc args) - (let ((len (length args))) - (record-case proc - ((<primitive-ref> name) - (cond - - ((and (eq? name 'eq?) (= len 2)) - (comp-push (car args)) - (comp-push (cadr args)) - (emit-branch src 'br-if-eq L1)) - - ((and (eq? name 'null?) (= len 1)) - (comp-push (car args)) - (emit-branch src 'br-if-null L1)) - - (else - (comp-push app) - (emit-branch src 'br-if L1)))) - (else - (comp-push app) - (emit-branch src 'br-if L1))))) - (else - (comp-push app) - (emit-branch src 'br-if L1))))) - - (else - (comp-push test) - (emit-branch src 'br-if-not L1))))) + ((<primcall> name args) + (pmatch (cons name args) + ((eq? ,a ,b) + (comp-push a) + (comp-push b) + (emit-branch src 'br-if-not-eq L1)) + ((null? ,x) + (comp-push x) + (emit-branch src 'br-if-not-null L1)) + ((nil? ,x) + (comp-push x) + (emit-branch src 'br-if-not-nil L1)) + ((not ,x) + (record-case x + ((<primcall> name args) + (pmatch (cons name args) + ((eq? ,a ,b) + (comp-push a) + (comp-push b) + (emit-branch src 'br-if-eq L1)) + ((null? ,x) + (comp-push x) + (emit-branch src 'br-if-null L1)) + ((nil? ,x) + (comp-push x) + (emit-branch src 'br-if-nil L1)) + (else + (comp-push x) + (emit-branch src 'br-if L1)))) + (else + (comp-push x) + (emit-branch src 'br-if L1)))) (else (comp-push test) (emit-branch src 'br-if-not L1)))) @@ -974,10 +927,34 @@ ;; to have body's return value(s) on the stack while the unwinder runs, ;; then proceed with returning or dropping or what-have-you, interacting ;; with RA and MVRA. What have you, I say. - ((<dynwind> src body winder unwinder) + ((<dynwind> src winder pre body post unwinder) + (define (thunk? x) + (and (lambda? x) + (null? (lambda-case-gensyms (lambda-body x))))) + (define (make-wrong-type-arg x) + (make-primcall src 'scm-error + (list + (make-const #f 'wrong-type-arg) + (make-const #f "dynamic-wind") + (make-const #f "Wrong type (expecting thunk): ~S") + (make-primcall #f 'list (list x)) + (make-primcall #f 'list (list x))))) + (define (emit-thunk-check x) + (comp-drop (make-conditional + src + (make-primcall src 'thunk? (list x)) + (make-void #f) + (make-wrong-type-arg x)))) + + ;; We know at this point that `winder' and `unwinder' are + ;; constant expressions and can be duplicated. + (if (not (thunk? winder)) + (emit-thunk-check winder)) (comp-push winder) + (if (not (thunk? unwinder)) + (emit-thunk-check unwinder)) (comp-push unwinder) - (comp-drop (make-application src winder '())) + (comp-drop pre) (emit-code #f (make-glil-call 'wind 2)) (case context @@ -986,14 +963,14 @@ (comp-vals body MV) ;; one value: unwind... (emit-code #f (make-glil-call 'unwind 0)) - (comp-drop (make-application src unwinder '())) + (comp-drop post) ;; ...and return the val (emit-code #f (make-glil-call 'return 1)) (emit-label MV) ;; multiple values: unwind... (emit-code #f (make-glil-call 'unwind 0)) - (comp-drop (make-application src unwinder '())) + (comp-drop post) ;; and return the values. (emit-code #f (make-glil-call 'return/nvalues 1)))) @@ -1002,7 +979,7 @@ (comp-push body) ;; and unwind, leaving the val on the stack (emit-code #f (make-glil-call 'unwind 0)) - (comp-drop (make-application src unwinder '()))) + (comp-drop post)) ((vals) (let ((MV (make-label))) @@ -1013,7 +990,7 @@ (emit-label MV) ;; multiple values: unwind... (emit-code #f (make-glil-call 'unwind 0)) - (comp-drop (make-application src unwinder '())) + (comp-drop post) ;; and goto the MVRA. (emit-branch #f 'br MVRA))) @@ -1021,7 +998,7 @@ ;; compile body, discarding values. then unwind... (comp-drop body) (emit-code #f (make-glil-call 'unwind 0)) - (comp-drop (make-application src unwinder '())) + (comp-drop post) ;; and fall through, or goto RA if there is one. (if RA (emit-branch #f 'br RA))))) diff --git a/module/language/tree-il/cse.scm b/module/language/tree-il/cse.scm index d8c7e3fc9..f8fd1cd9c 100644 --- a/module/language/tree-il/cse.scm +++ b/module/language/tree-il/cse.scm @@ -149,8 +149,7 @@ (define (boolean-valued-expression? x ctx) (match x - (($ <application> _ - ($ <primitive-ref> _ (? boolean-valued-primitive?))) #t) + (($ <primcall> _ (? boolean-valued-primitive?)) #t) (($ <const> _ (? boolean?)) #t) (_ (eq? ctx 'test)))) @@ -163,9 +162,8 @@ (($ <primitive-ref>) #t) (($ <module-ref>) #t) (($ <toplevel-ref>) #t) - (($ <application> _ - ($ <primitive-ref> _ (? singly-valued-primitive?))) #t) - (($ <application> _ ($ <primitive-ref> _ 'values) (val)) #t) + (($ <primcall> _ (? singly-valued-primitive?)) #t) + (($ <primcall> _ 'values (val)) #t) (($ <lambda>) #t) (_ (eq? ctx 'value)))) @@ -188,17 +186,13 @@ (make-const src #f)) (($ <conditional> src test consequent alternate) (make-conditional src test (negate consequent ctx) (negate alternate ctx))) - (($ <application> _ ($ <primitive-ref> _ 'not) + (($ <primcall> _ 'not ((and x (? (cut boolean-valued-expression? <> ctx))))) x) - (($ <application> src - ($ <primitive-ref> _ (and pred (? negate-primitive))) - args) - (make-application src - (make-primitive-ref #f (negate-primitive pred)) - args)) + (($ <primcall> src (and pred (? negate-primitive)) args) + (make-primcall src (negate-primitive pred) args)) (_ - (make-application #f (make-primitive-ref #f 'not) (list exp))))) + (make-primcall #f 'not (list exp))))) (define (hasher n) @@ -267,7 +261,7 @@ exp (make-const src (not (not val))))) ;; For (not FOO), try to prove FOO, then negate the result. - (($ <application> src ($ <primitive-ref> _ 'not) (exp*)) + (($ <primcall> src 'not (exp*)) (match (find-dominating-test exp* effects db) (($ <const> _ val) (log 'inferring exp (not val)) @@ -450,12 +444,19 @@ ((consumer db**) (visit consumer (concat db* db) env ctx))) (return (make-let-values src producer consumer) (concat db** db*)))) - (($ <dynwind> src winder body unwinder) - (let*-values (((pre db*) (visit winder db env 'value)) - ((body db**) (visit body (concat db* db) env ctx)) - ((post db***) (visit unwinder db env 'value))) - (return (make-dynwind src pre body post) - (concat db* (concat db** db***))))) + (($ <dynwind> src winder pre body post unwinder) + (let*-values (((winder db*) (visit winder db env 'value)) + ((db**) db*) + ((unwinder db*) (visit unwinder db env 'value)) + ((db**) (concat db* db**)) + ((pre db*) (visit pre (concat db** db) env 'effect)) + ((db**) (concat db* db**)) + ((body db*) (visit body (concat db** db) env ctx)) + ((db**) (concat db* db**)) + ((post db*) (visit post (concat db** db) env 'effect)) + ((db**) (concat db* db**))) + (return (make-dynwind src winder pre body post unwinder) + db**))) (($ <dynlet> src fluids vals body) (let*-values (((fluids db*) (parallel-visit fluids db env 'value)) ((vals db**) (parallel-visit vals db env 'value)) @@ -504,7 +505,7 @@ ;; (if FOO A A) => (begin FOO A) (($ <conditional> src _ ($ <const> _ a) ($ <const> _ (? (cut equal? a <>)))) - (visit (make-sequence #f (list test (make-const #f a))) + (visit (make-seq #f test (make-const #f a)) db env ctx)) ;; (if FOO #t #f) => FOO for boolean-valued FOO. (($ <conditional> src @@ -529,10 +530,13 @@ (c (return c (intersection (concat db++ db+) (concat db-- db-))))))) - (($ <application> src proc args) + (($ <primcall> src primitive args) + (let*-values (((args db*) (parallel-visit args db env 'value))) + (return (make-primcall src primitive args) db*))) + (($ <call> src proc args) (let*-values (((proc db*) (visit proc db env 'value)) ((args db**) (parallel-visit args db env 'value))) - (return (make-application src proc args) + (return (make-call src proc args) (concat db** db*)))) (($ <lambda> src meta body) (let*-values (((body _) (visit body (control-flow-boundary db) @@ -547,24 +551,15 @@ (values #f #f)))) (return (make-lambda-case src req opt rest kw inits gensyms body alt) (if alt vlist-null db*)))) - (($ <sequence> src exps) - (let lp ((in exps) (out '()) (db* vlist-null)) - (match in - ((last) - (let*-values (((last db**) (visit last (concat db* db) env ctx))) - (if (null? out) - (return last (concat db** db*)) - (return (make-sequence src (reverse (cons last out))) - (concat db** db*))))) - ((head . rest) - (let*-values (((head db**) (visit head (concat db* db) env 'effect))) - (cond - ((sequence? head) - (lp (append (sequence-exps head) rest) out db*)) - ((void? head) - (lp rest out db*)) - (else - (lp rest (cons head out) (concat db** db*))))))))) + (($ <seq> src head tail) + (let*-values (((head db*) (visit head db env 'effect))) + (cond + ((void? head) + (visit tail db env ctx)) + (else + (let*-values (((tail db**) (visit tail (concat db* db) env ctx))) + (values (make-seq src head tail) + (concat db** db*))))))) (($ <prompt> src tag body handler) (let*-values (((tag db*) (visit tag db env 'value)) ((body _) (visit body (concat db* db) env ctx)) diff --git a/module/language/tree-il/debug.scm b/module/language/tree-il/debug.scm index 78f132416..a32fc4153 100644 --- a/module/language/tree-il/debug.scm +++ b/module/language/tree-il/debug.scm @@ -215,9 +215,11 @@ (for-each (cut visit <> env) fluids) (for-each (cut visit <> env) vals) (visit body env)))) - (($ <dynwind> src winder body unwinder) + (($ <dynwind> src winder pre body post unwinder) (visit winder env) + (visit pre env) (visit body env) + (visit post env) (visit unwinder env)) (($ <dynref> src fluid) (visit fluid env)) @@ -228,21 +230,24 @@ (visit condition env) (visit subsequent env) (visit alternate env)) - (($ <application> src proc args) + (($ <primcall> src name args) (cond + ((not (symbol? name)) + (error "expected symbolic operator" exp)) ((not (list? args)) (error "expected list of args" args)) (else - (visit proc env) (for-each (cut visit <> env) args)))) - (($ <sequence> src exps) + (($ <call> src proc args) (cond - ((not (list? exps)) - (error "expected list of exps" exp)) - ((null? exps) - (error "expected more than one exp" exp)) + ((not (list? args)) + (error "expected list of args" args)) (else - (for-each (cut visit <> env) exps)))) + (visit proc env) + (for-each (cut visit <> env) args)))) + (($ <seq> src head tail) + (visit head env) + (visit tail env)) (($ <prompt> src tag body handler) (visit tag env) (visit body env) diff --git a/module/language/tree-il/effects.scm b/module/language/tree-il/effects.scm index 4610f7f8f..8b380da27 100644 --- a/module/language/tree-il/effects.scm +++ b/module/language/tree-il/effects.scm @@ -211,9 +211,11 @@ of an expression." (logior (compute-effects producer) (compute-effects consumer) (cause &type-check))) - (($ <dynwind> _ winder body unwinder) + (($ <dynwind> _ winder pre body post unwinder) (logior (compute-effects winder) + (compute-effects pre) (compute-effects body) + (compute-effects post) (compute-effects unwinder))) (($ <dynlet> _ fluids vals body) (logior (accumulate-effects fluids) @@ -259,43 +261,37 @@ of an expression." &definite-bailout)))) ;; Zero values. - (($ <application> _ ($ <primitive-ref> _ 'values) ()) + (($ <primcall> _ 'values ()) (cause &zero-values)) ;; Effect-free primitives. - (($ <application> _ - ($ <primitive-ref> _ (or 'values 'eq? 'eqv? 'equal?)) - args) + (($ <primcall> _ (or 'values 'eq? 'eqv? 'equal?) args) (accumulate-effects args)) - (($ <application> _ - ($ <primitive-ref> _ (or 'not 'pair? 'null? 'list? 'symbol? - 'vector? 'struct? 'string? 'number? - 'char?)) + (($ <primcall> _ (or 'not 'pair? 'null? 'list? 'symbol? + 'vector? 'struct? 'string? 'number? + 'char?) (arg)) (compute-effects arg)) ;; Primitives that allocate memory. - (($ <application> _ ($ <primitive-ref> _ 'cons) (x y)) + (($ <primcall> _ 'cons (x y)) (logior (compute-effects x) (compute-effects y) &allocation)) - (($ <application> _ ($ <primitive-ref> _ (or 'list 'vector)) args) + (($ <primcall> _ (or 'list 'vector) args) (logior (accumulate-effects args) &allocation)) - (($ <application> _ ($ <primitive-ref> _ 'make-prompt-tag) ()) + (($ <primcall> _ 'make-prompt-tag ()) &allocation) - (($ <application> _ ($ <primitive-ref> _ 'make-prompt-tag) (arg)) + (($ <primcall> _ 'make-prompt-tag (arg)) (logior (compute-effects arg) &allocation)) ;; Primitives that are normally effect-free, but which might ;; cause type checks, allocate memory, or access mutable ;; memory. FIXME: expand, to be more precise. - (($ <application> _ - ($ <primitive-ref> _ (and name - (? effect-free-primitive?))) - args) + (($ <primcall> _ (and name (? effect-free-primitive?)) args) (logior (accumulate-effects args) (cause &type-check) (if (constructor-primitive? name) @@ -305,7 +301,7 @@ of an expression." &no-effects)))) ;; Lambda applications might throw wrong-number-of-args. - (($ <application> _ ($ <lambda> _ _ body) args) + (($ <call> _ ($ <lambda> _ _ body) args) (logior (accumulate-effects args) (match body (($ <lambda-case> _ req #f #f #f () syms body #f) @@ -318,25 +314,27 @@ of an expression." (cause &type-check)))))) ;; Bailout primitives. - (($ <application> src ($ <primitive-ref> _ (? bailout-primitive? name)) - args) + (($ <primcall> _ (? bailout-primitive? name) args) (logior (accumulate-effects args) (cause &definite-bailout) (cause &possible-bailout))) ;; A call to a lexically bound procedure, perhaps labels ;; allocated. - (($ <application> _ (and proc ($ <lexical-ref> _ _ sym)) args) + (($ <call> _ (and proc ($ <lexical-ref> _ _ sym)) args) (cond ((lookup sym) => (lambda (proc) - (compute-effects (make-application #f proc args)))) + (compute-effects (make-call #f proc args)))) (else (logior &all-effects-but-bailout (cause &all-effects-but-bailout))))) ;; A call to an unknown procedure can do anything. - (($ <application> _ proc args) + (($ <primcall> _ name args) + (logior &all-effects-but-bailout + (cause &all-effects-but-bailout))) + (($ <call> _ proc args) (logior &all-effects-but-bailout (cause &all-effects-but-bailout))) @@ -351,16 +349,13 @@ of an expression." (compute-effects body) (if alt (compute-effects alt) &no-effects))) - (($ <sequence> _ exps) - (let lp ((exps exps) (effects &no-effects)) - (match exps - ((tail) - (logior (compute-effects tail) - ;; Returning zero values to a for-effect continuation is - ;; not observable. - (exclude-effects effects (cause &zero-values)))) - ((head . tail) - (lp tail (logior (compute-effects head) effects)))))) + (($ <seq> _ head tail) + (logior + ;; Returning zero values to a for-effect continuation is + ;; not observable. + (exclude-effects (compute-effects head) + (cause &zero-values)) + (compute-effects tail))) (($ <prompt> _ tag body handler) (logior (compute-effects tag) diff --git a/module/language/tree-il/fix-letrec.scm b/module/language/tree-il/fix-letrec.scm index 60c87e389..b5722fe09 100644 --- a/module/language/tree-il/fix-letrec.scm +++ b/module/language/tree-il/fix-letrec.scm @@ -41,12 +41,11 @@ (and (simple-expression? test bound-vars simple-primcall?) (simple-expression? consequent bound-vars simple-primcall?) (simple-expression? alternate bound-vars simple-primcall?))) - ((<sequence> exps) - (and-map (lambda (x) (simple-expression? x bound-vars simple-primcall?)) - exps)) - ((<application> proc args) - (and (primitive-ref? proc) - (simple-primcall? x) + ((<seq> head tail) + (and (simple-expression? head bound-vars simple-primcall?) + (simple-expression? tail bound-vars simple-primcall?))) + ((<primcall> name args) + (and (simple-primcall? x) (and-map (lambda (x) (simple-expression? x bound-vars simple-primcall?)) args))) @@ -191,19 +190,25 @@ '()))) (values unref simple lambda* complex))) -(define (make-sequence* src exps) - (let lp ((in exps) (out '())) - (if (null? (cdr in)) - (if (null? out) - (car in) - (make-sequence src (reverse (cons (car in) out)))) - (let ((head (car in))) - (record-case head - ((<lambda>) (lp (cdr in) out)) - ((<const>) (lp (cdr in) out)) - ((<lexical-ref>) (lp (cdr in) out)) - ((<void>) (lp (cdr in) out)) - (else (lp (cdr in) (cons head out)))))))) +(define (make-seq* src head tail) + (record-case head + ((<lambda>) tail) + ((<const>) tail) + ((<lexical-ref>) tail) + ((<void>) tail) + (else (make-seq src head tail)))) + +(define (list->seq* loc exps) + (if (null? (cdr exps)) + (car exps) + (let lp ((exps (cdr exps)) (effects (list (car exps)))) + (if (null? (cdr exps)) + (make-seq* loc + (fold (lambda (exp tail) (make-seq* #f exp tail)) + (car effects) + (cdr effects)) + (car exps)) + (lp (cdr exps) (cons (car exps) effects)))))) (define (fix-letrec! x) (let-values (((unref simple lambda* complex) (partition-vars x))) @@ -215,7 +220,7 @@ ;; expression, called for effect. ((<lexical-set> gensym exp) (if (memq gensym unref) - (make-sequence* #f (list exp (make-void #f))) + (make-seq* #f exp (make-void #f)) x)) ((<letrec> src in-order? names gensyms vals body) @@ -243,7 +248,7 @@ ;; Bind lambdas using the fixpoint operator. (make-fix src (map cadr l) (map car l) (map caddr l) - (make-sequence* + (list->seq* src (append ;; The right-hand-sides of the unreferenced @@ -270,7 +275,7 @@ (let ((tmps (map (lambda (x) (gensym)) c))) (make-let #f (map cadr c) tmps (map caddr c) - (make-sequence + (list->seq #f (map (lambda (x tmp) (make-lexical-set @@ -287,7 +292,7 @@ (let ((u (lookup unref)) (l (lookup lambda*)) (c (lookup complex))) - (make-sequence* + (list->seq* src (append ;; unreferenced bindings, called for effect. diff --git a/module/language/tree-il/peval.scm b/module/language/tree-il/peval.scm index da3f4a82c..2d2c30ba6 100644 --- a/module/language/tree-il/peval.scm +++ b/module/language/tree-il/peval.scm @@ -109,9 +109,8 @@ (($ <primitive-ref>) #t) (($ <module-ref>) #t) (($ <toplevel-ref>) #t) - (($ <application> _ - ($ <primitive-ref> _ (? singly-valued-primitive?))) #t) - (($ <application> _ ($ <primitive-ref> _ 'values) (val)) #t) + (($ <primcall> _ (? singly-valued-primitive?)) #t) + (($ <primcall> _ 'values (val)) #t) (($ <lambda>) #t) (else #f))) @@ -119,9 +118,7 @@ "Discard all but the first value of X." (if (singly-valued-expression? x) x - (make-application (tree-il-src x) - (make-primitive-ref #f 'values) - (list x)))) + (make-primcall (tree-il-src x) 'values (list x)))) ;; Peval will do a one-pass analysis on the source program to determine ;; the set of assigned lexicals, and to identify unreferenced and @@ -328,7 +325,7 @@ (%set-operand-residual-value! op (match val - (($ <application> src ($ <primitive-ref> _ 'values) (first)) + (($ <primcall> src 'values (first)) ;; The continuation of a residualized binding does not need the ;; introduced `values' node, so undo the effects of truncation. first) @@ -401,18 +398,15 @@ top-level bindings from ENV and return the resulting expression." (define local-toplevel-env ;; The top-level environment of the module being compiled. - (match exp - (($ <toplevel-define> _ name) - (vhash-consq name #t env)) - (($ <sequence> _ exps) - (fold (lambda (x r) - (match x - (($ <toplevel-define> _ name) - (vhash-consq name #t r)) - (_ r))) - env - exps)) - (_ env))) + (let () + (define (env-folder x env) + (match x + (($ <toplevel-define> _ name) + (vhash-consq name #t env)) + (($ <seq> _ head tail) + (env-folder tail (env-folder head env))) + (_ env))) + (env-folder exp vlist-null))) (define (local-toplevel? name) (vhash-assq name local-toplevel-env)) @@ -492,15 +486,13 @@ top-level bindings from ENV and return the resulting expression." (values #t results)))) (lambda _ (values #f '())))) - (define (make-values src values) (match values ((single) single) ; 1 value ((_ ...) ; 0, or 2 or more values - (make-application src (make-primitive-ref src 'values) - values)))) + (make-primcall src 'values values)))) (define (residualize-call) - (make-application src (make-primitive-ref #f name) args)) + (make-primcall src name args)) (cond ((every const? args) (let-values (((success? values) @@ -540,21 +532,21 @@ top-level bindings from ENV and return the resulting expression." ($ <toplevel-define>) ; the future ($ <module-set>) ; ($ <dynset>) ; - ($ <application> src - ($ <primitive-ref> _ (? singly-valued-primitive?)))) + ($ <primcall> src (? singly-valued-primitive?))) (and (<= nmin 1) (or (not nmax) (>= nmax 1)) - (make-application src (make-lambda #f '() consumer) (list exp)))) + (make-call src (make-lambda #f '() consumer) (list exp)))) ;; Statically-known number of values. - (($ <application> src ($ <primitive-ref> _ 'values) vals) + (($ <primcall> src 'values vals) (and (<= nmin (length vals)) (or (not nmax) (>= nmax (length vals))) - (make-application src (make-lambda #f '() consumer) vals))) + (make-call src (make-lambda #f '() consumer) vals))) ;; Not going to copy code into both branches. (($ <conditional>) #f) ;; Bail on other applications. - (($ <application>) #f) + (($ <call>) #f) + (($ <primcall>) #f) ;; Bail on prompt and abort. (($ <prompt>) #f) @@ -580,20 +572,17 @@ top-level bindings from ENV and return the resulting expression." (make-let-values src exp (make-lambda-case src2 req opt rest kw inits gensyms body #f))))) - (($ <dynwind> src winder body unwinder) + (($ <dynwind> src winder pre body post unwinder) (let ((body (loop body))) (and body - (make-dynwind src winder body unwinder)))) + (make-dynwind src winder pre body post unwinder)))) (($ <dynlet> src fluids vals body) (let ((body (loop body))) (and body (make-dynlet src fluids vals body)))) - (($ <sequence> src exps) - (match exps - ((head ... tail) - (let ((tail (loop tail))) - (and tail - (make-sequence src (append head (list tail))))))))))) + (($ <seq> src head tail) + (let ((tail (loop tail))) + (and tail (make-seq src head tail))))))) (define compute-effects (make-effects-analyzer assigned-lexical?)) @@ -640,7 +629,7 @@ top-level bindings from ENV and return the resulting expression." (if (null? effects) body (let ((effect-vals (map operand-residual-value effects))) - (make-sequence #f (reverse (cons body effect-vals))))))) + (list->seq #f (reverse (cons body effect-vals))))))) (if (null? values) body (let ((values (reverse values))) @@ -875,16 +864,15 @@ top-level bindings from ENV and return the resulting expression." (let ((exp (for-effect exp))) (if (void? exp) exp - (make-sequence src (list exp (make-void #f))))) + (make-seq src exp (make-void #f)))) (begin (record-operand-use op) (make-lexical-set src name (operand-sym op) (for-value exp)))))) (($ <let> src (names ... rest) (gensyms ... rest-sym) - (vals ... ($ <application> _ ($ <primitive-ref> _ 'list) rest-args)) - ($ <application> asrc - ($ <primitive-ref> _ (or 'apply '@apply)) + (vals ... ($ <primcall> _ 'list rest-args)) + ($ <primcall> asrc (or 'apply '@apply) (proc args ... ($ <lexical-ref> _ (? (cut eq? <> rest)) @@ -898,7 +886,7 @@ top-level bindings from ENV and return the resulting expression." (append names tmps) (append gensyms tmp-syms) (append vals rest-args) - (make-application + (make-call asrc proc (append args @@ -940,14 +928,14 @@ top-level bindings from ENV and return the resulting expression." (body (loop body env counter ctx))) (cond ((const? body) - (for-tail (make-sequence src (append vals (list body))))) + (for-tail (list->seq src (append vals (list body))))) ((and (lexical-ref? body) (memq (lexical-ref-gensym body) new)) (let ((sym (lexical-ref-gensym body)) (pairs (map cons new vals))) ;; (let ((x foo) (y bar) ...) x) => (begin bar ... foo) (for-tail - (make-sequence + (list->seq src (append (map cdr (alist-delete sym pairs eq?)) (list (assq-ref pairs sym))))))) @@ -1008,40 +996,10 @@ top-level bindings from ENV and return the resulting expression." (else #f)))) (_ #f)) (make-let-values lv-src producer (for-tail consumer))))) - (($ <dynwind> src winder body unwinder) - (let ((pre (for-value winder)) - (body (for-tail body)) - (post (for-value unwinder))) - (cond - ((not (constant-expression? pre)) - (cond - ((not (constant-expression? post)) - (let ((pre-sym (gensym "pre-")) (post-sym (gensym "post-"))) - (record-new-temporary! 'pre pre-sym 1) - (record-new-temporary! 'post post-sym 1) - (make-let src '(pre post) (list pre-sym post-sym) (list pre post) - (make-dynwind src - (make-lexical-ref #f 'pre pre-sym) - body - (make-lexical-ref #f 'post post-sym))))) - (else - (let ((pre-sym (gensym "pre-"))) - (record-new-temporary! 'pre pre-sym 1) - (make-let src '(pre) (list pre-sym) (list pre) - (make-dynwind src - (make-lexical-ref #f 'pre pre-sym) - body - post)))))) - ((not (constant-expression? post)) - (let ((post-sym (gensym "post-"))) - (record-new-temporary! 'post post-sym 1) - (make-let src '(post) (list post-sym) (list post) - (make-dynwind src - pre - body - (make-lexical-ref #f 'post post-sym))))) - (else - (make-dynwind src pre body post))))) + (($ <dynwind> src winder pre body post unwinder) + (make-dynwind src (for-value winder) (for-effect pre) + (for-tail body) + (for-effect post) (for-value unwinder))) (($ <dynlet> src fluids vals body) (make-dynlet src (map for-value fluids) (map for-value vals) (for-tail body))) @@ -1050,12 +1008,7 @@ top-level bindings from ENV and return the resulting expression." (($ <dynset> src fluid exp) (make-dynset src (for-value fluid) (for-value exp))) (($ <toplevel-ref> src (? effect-free-primitive? name)) - (if (local-toplevel? name) - exp - (let ((exp (resolve-primitives! exp cenv))) - (if (primitive-ref? exp) - (for-tail exp) - exp)))) + exp) (($ <toplevel-ref>) ;; todo: open private local bindings. exp) @@ -1084,7 +1037,8 @@ top-level bindings from ENV and return the resulting expression." (($ <conditional> src condition subsequent alternate) (define (call-with-failure-thunk exp proc) (match exp - (($ <application> _ _ ()) (proc exp)) + (($ <call> _ _ ()) (proc exp)) + (($ <primcall> _ _ ()) (proc exp)) (($ <const>) (proc exp)) (($ <void>) (proc exp)) (($ <lexical-ref>) (proc exp)) @@ -1097,13 +1051,12 @@ top-level bindings from ENV and return the resulting expression." (make-lambda #f '() (make-lambda-case #f '() #f #f #f '() '() exp #f))) - (proc (make-application #f (make-lexical-ref #f 'failure t) - '()))))))) + (proc (make-call #f (make-lexical-ref #f 'failure t) + '()))))))) (define (simplify-conditional c) (match c ;; Swap the arms of (if (not FOO) A B), to simplify. - (($ <conditional> src - ($ <application> _ ($ <primitive-ref> _ 'not) (pred)) + (($ <conditional> src ($ <primcall> _ 'not (pred)) subsequent alternate) (simplify-conditional (make-conditional src pred alternate subsequent))) @@ -1155,17 +1108,59 @@ top-level bindings from ENV and return the resulting expression." (simplify-conditional (make-conditional src c (for-tail subsequent) (for-tail alternate)))))) - (($ <application> src - ($ <primitive-ref> _ '@call-with-values) + (($ <primcall> src '@call-with-values (producer ($ <lambda> _ _ (and consumer ;; No optional or kwargs. ($ <lambda-case> _ req #f rest #f () gensyms body #f))))) - (for-tail (make-let-values src (make-application src producer '()) + (for-tail (make-let-values src (make-call src producer '()) consumer))) - (($ <application> src ($ <primitive-ref> _ 'values) exps) + (($ <primcall> src 'dynamic-wind (w thunk u)) + (for-tail + (cond + ((not (constant-expression? w)) + (cond + ((not (constant-expression? u)) + (let ((w-sym (gensym "w ")) (u-sym (gensym "u "))) + (record-new-temporary! 'w w-sym 2) + (record-new-temporary! 'u u-sym 2) + (make-let src '(w u) (list w-sym u-sym) (list w u) + (make-dynwind + src + (make-lexical-ref #f 'w w-sym) + (make-call #f (make-lexical-ref #f 'w w-sym) '()) + (make-call #f thunk '()) + (make-call #f (make-lexical-ref #f 'u u-sym) '()) + (make-lexical-ref #f 'u u-sym))))) + (else + (let ((w-sym (gensym "w "))) + (record-new-temporary! 'w w-sym 2) + (make-let src '(w) (list w-sym) (list w) + (make-dynwind + src + (make-lexical-ref #f 'w w-sym) + (make-call #f (make-lexical-ref #f 'w w-sym) '()) + (make-call #f thunk '()) + (make-call #f u '()) + u)))))) + ((not (constant-expression? u)) + (let ((u-sym (gensym "u "))) + (record-new-temporary! 'u u-sym 2) + (make-let src '(u) (list u-sym) (list u) + (make-dynwind + src + w + (make-call #f w '()) + (make-call #f thunk '()) + (make-call #f (make-lexical-ref #f 'u u-sym) '()) + (make-lexical-ref #f 'u u-sym))))) + (else + (make-dynwind src w (make-call #f w '()) (make-call #f thunk '()) + (make-call #f u '()) u))))) + + (($ <primcall> src 'values exps) (cond ((null? exps) (if (eq? ctx 'effect) @@ -1177,10 +1172,10 @@ top-level bindings from ENV and return the resulting expression." ((value test effect) #t) (else (null? (cdr vals)))) (every singly-valued-expression? vals)) - (for-tail (make-sequence src (append (cdr vals) (list (car vals))))) - (make-application src (make-primitive-ref #f 'values) vals)))))) - (($ <application> src (and apply ($ <primitive-ref> _ (or 'apply '@apply))) - (proc args ... tail)) + (for-tail (list->seq src (append (cdr vals) (list (car vals))))) + (make-primcall src 'values vals)))))) + + (($ <primcall> src (or 'apply '@apply) (proc args ... tail)) (let lp ((tail* (find-definition tail 1)) (speculative? #t)) (define (copyable? x) ;; Inlining a result from find-definition effectively copies it, @@ -1190,126 +1185,133 @@ top-level bindings from ENV and return the resulting expression." (match tail* (($ <const> _ (args* ...)) (let ((args* (map (cut make-const #f <>) args*))) - (for-tail (make-application src proc (append args args*))))) - (($ <application> _ ($ <primitive-ref> _ 'cons) + (for-tail (make-call src proc (append args args*))))) + (($ <primcall> _ 'cons ((and head (? copyable?)) (and tail (? copyable?)))) - (for-tail (make-application src apply - (cons proc - (append args (list head tail)))))) - (($ <application> _ ($ <primitive-ref> _ 'list) + (for-tail (make-primcall src '@apply + (cons proc + (append args (list head tail)))))) + (($ <primcall> _ 'list (and args* ((? copyable?) ...))) - (for-tail (make-application src proc (append args args*)))) + (for-tail (make-call src proc (append args args*)))) (tail* (if speculative? (lp (for-value tail) #f) (let ((args (append (map for-value args) (list tail*)))) - (make-application src apply - (cons (for-value proc) args)))))))) - (($ <application> src orig-proc orig-args) + (make-primcall src '@apply + (cons (for-value proc) args)))))))) + + (($ <primcall> src (? constructor-primitive? name) args) + (cond + ((and (memq ctx '(effect test)) + (match (cons name args) + ((or ('cons _ _) + ('list . _) + ('vector . _) + ('make-prompt-tag) + ('make-prompt-tag ($ <const> _ (? string?)))) + #t) + (_ #f))) + ;; Some expressions can be folded without visiting the + ;; arguments for value. + (let ((res (if (eq? ctx 'effect) + (make-void #f) + (make-const #f #t)))) + (for-tail (list->seq src (append args (list res)))))) + (else + (match (cons name (map for-value args)) + (('cons x ($ <const> _ (? (cut eq? <> '())))) + (make-primcall src 'list (list x))) + (('cons x ($ <primcall> _ 'list elts)) + (make-primcall src 'list (cons x elts))) + ((name . args) + (make-primcall src name args)))))) + + (($ <primcall> src (? accessor-primitive? name) args) + (match (cons name (map for-value args)) + ;; FIXME: these for-tail recursions could take place outside + ;; an effort counter. + (('car ($ <primcall> src 'cons (head tail))) + (for-tail (make-seq src tail head))) + (('cdr ($ <primcall> src 'cons (head tail))) + (for-tail (make-seq src head tail))) + (('car ($ <primcall> src 'list (head . tail))) + (for-tail (list->seq src (append tail (list head))))) + (('cdr ($ <primcall> src 'list (head . tail))) + (for-tail (make-seq src head (make-primcall #f 'list tail)))) + + (('car ($ <const> src (head . tail))) + (for-tail (make-const src head))) + (('cdr ($ <const> src (head . tail))) + (for-tail (make-const src tail))) + (((or 'memq 'memv) k ($ <const> _ (elts ...))) + ;; FIXME: factor + (case ctx + ((effect) + (for-tail + (make-seq src k (make-void #f)))) + ((test) + (cond + ((const? k) + ;; A shortcut. The `else' case would handle it, but + ;; this way is faster. + (let ((member (case name ((memq) memq) ((memv) memv)))) + (make-const #f (and (member (const-exp k) elts) #t)))) + ((null? elts) + (for-tail + (make-seq src k (make-const #f #f)))) + (else + (let ((t (gensym "t ")) + (eq (if (eq? name 'memq) 'eq? 'eqv?))) + (record-new-temporary! 't t (length elts)) + (for-tail + (make-let + src (list 't) (list t) (list k) + (let lp ((elts elts)) + (define test + (make-primcall #f eq + (list (make-lexical-ref #f 't t) + (make-const #f (car elts))))) + (if (null? (cdr elts)) + test + (make-conditional src test + (make-const #f #t) + (lp (cdr elts))))))))))) + (else + (cond + ((const? k) + (let ((member (case name ((memq) memq) ((memv) memv)))) + (make-const #f (member (const-exp k) elts)))) + ((null? elts) + (for-tail (make-seq src k (make-const #f #f)))) + (else + (make-primcall src name (list k (make-const #f elts)))))))) + ((name . args) + (fold-constants src name args ctx)))) + + (($ <primcall> src (? equality-primitive? name) (a b)) + (let ((val-a (for-value a)) + (val-b (for-value b))) + (log 'equality-primitive name val-a val-b) + (cond ((and (lexical-ref? val-a) (lexical-ref? val-b) + (eq? (lexical-ref-gensym val-a) + (lexical-ref-gensym val-b))) + (for-tail (make-const #f #t))) + (else + (fold-constants src name (list val-a val-b) ctx))))) + + (($ <primcall> src (? effect-free-primitive? name) args) + (fold-constants src name (map for-value args) ctx)) + + (($ <primcall> src name args) + (make-primcall src name (map for-value args))) + + (($ <call> src orig-proc orig-args) ;; todo: augment the global env with specialized functions (let revisit-proc ((proc (visit orig-proc 'operator))) (match proc - (($ <primitive-ref> _ (? constructor-primitive? name)) - (cond - ((and (memq ctx '(effect test)) - (match (cons name orig-args) - ((or ('cons _ _) - ('list . _) - ('vector . _) - ('make-prompt-tag) - ('make-prompt-tag ($ <const> _ (? string?)))) - #t) - (_ #f))) - ;; Some expressions can be folded without visiting the - ;; arguments for value. - (let ((res (if (eq? ctx 'effect) - (make-void #f) - (make-const #f #t)))) - (for-tail (make-sequence src (append orig-args (list res)))))) - (else - (match (cons name (map for-value orig-args)) - (('cons head tail) - (match tail - (($ <const> src (? (cut eq? <> '()))) - (make-application src (make-primitive-ref #f 'list) - (list head))) - (($ <application> src ($ <primitive-ref> _ 'list) elts) - (make-application src (make-primitive-ref #f 'list) - (cons head elts))) - (_ (make-application src proc (list head tail))))) - ((_ . args) - (make-application src proc args)))))) - (($ <primitive-ref> _ (? accessor-primitive? name)) - (match (cons name (map for-value orig-args)) - ;; FIXME: these for-tail recursions could take place outside - ;; an effort counter. - (('car ($ <application> src ($ <primitive-ref> _ 'cons) (head tail))) - (for-tail (make-sequence src (list tail head)))) - (('cdr ($ <application> src ($ <primitive-ref> _ 'cons) (head tail))) - (for-tail (make-sequence src (list head tail)))) - (('car ($ <application> src ($ <primitive-ref> _ 'list) (head . tail))) - (for-tail (make-sequence src (append tail (list head))))) - (('cdr ($ <application> src ($ <primitive-ref> _ 'list) (head . tail))) - (for-tail (make-sequence - src - (list head - (make-application - src (make-primitive-ref #f 'list) tail))))) - - (('car ($ <const> src (head . tail))) - (for-tail (make-const src head))) - (('cdr ($ <const> src (head . tail))) - (for-tail (make-const src tail))) - (((or 'memq 'memv) k ($ <const> _ (elts ...))) - ;; FIXME: factor - (case ctx - ((effect) - (for-tail - (make-sequence src (list k (make-void #f))))) - ((test) - (cond - ((const? k) - ;; A shortcut. The `else' case would handle it, but - ;; this way is faster. - (let ((member (case name ((memq) memq) ((memv) memv)))) - (make-const #f (and (member (const-exp k) elts) #t)))) - ((null? elts) - (for-tail - (make-sequence src (list k (make-const #f #f))))) - (else - (let ((t (gensym "t-")) - (eq (if (eq? name 'memq) 'eq? 'eqv?))) - (record-new-temporary! 't t (length elts)) - (for-tail - (make-let - src (list 't) (list t) (list k) - (let lp ((elts elts)) - (define test - (make-application - #f (make-primitive-ref #f eq) - (list (make-lexical-ref #f 't t) - (make-const #f (car elts))))) - (if (null? (cdr elts)) - test - (make-conditional src test - (make-const #f #t) - (lp (cdr elts))))))))))) - (else - (cond - ((const? k) - (let ((member (case name ((memq) memq) ((memv) memv)))) - (make-const #f (member (const-exp k) elts)))) - ((null? elts) - (for-tail (make-sequence src (list k (make-const #f #f))))) - (else - (make-application src proc (list k (make-const #f elts)))))))) - ((_ . args) - (or (fold-constants src name args ctx) - (make-application src proc args))))) - (($ <primitive-ref> _ (? effect-free-primitive? name)) - (let ((args (map for-value orig-args))) - (or (fold-constants src name args ctx) - (make-application src proc args)))) + (($ <primitive-ref> _ name) + (for-tail (make-primcall src name orig-args))) (($ <lambda> _ _ ($ <lambda-case> _ req opt rest #f inits gensyms body #f)) ;; Simple case: no keyword arguments. @@ -1318,7 +1320,7 @@ top-level bindings from ENV and return the resulting expression." (nreq (length req)) (nopt (if opt (length opt) 0)) (key (source-expression proc))) - (define (inlined-application) + (define (inlined-call) (make-let src (append req (or opt '()) @@ -1327,9 +1329,8 @@ top-level bindings from ENV and return the resulting expression." (if (> nargs (+ nreq nopt)) (append (list-head orig-args (+ nreq nopt)) (list - (make-application - #f - (make-primitive-ref #f 'list) + (make-primcall + #f 'list (drop orig-args (+ nreq nopt))))) (append orig-args (drop inits (- nargs nreq)) @@ -1341,8 +1342,7 @@ top-level bindings from ENV and return the resulting expression." (cond ((or (< nargs nreq) (and (not rest) (> nargs (+ nreq nopt)))) ;; An error, or effecting arguments. - (make-application src (for-call orig-proc) - (map for-value orig-args))) + (make-call src (for-call orig-proc) (map for-value orig-args))) ((or (and=> (find-counter key counter) counter-recursive?) (lambda? orig-proc)) ;; A recursive call, or a lambda in the operator @@ -1364,7 +1364,7 @@ top-level bindings from ENV and return the resulting expression." (lp (counter-prev counter))))))) (log 'inline-recurse key) - (loop (inlined-application) env counter ctx)) + (loop (inlined-call) env counter ctx)) (else ;; An integration at the top-level, the first ;; recursion of a recursive procedure, or a nested @@ -1374,8 +1374,8 @@ top-level bindings from ENV and return the resulting expression." (let/ec k (define (abort) (log 'inline-abort exp) - (k (make-application src (for-call orig-proc) - (map for-value orig-args)))) + (k (make-call src (for-call orig-proc) + (map for-value orig-args)))) (define new-counter (cond ;; These first two cases will transfer effort @@ -1395,7 +1395,7 @@ top-level bindings from ENV and return the resulting expression." (make-top-counter effort-limit operand-size-limit abort key)))) (define result - (loop (inlined-application) env new-counter ctx)) + (loop (inlined-call) env new-counter ctx)) (if counter ;; The nested inlining attempt succeeded. @@ -1420,7 +1420,7 @@ top-level bindings from ENV and return the resulting expression." (log 'inline-let orig-proc) (for-tail (make-let lsrc names syms vals - (make-application src body orig-args)))) + (make-call src body orig-args)))) ;; It's possible for a `let' to go away after the ;; visit due to the fact that visiting a procedure in ;; value context will prune unused bindings, whereas @@ -1428,11 +1428,10 @@ top-level bindings from ENV and return the resulting expression." ;; traverse through lambdas. In that case re-visit ;; the procedure. (proc (revisit-proc proc))) - (make-application src (for-call orig-proc) - (map for-value orig-args)))) + (make-call src (for-call orig-proc) + (map for-value orig-args)))) (_ - (make-application src (for-call orig-proc) - (map for-value orig-args)))))) + (make-call src (for-call orig-proc) (map for-value orig-args)))))) (($ <lambda> src meta body) (case ctx ((effect) (make-void #f)) @@ -1445,8 +1444,7 @@ top-level bindings from ENV and return the resulting expression." (define (lift-applied-lambda body gensyms) (and (not opt) rest (not kw) (match body - (($ <application> _ - ($ <primitive-ref> _ '@apply) + (($ <primcall> _ '@apply (($ <lambda> _ _ lcase) ($ <lexical-ref> _ _ sym) ...)) @@ -1473,29 +1471,21 @@ top-level bindings from ENV and return the resulting expression." new body (and alt (for-tail alt)))))) - (($ <sequence> src exps) - (let lp ((exps exps) (effects '())) - (match exps - ((last) - (if (null? effects) - (for-tail last) - (make-sequence - src - (reverse (cons (for-tail last) effects))))) - ((head . rest) - (let ((head (for-effect head))) - (cond - ((sequence? head) - (lp (append (sequence-exps head) rest) effects)) - ((void? head) - (lp rest effects)) - (else - (lp rest (cons head effects))))))))) + (($ <seq> src head tail) + (let ((head (for-effect head)) + (tail (for-tail tail))) + (if (void? head) + tail + (make-seq src + (if (and (seq? head) + (void? (seq-tail head))) + (seq-head head) + head) + tail)))) (($ <prompt> src tag body handler) (define (make-prompt-tag? x) (match x - (($ <application> _ ($ <primitive-ref> _ 'make-prompt-tag) - (or () ((? constant-expression?)))) + (($ <primcall> _ 'make-prompt-tag (or () ((? constant-expression?)))) #t) (_ #f))) @@ -1527,11 +1517,11 @@ top-level bindings from ENV and return the resulting expression." (for-tail (make-let-values src - (make-application #f (make-primitive-ref #f 'apply) - `(,(make-primitive-ref #f 'values) - ,(make-primitive-ref #f 'values) - ,@(abort-args body) - ,(abort-tail body))) + (make-primcall #f 'apply + `(,(make-primitive-ref #f 'values) + ,(make-primitive-ref #f 'values) + ,@(abort-args body) + ,(abort-tail body))) (for-value handler))))) (else (make-prompt src tag body (for-value handler)))))) diff --git a/module/language/tree-il/primitives.scm b/module/language/tree-il/primitives.scm index bac3136e3..e3f6a9071 100644 --- a/module/language/tree-il/primitives.scm +++ b/module/language/tree-il/primitives.scm @@ -29,7 +29,8 @@ expand-primitives! effect-free-primitive? effect+exception-free-primitive? constructor-primitive? accessor-primitive? - singly-valued-primitive? bailout-primitive? + singly-valued-primitive? equality-primitive? + bailout-primitive? negate-primitive)) ;; When adding to this, be sure to update *multiply-valued-primitives* @@ -48,7 +49,7 @@ + * - / 1- 1+ quotient remainder modulo ash logand logior logxor lognot not - pair? null? list? symbol? vector? string? struct? number? char? + pair? null? list? symbol? vector? string? struct? number? char? nil? complex? real? rational? inf? nan? integer? exact? inexact? even? odd? @@ -70,7 +71,7 @@ caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr - vector-ref vector-set! + vector-length vector-ref vector-set! variable-ref variable-set! variable-bound? @@ -153,12 +154,12 @@ ash logand logior logxor lognot + * - / 1- 1+ quotient remainder modulo not - pair? null? list? symbol? vector? struct? string? number? char? + pair? null? list? symbol? vector? struct? string? number? char? nil complex? real? rational? inf? nan? integer? exact? inexact? even? odd? char<? char<=? char>=? char>? integer->char char->integer number->string string->number struct-vtable - string-length + string-length vector-length ;; These all should get expanded out by expand-primitives!. caar cadr cdar cddr caaar caadr cadar caddr cdaar cdadr cddar cdddr @@ -200,8 +201,12 @@ (char<? . char>=?) (char>? . char<=?))) +(define *equality-primitives* + '(eq? eqv? equal?)) + (define *effect-free-primitive-table* (make-hash-table)) (define *effect+exceptions-free-primitive-table* (make-hash-table)) +(define *equality-primitive-table* (make-hash-table)) (define *multiply-valued-primitive-table* (make-hash-table)) (define *bailout-primitive-table* (make-hash-table)) (define *negatable-primitive-table* (make-hash-table)) @@ -212,6 +217,9 @@ (for-each (lambda (x) (hashq-set! *effect+exceptions-free-primitive-table* x #t)) *effect+exception-free-primitives*) +(for-each (lambda (x) + (hashq-set! *equality-primitive-table* x #t)) + *equality-primitives*) (for-each (lambda (x) (hashq-set! *multiply-valued-primitive-table* x #t)) *multiply-valued-primitives*) @@ -231,6 +239,8 @@ (hashq-ref *effect-free-primitive-table* prim)) (define (effect+exception-free-primitive? prim) (hashq-ref *effect+exceptions-free-primitive-table* prim)) +(define (equality-primitive? prim) + (hashq-ref *equality-primitive-table* prim)) (define (singly-valued-primitive? prim) (not (hashq-ref *multiply-valued-primitive-table* prim))) (define (bailout-primitive? prim) @@ -239,14 +249,29 @@ (hashq-ref *negatable-primitive-table* prim)) (define (resolve-primitives! x mod) + (define local-definitions + (make-hash-table)) + + (let collect-local-definitions ((x x)) + (record-case x + ((<toplevel-define> name) + (hashq-set! local-definitions name #t)) + ((<seq> head tail) + (collect-local-definitions head) + (collect-local-definitions tail)) + (else #f))) + (post-order! (lambda (x) (record-case x ((<toplevel-ref> src name) - (and=> (hashq-ref *interesting-primitive-vars* - (module-variable mod name)) + (and=> (and (not (hashq-ref local-definitions name)) + (hashq-ref *interesting-primitive-vars* + (module-variable mod name))) (lambda (name) (make-primitive-ref src name)))) ((<module-ref> src mod name public?) + ;; for the moment, we're disabling primitive resolution for + ;; public refs because resolve-interface can raise errors. (and=> (and=> (resolve-module mod) (if public? module-public-interface @@ -256,6 +281,9 @@ (module-variable m name)) (lambda (name) (make-primitive-ref src name)))))) + ((<call> src proc args) + (and (primitive-ref? proc) + (make-primcall src (primitive-ref-name proc) args))) (else #f))) x)) @@ -267,11 +295,9 @@ (pre-order! (lambda (x) (record-case x - ((<application> src proc args) - (and (primitive-ref? proc) - (let ((expand (hashq-ref *primitive-expand-table* - (primitive-ref-name proc)))) - (and expand (apply expand src args))))) + ((<primcall> src name args) + (let ((expand (hashq-ref *primitive-expand-table* name))) + (and expand (apply expand src args)))) (else #f))) x)) @@ -287,8 +313,8 @@ (lp (cdr in) (cons (if (eq? (caar in) 'quote) `(make-const src ,@(cdar in)) - `(make-application src (make-primitive-ref src ',(caar in)) - ,(inline-args (cdar in)))) + `(make-primcall src ',(caar in) + ,(inline-args (cdar in)))) out))) ((symbol? (car in)) ;; assume it's locally bound @@ -306,8 +332,8 @@ ,(consequent then) ,(consequent else))) (else - `(make-application src (make-primitive-ref src ',(car exp)) - ,(inline-args (cdr exp)))))) + `(make-primcall src ',(car exp) + ,(inline-args (cdr exp)))))) ((symbol? exp) ;; assume locally bound exp) @@ -502,9 +528,9 @@ (symbol? v) (and (integer? v) (exact? v) - (<= most-negative-fixnum v most-positive-fixnum))) - (make-application src (make-primitive-ref #f 'eq?) - (list a b)))))) + (<= v most-positive-fixnum) + (>= v most-negative-fixnum))) + (make-primcall src 'eq? (list a b)))))) (or (maybe-simplify a b) (maybe-simplify b a))) (else #f))) @@ -512,25 +538,6 @@ (hashq-set! *primitive-expand-table* 'equal? maybe-simplify-to-eq) (hashq-set! *primitive-expand-table* - 'dynamic-wind - (case-lambda - ((src pre thunk post) - (let ((PRE (gensym "pre-")) - (THUNK (gensym "thunk-")) - (POST (gensym "post-"))) - (make-let - src - '(pre thunk post) - (list PRE THUNK POST) - (list pre thunk post) - (make-dynwind - src - (make-lexical-ref #f 'pre PRE) - (make-application #f (make-lexical-ref #f 'thunk THUNK) '()) - (make-lexical-ref #f 'post POST))))) - (else #f))) - -(hashq-set! *primitive-expand-table* '@dynamic-wind (case-lambda ((src pre expr post) @@ -544,7 +551,9 @@ (make-dynwind src (make-lexical-ref #f 'pre PRE) + (make-call #f (make-lexical-ref #f 'pre PRE) '()) expr + (make-call #f (make-lexical-ref #f 'post POST) '()) (make-lexical-ref #f 'post POST))))))) (hashq-set! *primitive-expand-table* @@ -570,9 +579,9 @@ ;; trickery here. (make-lambda-case (tree-il-src handler) '() #f 'args #f '() (list args-sym) - (make-application #f (make-primitive-ref #f 'apply) - (list handler - (make-lexical-ref #f 'args args-sym))) + (make-primcall #f 'apply + (list handler + (make-lexical-ref #f 'args args-sym))) #f)))) (else #f))) @@ -585,13 +594,13 @@ (make-let src '(handler) (list handler-sym) (list handler) (make-prompt - src tag (make-application #f thunk '()) + src tag (make-call #f thunk '()) ;; If handler itself is a lambda, the inliner can do some ;; trickery here. (make-lambda-case (tree-il-src handler) '() #f 'args #f '() (list args-sym) - (make-application - #f (make-primitive-ref #f 'apply) + (make-primcall + #f 'apply (list (make-lexical-ref #f 'handler handler-sym) (make-lexical-ref #f 'args args-sym))) #f))))) diff --git a/module/language/tree-il/spec.scm b/module/language/tree-il/spec.scm index bb7a200b7..80c32fe29 100644 --- a/module/language/tree-il/spec.scm +++ b/module/language/tree-il/spec.scm @@ -1,6 +1,6 @@ ;;; Tree Intermediate Language -;; Copyright (C) 2009, 2010, 2013 Free Software Foundation, Inc. +;; Copyright (C) 2009, 2010, 2011, 2013 Free Software Foundation, Inc. ;;;; This library is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Lesser General Public @@ -33,7 +33,9 @@ (pmatch exps (() (make-void #f)) ((,x) x) - (else (make-sequence #f exps)))) + ((,x . ,rest) + (make-seq #f x (join rest env))) + (else (error "what!" exps env)))) (define-language tree-il #:title "Tree Intermediate Language" diff --git a/module/oop/goops.scm b/module/oop/goops.scm index 8e548d8e9..2e875fa4b 100644 --- a/module/oop/goops.scm +++ b/module/oop/goops.scm @@ -25,54 +25,112 @@ ;;;; (define-module (oop goops) - :use-module (srfi srfi-1) - :export-syntax (define-class class standard-define-class - define-generic define-accessor define-method - define-extended-generic define-extended-generics - method) - :export (is-a? class-of - ensure-metaclass ensure-metaclass-with-supers - make-class - make-generic ensure-generic - make-extended-generic - make-accessor ensure-accessor - add-method! - class-slot-ref class-slot-set! slot-unbound slot-missing - slot-definition-name slot-definition-options - slot-definition-allocation - slot-definition-getter slot-definition-setter - slot-definition-accessor - slot-definition-init-value slot-definition-init-form - slot-definition-init-thunk slot-definition-init-keyword - slot-init-function class-slot-definition - method-source - compute-cpl compute-std-cpl compute-get-n-set compute-slots - compute-getter-method compute-setter-method - allocate-instance initialize make-instance make - no-next-method no-applicable-method no-method - change-class update-instance-for-different-class - shallow-clone deep-clone - class-redefinition - apply-generic apply-method apply-methods - compute-applicable-methods %compute-applicable-methods - method-more-specific? sort-applicable-methods - class-subclasses class-methods - goops-error - min-fixnum max-fixnum - ;;; *fixme* Should go into goops.c - instance? slot-ref-using-class - slot-set-using-class! slot-bound-using-class? - slot-exists-using-class? slot-ref slot-set! slot-bound? - class-name class-direct-supers class-direct-subclasses - class-direct-methods class-direct-slots class-precedence-list - class-slots - generic-function-name - generic-function-methods method-generic-function - method-specializers method-formals - primitive-generic-generic enable-primitive-generic! - method-procedure accessor-method-slot-definition - slot-exists? make find-method get-keyword) - :no-backtrace) + #:use-module (srfi srfi-1) + #:export-syntax (define-class class standard-define-class + define-generic define-accessor define-method + define-extended-generic define-extended-generics + method) + #:export ( ;; The root of everything. + <top> + <class> <object> + + ;; Slot types. + <foreign-slot> <protected-slot> <hidden-slot> <opaque-slot> + <read-only-slot> <self-slot> <protected-opaque-slot> + <protected-hidden-slot> <protected-read-only-slot> + <scm-slot> <int-slot> <float-slot> <double-slot> + + ;; Methods are implementations of generic functions. + <method> <accessor-method> + + ;; Applicable objects, either procedures or applicable structs. + <procedure-class> <applicable> + <procedure> <primitive-generic> + + ;; Applicable structs. + <applicable-struct-class> + <applicable-struct> + <generic> <extended-generic> + <generic-with-setter> <extended-generic-with-setter> + <accessor> <extended-accessor> + + ;; Types with their own allocated typecodes. + <boolean> <char> <list> <pair> <null> <string> <symbol> + <vector> <bytevector> <uvec> <foreign> <hashtable> + <fluid> <dynamic-state> <frame> <objcode> <vm> <vm-continuation> + + ;; Numbers. + <number> <complex> <real> <integer> <fraction> + + ;; Unknown. + <unknown> + + ;; Particular SMOB data types. All SMOB types have + ;; corresponding classes, which may be obtained via class-of, + ;; once you have an instance. Perhaps FIXME to provide a + ;; smob-type-name->class procedure. + <arbiter> <promise> <thread> <mutex> <condition-variable> + <regexp> <hook> <bitvector> <random-state> <async> + <directory> <keyword> <array> <character-set> + <dynamic-object> <guardian> <macro> + + ;; Modules. + <module> + + ;; Ports. + <port> <input-port> <output-port> <input-output-port> + + ;; Like SMOB types, all port types have their own classes, + ;; which can be accessed via `class-of' once you have an + ;; instance. Here we export bindings just for file ports. + <file-port> + <file-input-port> <file-output-port> <file-input-output-port> + + is-a? class-of + ensure-metaclass ensure-metaclass-with-supers + make-class + make-generic ensure-generic + make-extended-generic + make-accessor ensure-accessor + add-method! + class-slot-ref class-slot-set! slot-unbound slot-missing + slot-definition-name slot-definition-options + slot-definition-allocation + + slot-definition-getter slot-definition-setter + slot-definition-accessor + slot-definition-init-value slot-definition-init-form + slot-definition-init-thunk slot-definition-init-keyword + slot-init-function class-slot-definition + method-source + compute-cpl compute-std-cpl compute-get-n-set compute-slots + compute-getter-method compute-setter-method + allocate-instance initialize make-instance make + no-next-method no-applicable-method no-method + change-class update-instance-for-different-class + shallow-clone deep-clone + class-redefinition + apply-generic apply-method apply-methods + compute-applicable-methods %compute-applicable-methods + method-more-specific? sort-applicable-methods + class-subclasses class-methods + goops-error + min-fixnum max-fixnum + +;;; *fixme* Should go into goops.c + instance? slot-ref-using-class + slot-set-using-class! slot-bound-using-class? + slot-exists-using-class? slot-ref slot-set! slot-bound? + class-name class-direct-supers class-direct-subclasses + class-direct-methods class-direct-slots class-precedence-list + class-slots + generic-function-name + generic-function-methods method-generic-function + method-specializers method-formals + primitive-generic-generic enable-primitive-generic! + method-procedure accessor-method-slot-definition + slot-exists? make find-method get-keyword) + #:no-backtrace) (define *goops-module* (current-module)) @@ -96,6 +154,7 @@ (oop goops compile)) +;; FIXME: deprecate. (eval-when (eval load compile) (define min-fixnum (- (expt 2 29))) (define max-fixnum (- (expt 2 29) 1))) @@ -814,6 +873,20 @@ ;;; Handling of duplicate bindings in the module system ;;; +(define (find-subclass super name) + (let lp ((classes (class-direct-subclasses super))) + (cond + ((null? classes) + (error "class not found" name)) + ((and (slot-bound? (car classes) 'name) + (eq? (class-name (car classes)) name)) + (car classes)) + (else + (lp (cdr classes)))))) + +;; A record type. +(define <module> (find-subclass <top> '<module>)) + (define-method (merge-generics (module <module>) (name <symbol>) (int1 <module>) @@ -1659,3 +1732,34 @@ ;; Tell C code that the main bulk of Goops has been loaded (%goops-loaded) + + + + +;;; +;;; {SMOB and port classes} +;;; + +(define <arbiter> (find-subclass <top> '<arbiter>)) +(define <promise> (find-subclass <top> '<promise>)) +(define <thread> (find-subclass <top> '<thread>)) +(define <mutex> (find-subclass <top> '<mutex>)) +(define <condition-variable> (find-subclass <top> '<condition-variable>)) +(define <regexp> (find-subclass <top> '<regexp>)) +(define <hook> (find-subclass <top> '<hook>)) +(define <bitvector> (find-subclass <top> '<bitvector>)) +(define <random-state> (find-subclass <top> '<random-state>)) +(define <async> (find-subclass <top> '<async>)) +(define <directory> (find-subclass <top> '<directory>)) +(define <keyword> (find-subclass <top> '<keyword>)) +(define <array> (find-subclass <top> '<array>)) +(define <character-set> (find-subclass <top> '<character-set>)) +(define <dynamic-object> (find-subclass <top> '<dynamic-object>)) +(define <guardian> (find-subclass <applicable> '<guardian>)) +(define <macro> (find-subclass <top> '<macro>)) + +(define (define-class-subtree class) + (define! (class-name class) class) + (for-each define-class-subtree (class-direct-subclasses class))) + +(define-class-subtree (find-subclass <port> '<file-port>)) diff --git a/module/oop/goops/util.scm b/module/oop/goops/util.scm index af72bc3f5..3c86f1525 100644 --- a/module/oop/goops/util.scm +++ b/module/oop/goops/util.scm @@ -1,4 +1,4 @@ -;;;; Copyright (C) 1999, 2000, 2001, 2003, 2006, 2008 Free Software Foundation, Inc. +;;;; Copyright (C) 1999, 2000, 2001, 2003, 2006, 2008, 2012 Free Software Foundation, Inc. ;;;; ;;;; This library is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Lesser General Public @@ -37,19 +37,6 @@ ((memv (car l) (cdr l)) (car l)) (else (find-duplicate (cdr l))))) -(begin-deprecated - (define (top-level-env) - (let ((mod (current-module))) - (if mod - (module-eval-closure mod) - '()))) - - (define (top-level-env? env) - (or (null? env) - (procedure? (car env)))) - - (export top-level-env? top-level-env)) - (define (map* fn . l) ; A map which accepts dotted lists (arg lists (cond ; must be "isomorph" ((null? (car l)) '()) diff --git a/module/rnrs/io/ports.scm b/module/rnrs/io/ports.scm index c1484cbed..069574a49 100644 --- a/module/rnrs/io/ports.scm +++ b/module/rnrs/io/ports.scm @@ -220,24 +220,22 @@ (define (port-transcoder port) "Return the transcoder object associated with @var{port}, or @code{#f} if the port has no transcoder." - (cond ((port-encoding port) - => (lambda (encoding) - (make-transcoder - encoding - (native-eol-style) - (case (port-conversion-strategy port) - ((error) 'raise) - ((substitute) 'replace) - (else - (assertion-violation 'port-transcoder - "unsupported error handling mode")))))) - (else - #f))) + (and (textual-port? port) + ;; All textual ports have transcoders. + (make-transcoder + (port-encoding port) + (native-eol-style) + (case (port-conversion-strategy port) + ((error) 'raise) + ((substitute) 'replace) + (else + (assertion-violation 'port-transcoder + "unsupported error handling mode")))))) (define (binary-port? port) - "Returns @code{#t} if @var{port} does not have an associated encoding, -@code{#f} otherwise." - (not (port-encoding port))) + "Always returns @code{#t}, as all ports can be used for binary I/O in +Guile." + (equal? (port-encoding port) "ISO-8859-1")) (define (textual-port? port) "Always returns @code{#t}, as all ports can be used for textual I/O in diff --git a/module/scripts/disassemble.scm b/module/scripts/disassemble.scm index 7dab2dde9..094d65654 100644 --- a/module/scripts/disassemble.scm +++ b/module/scripts/disassemble.scm @@ -1,6 +1,6 @@ ;;; Disassemble --- Disassemble .go files into something human-readable -;; Copyright 2005, 2008, 2009, 2011 Free Software Foundation, Inc. +;; Copyright 2005, 2008, 2009, 2011, 2012 Free Software Foundation, Inc. ;; ;; This program is free software; you can redistribute it and/or ;; modify it under the terms of the GNU Lesser General Public License @@ -36,7 +36,7 @@ (define (disassemble . files) (for-each (lambda (file) - (asm:disassemble (load-objcode file))) + (asm:disassemble (load-thunk-from-file file))) files)) (define main disassemble) diff --git a/module/srfi/srfi-18.scm b/module/srfi/srfi-18.scm index 4921a95d7..684a1254e 100644 --- a/module/srfi/srfi-18.scm +++ b/module/srfi/srfi-18.scm @@ -1,6 +1,6 @@ ;;; srfi-18.scm --- Multithreading support -;; Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc. +;; Copyright (C) 2008, 2009, 2010, 2012 Free Software Foundation, Inc. ;; ;; This library is free software; you can redistribute it and/or ;; modify it under the terms of the GNU Lesser General Public @@ -145,15 +145,15 @@ (check-arg-type procedure? handler "with-exception-handler") (check-arg-type thunk? thunk "with-exception-handler") (hashq-set! thread-exception-handlers ct (cons handler hl)) - (apply (@ (srfi srfi-34) with-exception-handler) - (list (lambda (obj) - (hashq-set! thread-exception-handlers ct hl) - (handler obj)) - (lambda () - (call-with-values thunk - (lambda res - (hashq-set! thread-exception-handlers ct hl) - (apply values res)))))))) + ((@ (srfi srfi-34) with-exception-handler) + (lambda (obj) + (hashq-set! thread-exception-handlers ct hl) + (handler obj)) + (lambda () + (call-with-values thunk + (lambda res + (hashq-set! thread-exception-handlers ct hl) + (apply values res))))))) (define (current-exception-handler) (car (current-handler-stack))) @@ -277,7 +277,7 @@ (define (thread-join! thread . args) (define thread-join-inner! (wrap (lambda () - (let ((v (apply join-thread (cons thread args))) + (let ((v (apply join-thread thread args)) (e (thread->exception thread))) (if (and (= (length args) 1) (not v)) (raise join-timeout-exception)) @@ -320,12 +320,12 @@ (define mutex-lock-inner! (wrap (lambda () (catch 'abandoned-mutex-error - (lambda () (apply lock-mutex (cons mutex args))) + (lambda () (apply lock-mutex mutex args)) (lambda (key . args) (raise abandoned-mutex-exception)))))) (call/cc mutex-lock-inner!)) (define (mutex-unlock! mutex . args) - (apply unlock-mutex (cons mutex args))) + (apply unlock-mutex mutex args)) ;; CONDITION VARIABLES ;; These functions are all pass-thrus to the existing Guile implementations. diff --git a/module/system/foreign.scm b/module/system/foreign.scm index e4db6ffb3..01a71b8b9 100644 --- a/module/system/foreign.scm +++ b/module/system/foreign.scm @@ -192,10 +192,6 @@ which does the reverse. PRINT must name a user-defined object printer." ;; PTR1 == PTR2 <-> (eq? (wrap PTR1) (wrap PTR2)). (let ((ptr->obj (make-weak-value-hash-table 3000))) (lambda (ptr) - ;; XXX: We can't use `hash-create-handle!' + - ;; `set-cdr!' here because the former would create a - ;; weak-cdr pair but the latter wouldn't register a - ;; disappearing link (see `scm_hash_fn_set_x'.) (or (hash-ref ptr->obj ptr) (let ((o (%wrap ptr))) (hash-set! ptr->obj ptr o) diff --git a/module/system/repl/command.scm b/module/system/repl/command.scm index c4e9e2ce5..aa16f5d8d 100644 --- a/module/system/repl/command.scm +++ b/module/system/repl/command.scm @@ -1,6 +1,6 @@ ;;; Repl commands -;; Copyright (C) 2001, 2009, 2010, 2011, 2013 Free Software Foundation, Inc. +;; Copyright (C) 2001, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc. ;; This library is free software; you can redistribute it and/or ;; modify it under the terms of the GNU Lesser General Public @@ -495,7 +495,7 @@ Disassemble a compiled procedure." (define-meta-command (disassemble-file repl file) "disassemble-file FILE Disassemble a file." - (guile:disassemble (load-objcode (->string file)))) + (guile:disassemble (load-thunk-from-file (->string file)))) ;;; diff --git a/module/system/vm/elf.scm b/module/system/vm/elf.scm new file mode 100644 index 000000000..040b27433 --- /dev/null +++ b/module/system/vm/elf.scm @@ -0,0 +1,1255 @@ +;;; Guile ELF reader and writer + +;; Copyright (C) 2011, 2012 Free Software Foundation, Inc. + +;;;; This library is free software; you can redistribute it and/or +;;;; modify it under the terms of the GNU Lesser General Public +;;;; License as published by the Free Software Foundation; either +;;;; version 3 of the License, or (at your option) any later version. +;;;; +;;;; This library is distributed in the hope that it will be useful, +;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +;;;; Lesser General Public License for more details. +;;;; +;;;; You should have received a copy of the GNU Lesser General Public +;;;; License along with this library; if not, write to the Free Software +;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +;;; Code: + +(define-module (system vm elf) + #:use-module (rnrs bytevectors) + #:use-module (system foreign) + #:use-module (system base target) + #:use-module (srfi srfi-9) + #:use-module (ice-9 receive) + #:use-module (ice-9 vlist) + #:export (has-elf-header? + + make-elf elf? + elf-bytes elf-word-size elf-byte-order + elf-abi elf-type elf-machine-type + elf-entry elf-phoff elf-shoff elf-flags elf-ehsize + elf-phentsize elf-phnum elf-shentsize elf-shnum elf-shstrndx + + (make-elf-segment* . make-elf-segment) + elf-segment? + elf-segment-type elf-segment-offset elf-segment-vaddr + elf-segment-paddr elf-segment-filesz elf-segment-memsz + elf-segment-flags elf-segment-align + + (make-elf-section* . make-elf-section) + elf-section? + elf-section-name elf-section-type elf-section-flags + elf-section-addr elf-section-offset elf-section-size + elf-section-link elf-section-info elf-section-addralign + elf-section-entsize + + make-elf-symbol elf-symbol? + elf-symbol-name elf-symbol-value elf-symbol-size + elf-symbol-info elf-symbol-other elf-symbol-shndx + elf-symbol-binding elf-symbol-type elf-symbol-visibility + + SHT_NULL SHT_PROGBITS SHT_SYMTAB SHT_STRTAB SHT_RELA + SHT_HASH SHT_DYNAMIC SHT_NOTE SHT_NOBITS SHT_REL SHT_SHLIB + SHT_DYNSYM SHT_INIT_ARRAY SHT_FINI_ARRAY SHT_PREINIT_ARRAY + SHT_GROUP SHT_SYMTAB_SHNDX SHT_NUM SHT_LOOS SHT_HIOS + SHT_LOPROC SHT_HIPROC SHT_LOUSER SHT_HIUSER + + SHF_WRITE SHF_ALLOC SHF_EXECINSTR SHF_MERGE SHF_STRINGS + SHF_INFO_LINK SHF_LINK_ORDER SHF_OS_NONCONFORMING SHF_GROUP + SHF_TLS + + DT_NULL DT_NEEDED DT_PLTRELSZ DT_PLTGOT DT_HASH DT_STRTAB + DT_SYMTAB DT_RELA DT_RELASZ DT_RELAENT DT_STRSZ DT_SYMENT + DT_INIT DT_FINI DT_SONAME DT_RPATH DT_SYMBOLIC DT_REL + DT_RELSZ DT_RELENT DT_PLTREL DT_DEBUG DT_TEXTREL DT_JMPREL + DT_BIND_NOW DT_INIT_ARRAY DT_FINI_ARRAY DT_INIT_ARRAYSZ + DT_FINI_ARRAYSZ DT_RUNPATH DT_FLAGS DT_ENCODING + DT_PREINIT_ARRAY DT_PREINIT_ARRAYSZ DT_NUM DT_LOGUILE + DT_GUILE_GC_ROOT DT_GUILE_GC_ROOT_SZ DT_GUILE_ENTRY + DT_GUILE_RTL_VERSION DT_HIGUILE DT_LOOS DT_HIOS DT_LOPROC + DT_HIPROC + + STB_LOCAL STB_GLOBAL STB_WEAK STB_NUM STB_LOOS STB_GNU + STB_HIOS STB_LOPROC STB_HIPROC + + STT_NOTYPE STT_OBJECT STT_FUNC STT_SECTION STT_FILE + STT_COMMON STT_TLS STT_NUM STT_LOOS STT_GNU STT_HIOS + STT_LOPROC STT_HIPROC + + STV_DEFAULT STV_INTERNAL STV_HIDDEN STV_PROTECTED + + NT_GNU_ABI_TAG NT_GNU_HWCAP NT_GNU_BUILD_ID NT_GNU_GOLD_VERSION + + parse-elf + elf-segment elf-segments + elf-section elf-sections elf-sections-by-name + elf-symbol-table-ref + + parse-elf-note + elf-note-name elf-note-desc elf-note-type + + (make-string-table . make-elf-string-table) + (string-table-intern . elf-string-table-intern) + (link-string-table . link-elf-string-table) + + (make-reloc . make-elf-reloc) + (make-symbol . make-elf-symbol) + + (make-object . make-elf-object) + (object? . elf-object?) + (object-section . elf-object-section) + (object-bv . elf-object-bv) + (object-relocs . elf-object-relocs) + (object-symbols . elf-object-symbols) + + link-elf)) + +;; #define EI_NIDENT 16 + +;; typedef struct { +;; unsigned char e_ident[EI_NIDENT]; +;; uint16_t e_type; +;; uint16_t e_machine; +;; uint32_t e_version; +;; ElfN_Addr e_entry; +;; ElfN_Off e_phoff; +;; ElfN_Off e_shoff; +;; uint32_t e_flags; +;; uint16_t e_ehsize; +;; uint16_t e_phentsize; +;; uint16_t e_phnum; +;; uint16_t e_shentsize; +;; uint16_t e_shnum; +;; uint16_t e_shstrndx; +;; } ElfN_Ehdr; + +(define elf32-header-len 52) +(define elf64-header-len 64) +(define (elf-header-len word-size) + (case word-size + ((4) elf32-header-len) + ((8) elf64-header-len) + (else (error "invalid word size" word-size)))) + +(define ELFCLASS32 1) ; 32-bit objects +(define ELFCLASS64 2) ; 64-bit objects + +(define ELFDATA2LSB 1) ; 2's complement, little endian +(define ELFDATA2MSB 2) ; 2's complement, big endian + +(define EV_CURRENT 1) ; Current version + +(define ELFOSABI_STANDALONE 255) ; Standalone (embedded) application + +(define ET_DYN 3) ; Shared object file + +;; +;; Machine types +;; +;; Just a sampling of these values. We could include more, but the +;; important thing is to recognize architectures for which we have a +;; native compiler. Recognizing more common machine types is icing on +;; the cake. +;; +(define EM_NONE 0) ; No machine +(define EM_SPARC 2) ; SUN SPARC +(define EM_386 3) ; Intel 80386 +(define EM_MIPS 8) ; MIPS R3000 big-endian +(define EM_PPC 20) ; PowerPC +(define EM_PPC64 21) ; PowerPC 64-bit +(define EM_ARM 40) ; ARM +(define EM_SH 42) ; Hitachi SH +(define EM_SPARCV9 43) ; SPARC v9 64-bit +(define EM_IA_64 50) ; Intel Merced +(define EM_X86_64 62) ; AMD x86-64 architecture + +(define cpu-mapping (make-hash-table)) +(for-each (lambda (pair) + (hashq-set! cpu-mapping (car pair) (cdr pair))) + `((none . ,EM_NONE) + (sparc . ,EM_SPARC) ; FIXME: map 64-bit to SPARCV9 ? + (i386 . ,EM_386) + (mips . ,EM_MIPS) + (ppc . ,EM_PPC) + (ppc64 . ,EM_PPC64) + (arm . ,EM_ARM) ; FIXME: there are more arm cpu variants + (sh . ,EM_SH) ; FIXME: there are more sh cpu variants + (ia64 . ,EM_IA_64) + (x86_64 . ,EM_X86_64))) + +(define SHN_UNDEF 0) + +(define host-machine-type + (hashq-ref cpu-mapping + (string->symbol (car (string-split %host-type #\-))) + EM_NONE)) + +(define host-word-size + (sizeof '*)) + +(define host-byte-order + (native-endianness)) + +(define (has-elf-header? bv) + (and + ;; e_ident + (>= (bytevector-length bv) 16) + (= (bytevector-u8-ref bv 0) #x7f) + (= (bytevector-u8-ref bv 1) (char->integer #\E)) + (= (bytevector-u8-ref bv 2) (char->integer #\L)) + (= (bytevector-u8-ref bv 3) (char->integer #\F)) + (cond + ((= (bytevector-u8-ref bv 4) ELFCLASS32) + (>= (bytevector-length bv) elf32-header-len)) + ((= (bytevector-u8-ref bv 4) ELFCLASS64) + (>= (bytevector-length bv) elf64-header-len)) + (else #f)) + (or (= (bytevector-u8-ref bv 5) ELFDATA2LSB) + (= (bytevector-u8-ref bv 5) ELFDATA2MSB)) + (= (bytevector-u8-ref bv 6) EV_CURRENT) + ;; Look at ABI later. + (= (bytevector-u8-ref bv 8) 0) ; ABI version + ;; The rest of the e_ident is padding. + + ;; e_version + (let ((byte-order (if (= (bytevector-u8-ref bv 5) ELFDATA2LSB) + (endianness little) + (endianness big)))) + (= (bytevector-u32-ref bv 20 byte-order) EV_CURRENT)))) + +(define-record-type <elf> + (make-elf bytes word-size byte-order abi type machine-type + entry phoff shoff flags ehsize + phentsize phnum shentsize shnum shstrndx) + elf? + (bytes elf-bytes) + (word-size elf-word-size) + (byte-order elf-byte-order) + (abi elf-abi) + (type elf-type) + (machine-type elf-machine-type) + (entry elf-entry) + (phoff elf-phoff) + (shoff elf-shoff) + (flags elf-flags) + (ehsize elf-ehsize) + (phentsize elf-phentsize) + (phnum elf-phnum) + (shentsize elf-shentsize) + (shnum elf-shnum) + (shstrndx elf-shstrndx)) + +(define (parse-elf32 bv byte-order) + (make-elf bv 4 byte-order + (bytevector-u8-ref bv 7) + (bytevector-u16-ref bv 16 byte-order) + (bytevector-u16-ref bv 18 byte-order) + (bytevector-u32-ref bv 24 byte-order) + (bytevector-u32-ref bv 28 byte-order) + (bytevector-u32-ref bv 32 byte-order) + (bytevector-u32-ref bv 36 byte-order) + (bytevector-u16-ref bv 40 byte-order) + (bytevector-u16-ref bv 42 byte-order) + (bytevector-u16-ref bv 44 byte-order) + (bytevector-u16-ref bv 46 byte-order) + (bytevector-u16-ref bv 48 byte-order) + (bytevector-u16-ref bv 50 byte-order))) + +(define (write-elf-ident bv class data abi) + (bytevector-u8-set! bv 0 #x7f) + (bytevector-u8-set! bv 1 (char->integer #\E)) + (bytevector-u8-set! bv 2 (char->integer #\L)) + (bytevector-u8-set! bv 3 (char->integer #\F)) + (bytevector-u8-set! bv 4 class) + (bytevector-u8-set! bv 5 data) + (bytevector-u8-set! bv 6 EV_CURRENT) + (bytevector-u8-set! bv 7 abi) + (bytevector-u8-set! bv 8 0) ; ABI version + (bytevector-u8-set! bv 9 0) ; Pad to 16 bytes. + (bytevector-u8-set! bv 10 0) + (bytevector-u8-set! bv 11 0) + (bytevector-u8-set! bv 12 0) + (bytevector-u8-set! bv 13 0) + (bytevector-u8-set! bv 14 0) + (bytevector-u8-set! bv 15 0)) + +(define (write-elf32 bv byte-order abi type machine-type + entry phoff shoff flags ehsize phentsize phnum + shentsize shnum shstrndx) + (write-elf-ident bv ELFCLASS32 + (case byte-order + ((little) ELFDATA2LSB) + ((big) ELFDATA2MSB) + (else (error "unknown endianness" byte-order))) + abi) + (bytevector-u16-set! bv 16 type byte-order) + (bytevector-u16-set! bv 18 machine-type byte-order) + (bytevector-u32-set! bv 20 EV_CURRENT byte-order) + (bytevector-u32-set! bv 24 entry byte-order) + (bytevector-u32-set! bv 28 phoff byte-order) + (bytevector-u32-set! bv 32 shoff byte-order) + (bytevector-u32-set! bv 36 flags byte-order) + (bytevector-u16-set! bv 40 ehsize byte-order) + (bytevector-u16-set! bv 42 phentsize byte-order) + (bytevector-u16-set! bv 44 phnum byte-order) + (bytevector-u16-set! bv 46 shentsize byte-order) + (bytevector-u16-set! bv 48 shnum byte-order) + (bytevector-u16-set! bv 50 shstrndx byte-order)) + +(define (parse-elf64 bv byte-order) + (make-elf bv 8 byte-order + (bytevector-u8-ref bv 7) + (bytevector-u16-ref bv 16 byte-order) + (bytevector-u16-ref bv 18 byte-order) + (bytevector-u64-ref bv 24 byte-order) + (bytevector-u64-ref bv 32 byte-order) + (bytevector-u64-ref bv 40 byte-order) + (bytevector-u32-ref bv 48 byte-order) + (bytevector-u16-ref bv 52 byte-order) + (bytevector-u16-ref bv 54 byte-order) + (bytevector-u16-ref bv 56 byte-order) + (bytevector-u16-ref bv 58 byte-order) + (bytevector-u16-ref bv 60 byte-order) + (bytevector-u16-ref bv 62 byte-order))) + +(define (write-elf64 bv byte-order abi type machine-type + entry phoff shoff flags ehsize phentsize phnum + shentsize shnum shstrndx) + (write-elf-ident bv ELFCLASS64 + (case byte-order + ((little) ELFDATA2LSB) + ((big) ELFDATA2MSB) + (else (error "unknown endianness" byte-order))) + abi) + (bytevector-u16-set! bv 16 type byte-order) + (bytevector-u16-set! bv 18 machine-type byte-order) + (bytevector-u32-set! bv 20 EV_CURRENT byte-order) + (bytevector-u64-set! bv 24 entry byte-order) + (bytevector-u64-set! bv 32 phoff byte-order) + (bytevector-u64-set! bv 40 shoff byte-order) + (bytevector-u32-set! bv 48 flags byte-order) + (bytevector-u16-set! bv 52 ehsize byte-order) + (bytevector-u16-set! bv 54 phentsize byte-order) + (bytevector-u16-set! bv 56 phnum byte-order) + (bytevector-u16-set! bv 58 shentsize byte-order) + (bytevector-u16-set! bv 60 shnum byte-order) + (bytevector-u16-set! bv 62 shstrndx byte-order)) + +(define (parse-elf bv) + (cond + ((has-elf-header? bv) + (let ((class (bytevector-u8-ref bv 4)) + (byte-order (let ((data (bytevector-u8-ref bv 5))) + (cond + ((= data ELFDATA2LSB) (endianness little)) + ((= data ELFDATA2MSB) (endianness big)) + (else (error "unhandled byte order" data)))))) + (cond + ((= class ELFCLASS32) (parse-elf32 bv byte-order)) + ((= class ELFCLASS64) (parse-elf64 bv byte-order)) + (else (error "unhandled class" class))))) + (else + (error "Invalid ELF" bv)))) + +(define* (write-elf-header bv #:key + (byte-order (target-endianness)) + (word-size (target-word-size)) + (abi ELFOSABI_STANDALONE) + (type ET_DYN) + (machine-type EM_NONE) + (entry 0) + (phoff (elf-header-len word-size)) + (shoff -1) + (flags 0) + (ehsize (elf-header-len word-size)) + (phentsize (elf-program-header-len word-size)) + (phnum 0) + (shentsize (elf-section-header-len word-size)) + (shnum 0) + (shstrndx SHN_UNDEF)) + ((case word-size + ((4) write-elf32) + ((8) write-elf64) + (else (error "unknown word size" word-size))) + bv byte-order abi type machine-type entry phoff shoff + flags ehsize phentsize phnum shentsize shnum shstrndx)) + +;; +;; Segment types +;; +(define PT_NULL 0) ; Program header table entry unused +(define PT_LOAD 1) ; Loadable program segment +(define PT_DYNAMIC 2) ; Dynamic linking information +(define PT_INTERP 3) ; Program interpreter +(define PT_NOTE 4) ; Auxiliary information +(define PT_SHLIB 5) ; Reserved +(define PT_PHDR 6) ; Entry for header table itself +(define PT_TLS 7) ; Thread-local storage segment +(define PT_NUM 8) ; Number of defined types +(define PT_LOOS #x60000000) ; Start of OS-specific +(define PT_GNU_EH_FRAME #x6474e550) ; GCC .eh_frame_hdr segment +(define PT_GNU_STACK #x6474e551) ; Indicates stack executability +(define PT_GNU_RELRO #x6474e552) ; Read-only after relocation + +;; +;; Segment flags +;; +(define PF_X (ash 1 0)) ; Segment is executable +(define PF_W (ash 1 1)) ; Segment is writable +(define PF_R (ash 1 2)) ; Segment is readable + +(define-record-type <elf-segment> + (make-elf-segment type offset vaddr paddr filesz memsz flags align) + elf-segment? + (type elf-segment-type) + (offset elf-segment-offset) + (vaddr elf-segment-vaddr) + (paddr elf-segment-paddr) + (filesz elf-segment-filesz) + (memsz elf-segment-memsz) + (flags elf-segment-flags) + (align elf-segment-align)) + +(define* (make-elf-segment* #:key (type PT_LOAD) (offset 0) (vaddr 0) + (paddr 0) (filesz 0) (memsz filesz) + (flags (logior PF_W PF_R)) + (align 8)) + (make-elf-segment type offset vaddr paddr filesz memsz flags align)) + +;; typedef struct { +;; uint32_t p_type; +;; Elf32_Off p_offset; +;; Elf32_Addr p_vaddr; +;; Elf32_Addr p_paddr; +;; uint32_t p_filesz; +;; uint32_t p_memsz; +;; uint32_t p_flags; +;; uint32_t p_align; +;; } Elf32_Phdr; + +(define (parse-elf32-program-header bv offset byte-order) + (if (<= (+ offset 32) (bytevector-length bv)) + (make-elf-segment (bytevector-u32-ref bv offset byte-order) + (bytevector-u32-ref bv (+ offset 4) byte-order) + (bytevector-u32-ref bv (+ offset 8) byte-order) + (bytevector-u32-ref bv (+ offset 12) byte-order) + (bytevector-u32-ref bv (+ offset 16) byte-order) + (bytevector-u32-ref bv (+ offset 20) byte-order) + (bytevector-u32-ref bv (+ offset 24) byte-order) + (bytevector-u32-ref bv (+ offset 28) byte-order)) + (error "corrupt ELF (offset out of range)" offset))) + +(define (write-elf32-program-header bv offset byte-order seg) + (bytevector-u32-set! bv offset (elf-segment-type seg) byte-order) + (bytevector-u32-set! bv (+ offset 4) (elf-segment-offset seg) byte-order) + (bytevector-u32-set! bv (+ offset 8) (elf-segment-vaddr seg) byte-order) + (bytevector-u32-set! bv (+ offset 12) (elf-segment-paddr seg) byte-order) + (bytevector-u32-set! bv (+ offset 16) (elf-segment-filesz seg) byte-order) + (bytevector-u32-set! bv (+ offset 20) (elf-segment-memsz seg) byte-order) + (bytevector-u32-set! bv (+ offset 24) (elf-segment-flags seg) byte-order) + (bytevector-u32-set! bv (+ offset 28) (elf-segment-align seg) byte-order)) + + +;; typedef struct { +;; uint32_t p_type; +;; uint32_t p_flags; +;; Elf64_Off p_offset; +;; Elf64_Addr p_vaddr; +;; Elf64_Addr p_paddr; +;; uint64_t p_filesz; +;; uint64_t p_memsz; +;; uint64_t p_align; +;; } Elf64_Phdr; + +;; NB: position of `flags' is different! + +(define (parse-elf64-program-header bv offset byte-order) + (if (<= (+ offset 56) (bytevector-length bv)) + (make-elf-segment (bytevector-u32-ref bv offset byte-order) + (bytevector-u64-ref bv (+ offset 8) byte-order) + (bytevector-u64-ref bv (+ offset 16) byte-order) + (bytevector-u64-ref bv (+ offset 24) byte-order) + (bytevector-u64-ref bv (+ offset 32) byte-order) + (bytevector-u64-ref bv (+ offset 40) byte-order) + (bytevector-u32-ref bv (+ offset 4) byte-order) + (bytevector-u64-ref bv (+ offset 48) byte-order)) + (error "corrupt ELF (offset out of range)" offset))) + +(define (write-elf64-program-header bv offset byte-order seg) + (bytevector-u32-set! bv offset (elf-segment-type seg) byte-order) + (bytevector-u64-set! bv (+ offset 8) (elf-segment-offset seg) byte-order) + (bytevector-u64-set! bv (+ offset 16) (elf-segment-vaddr seg) byte-order) + (bytevector-u64-set! bv (+ offset 24) (elf-segment-paddr seg) byte-order) + (bytevector-u64-set! bv (+ offset 32) (elf-segment-filesz seg) byte-order) + (bytevector-u64-set! bv (+ offset 40) (elf-segment-memsz seg) byte-order) + (bytevector-u32-set! bv (+ offset 4) (elf-segment-flags seg) byte-order) + (bytevector-u64-set! bv (+ offset 48) (elf-segment-align seg) byte-order)) + +(define (write-elf-program-header bv offset byte-order word-size seg) + ((case word-size + ((4) write-elf32-program-header) + ((8) write-elf64-program-header) + (else (error "invalid word size" word-size))) + bv offset byte-order seg)) + +(define (elf-program-header-len word-size) + (case word-size + ((4) 32) + ((8) 56) + (else (error "bad word size" word-size)))) + +(define (elf-segment elf n) + (if (not (< -1 n (elf-phnum elf))) + (error "bad segment number" n)) + ((case (elf-word-size elf) + ((4) parse-elf32-program-header) + ((8) parse-elf64-program-header) + (else (error "unhandled pointer size"))) + (elf-bytes elf) + (+ (elf-phoff elf) (* n (elf-phentsize elf))) + (elf-byte-order elf))) + +(define (elf-segments elf) + (let lp ((n (elf-phnum elf)) (out '())) + (if (zero? n) + out + (lp (1- n) (cons (elf-segment elf (1- n)) out))))) + +(define-record-type <elf-section> + (make-elf-section name type flags addr offset size link info addralign entsize) + elf-section? + (name elf-section-name) + (type elf-section-type) + (flags elf-section-flags) + (addr elf-section-addr) + (offset elf-section-offset) + (size elf-section-size) + (link elf-section-link) + (info elf-section-info) + (addralign elf-section-addralign) + (entsize elf-section-entsize)) + +(define* (make-elf-section* #:key (name 0) (type SHT_PROGBITS) + (flags SHF_ALLOC) (addr 0) (offset 0) (size 0) + (link 0) (info 0) (addralign 8) (entsize 0)) + (make-elf-section name type flags addr offset size link info addralign + entsize)) + +;; typedef struct { +;; uint32_t sh_name; +;; uint32_t sh_type; +;; uint32_t sh_flags; +;; Elf32_Addr sh_addr; +;; Elf32_Off sh_offset; +;; uint32_t sh_size; +;; uint32_t sh_link; +;; uint32_t sh_info; +;; uint32_t sh_addralign; +;; uint32_t sh_entsize; +;; } Elf32_Shdr; + +(define (parse-elf32-section-header bv offset byte-order) + (if (<= (+ offset 40) (bytevector-length bv)) + (make-elf-section (bytevector-u32-ref bv offset byte-order) + (bytevector-u32-ref bv (+ offset 4) byte-order) + (bytevector-u32-ref bv (+ offset 8) byte-order) + (bytevector-u32-ref bv (+ offset 12) byte-order) + (bytevector-u32-ref bv (+ offset 16) byte-order) + (bytevector-u32-ref bv (+ offset 20) byte-order) + (bytevector-u32-ref bv (+ offset 24) byte-order) + (bytevector-u32-ref bv (+ offset 28) byte-order) + (bytevector-u32-ref bv (+ offset 32) byte-order) + (bytevector-u32-ref bv (+ offset 36) byte-order)) + (error "corrupt ELF (offset out of range)" offset))) + +(define (write-elf32-section-header bv offset byte-order sec) + (bytevector-u32-set! bv offset (elf-section-name sec) byte-order) + (bytevector-u32-set! bv (+ offset 4) (elf-section-type sec) byte-order) + (bytevector-u32-set! bv (+ offset 8) (elf-section-flags sec) byte-order) + (bytevector-u32-set! bv (+ offset 12) (elf-section-addr sec) byte-order) + (bytevector-u32-set! bv (+ offset 16) (elf-section-offset sec) byte-order) + (bytevector-u32-set! bv (+ offset 20) (elf-section-size sec) byte-order) + (bytevector-u32-set! bv (+ offset 24) (elf-section-link sec) byte-order) + (bytevector-u32-set! bv (+ offset 28) (elf-section-info sec) byte-order) + (bytevector-u32-set! bv (+ offset 32) (elf-section-addralign sec) byte-order) + (bytevector-u32-set! bv (+ offset 36) (elf-section-entsize sec) byte-order)) + + +;; typedef struct { +;; uint32_t sh_name; +;; uint32_t sh_type; +;; uint64_t sh_flags; +;; Elf64_Addr sh_addr; +;; Elf64_Off sh_offset; +;; uint64_t sh_size; +;; uint32_t sh_link; +;; uint32_t sh_info; +;; uint64_t sh_addralign; +;; uint64_t sh_entsize; +;; } Elf64_Shdr; + +(define (elf-section-header-len word-size) + (case word-size + ((4) 40) + ((8) 64) + (else (error "bad word size" word-size)))) + +(define (parse-elf64-section-header bv offset byte-order) + (if (<= (+ offset 64) (bytevector-length bv)) + (make-elf-section (bytevector-u32-ref bv offset byte-order) + (bytevector-u32-ref bv (+ offset 4) byte-order) + (bytevector-u64-ref bv (+ offset 8) byte-order) + (bytevector-u64-ref bv (+ offset 16) byte-order) + (bytevector-u64-ref bv (+ offset 24) byte-order) + (bytevector-u64-ref bv (+ offset 32) byte-order) + (bytevector-u32-ref bv (+ offset 40) byte-order) + (bytevector-u32-ref bv (+ offset 44) byte-order) + (bytevector-u64-ref bv (+ offset 48) byte-order) + (bytevector-u64-ref bv (+ offset 56) byte-order)) + (error "corrupt ELF (offset out of range)" offset))) + +(define (write-elf64-section-header bv offset byte-order sec) + (bytevector-u32-set! bv offset (elf-section-name sec) byte-order) + (bytevector-u32-set! bv (+ offset 4) (elf-section-type sec) byte-order) + (bytevector-u64-set! bv (+ offset 8) (elf-section-flags sec) byte-order) + (bytevector-u64-set! bv (+ offset 16) (elf-section-addr sec) byte-order) + (bytevector-u64-set! bv (+ offset 24) (elf-section-offset sec) byte-order) + (bytevector-u64-set! bv (+ offset 32) (elf-section-size sec) byte-order) + (bytevector-u32-set! bv (+ offset 40) (elf-section-link sec) byte-order) + (bytevector-u32-set! bv (+ offset 44) (elf-section-info sec) byte-order) + (bytevector-u64-set! bv (+ offset 48) (elf-section-addralign sec) byte-order) + (bytevector-u64-set! bv (+ offset 56) (elf-section-entsize sec) byte-order)) + +(define (elf-section elf n) + (if (not (< -1 n (elf-shnum elf))) + (error "bad section number" n)) + ((case (elf-word-size elf) + ((4) parse-elf32-section-header) + ((8) parse-elf64-section-header) + (else (error "unhandled pointer size"))) + (elf-bytes elf) + (+ (elf-shoff elf) (* n (elf-shentsize elf))) + (elf-byte-order elf))) + +(define (write-elf-section-header bv offset byte-order word-size sec) + ((case word-size + ((4) write-elf32-section-header) + ((8) write-elf64-section-header) + (else (error "invalid word size" word-size))) + bv offset byte-order sec)) + +(define (elf-sections elf) + (let lp ((n (elf-shnum elf)) (out '())) + (if (zero? n) + out + (lp (1- n) (cons (elf-section elf (1- n)) out))))) + +;; +;; Section Types +;; +(define SHT_NULL 0) ; Section header table entry unused +(define SHT_PROGBITS 1) ; Program data +(define SHT_SYMTAB 2) ; Symbol table +(define SHT_STRTAB 3) ; String table +(define SHT_RELA 4) ; Relocation entries with addends +(define SHT_HASH 5) ; Symbol hash table +(define SHT_DYNAMIC 6) ; Dynamic linking information +(define SHT_NOTE 7) ; Notes +(define SHT_NOBITS 8) ; Program space with no data (bss) +(define SHT_REL 9) ; Relocation entries, no addends +(define SHT_SHLIB 10) ; Reserved +(define SHT_DYNSYM 11) ; Dynamic linker symbol table +(define SHT_INIT_ARRAY 14) ; Array of constructors +(define SHT_FINI_ARRAY 15) ; Array of destructors +(define SHT_PREINIT_ARRAY 16) ; Array of pre-constructors +(define SHT_GROUP 17) ; Section group +(define SHT_SYMTAB_SHNDX 18) ; Extended section indeces +(define SHT_NUM 19) ; Number of defined types. +(define SHT_LOOS #x60000000) ; Start OS-specific. +(define SHT_HIOS #x6fffffff) ; End OS-specific type +(define SHT_LOPROC #x70000000) ; Start of processor-specific +(define SHT_HIPROC #x7fffffff) ; End of processor-specific +(define SHT_LOUSER #x80000000) ; Start of application-specific +(define SHT_HIUSER #x8fffffff) ; End of application-specific + +;; +;; Section Flags +;; +(define SHF_WRITE (ash 1 0)) ; Writable +(define SHF_ALLOC (ash 1 1)) ; Occupies memory during execution +(define SHF_EXECINSTR (ash 1 2)) ; Executable +(define SHF_MERGE (ash 1 4)) ; Might be merged +(define SHF_STRINGS (ash 1 5)) ; Contains nul-terminated strings +(define SHF_INFO_LINK (ash 1 6)) ; `sh_info' contains SHT index +(define SHF_LINK_ORDER (ash 1 7)) ; Preserve order after combining +(define SHF_OS_NONCONFORMING (ash 1 8)) ; Non-standard OS specific handling required +(define SHF_GROUP (ash 1 9)) ; Section is member of a group. +(define SHF_TLS (ash 1 10)) ; Section hold thread-local data. + +;; +;; Dynamic entry types. The DT_GUILE types are non-standard. +;; +(define DT_NULL 0) ; Marks end of dynamic section +(define DT_NEEDED 1) ; Name of needed library +(define DT_PLTRELSZ 2) ; Size in bytes of PLT relocs +(define DT_PLTGOT 3) ; Processor defined value +(define DT_HASH 4) ; Address of symbol hash table +(define DT_STRTAB 5) ; Address of string table +(define DT_SYMTAB 6) ; Address of symbol table +(define DT_RELA 7) ; Address of Rela relocs +(define DT_RELASZ 8) ; Total size of Rela relocs +(define DT_RELAENT 9) ; Size of one Rela reloc +(define DT_STRSZ 10) ; Size of string table +(define DT_SYMENT 11) ; Size of one symbol table entry +(define DT_INIT 12) ; Address of init function +(define DT_FINI 13) ; Address of termination function +(define DT_SONAME 14) ; Name of shared object +(define DT_RPATH 15) ; Library search path (deprecated) +(define DT_SYMBOLIC 16) ; Start symbol search here +(define DT_REL 17) ; Address of Rel relocs +(define DT_RELSZ 18) ; Total size of Rel relocs +(define DT_RELENT 19) ; Size of one Rel reloc +(define DT_PLTREL 20) ; Type of reloc in PLT +(define DT_DEBUG 21) ; For debugging ; unspecified +(define DT_TEXTREL 22) ; Reloc might modify .text +(define DT_JMPREL 23) ; Address of PLT relocs +(define DT_BIND_NOW 24) ; Process relocations of object +(define DT_INIT_ARRAY 25) ; Array with addresses of init fct +(define DT_FINI_ARRAY 26) ; Array with addresses of fini fct +(define DT_INIT_ARRAYSZ 27) ; Size in bytes of DT_INIT_ARRAY +(define DT_FINI_ARRAYSZ 28) ; Size in bytes of DT_FINI_ARRAY +(define DT_RUNPATH 29) ; Library search path +(define DT_FLAGS 30) ; Flags for the object being loaded +(define DT_ENCODING 32) ; Start of encoded range +(define DT_PREINIT_ARRAY 32) ; Array with addresses of preinit fc +(define DT_PREINIT_ARRAYSZ 33) ; size in bytes of DT_PREINIT_ARRAY +(define DT_NUM 34) ; Number used +(define DT_LOGUILE #x37146000) ; Start of Guile-specific +(define DT_GUILE_GC_ROOT #x37146000) ; Offset of GC roots +(define DT_GUILE_GC_ROOT_SZ #x37146001) ; Size in machine words of GC roots +(define DT_GUILE_ENTRY #x37146002) ; Address of entry thunk +(define DT_GUILE_RTL_VERSION #x37146003); Bytecode version +(define DT_HIGUILE #x37146fff) ; End of Guile-specific +(define DT_LOOS #x6000000d) ; Start of OS-specific +(define DT_HIOS #x6ffff000) ; End of OS-specific +(define DT_LOPROC #x70000000) ; Start of processor-specific +(define DT_HIPROC #x7fffffff) ; End of processor-specific + + +(define (string-table-ref bv offset) + (let lp ((end offset)) + (if (zero? (bytevector-u8-ref bv end)) + (let ((out (make-bytevector (- end offset)))) + (bytevector-copy! bv offset out 0 (- end offset)) + (utf8->string out)) + (lp (1+ end))))) + +(define (elf-sections-by-name elf) + (let* ((sections (elf-sections elf)) + (off (elf-section-offset (list-ref sections (elf-shstrndx elf))))) + (map (lambda (section) + (cons (string-table-ref (elf-bytes elf) + (+ off (elf-section-name section))) + section)) + sections))) + +(define-record-type <elf-symbol> + (make-elf-symbol name value size info other shndx) + elf-symbol? + (name elf-symbol-name) + (value elf-symbol-value) + (size elf-symbol-size) + (info elf-symbol-info) + (other elf-symbol-other) + (shndx elf-symbol-shndx)) + +;; typedef struct { +;; uint32_t st_name; +;; Elf32_Addr st_value; +;; uint32_t st_size; +;; unsigned char st_info; +;; unsigned char st_other; +;; uint16_t st_shndx; +;; } Elf32_Sym; + +(define (parse-elf32-symbol bv offset stroff byte-order) + (if (<= (+ offset 16) (bytevector-length bv)) + (make-elf-symbol (let ((name (bytevector-u32-ref bv offset byte-order))) + (if stroff + (string-table-ref bv (+ stroff name)) + name)) + (bytevector-u32-ref bv (+ offset 4) byte-order) + (bytevector-u32-ref bv (+ offset 8) byte-order) + (bytevector-u8-ref bv (+ offset 12)) + (bytevector-u8-ref bv (+ offset 13)) + (bytevector-u16-ref bv (+ offset 14) byte-order)) + (error "corrupt ELF (offset out of range)" offset))) + +;; typedef struct { +;; uint32_t st_name; +;; unsigned char st_info; +;; unsigned char st_other; +;; uint16_t st_shndx; +;; Elf64_Addr st_value; +;; uint64_t st_size; +;; } Elf64_Sym; + +(define (parse-elf64-symbol bv offset stroff byte-order) + (if (<= (+ offset 24) (bytevector-length bv)) + (make-elf-symbol (let ((name (bytevector-u32-ref bv offset byte-order))) + (if stroff + (string-table-ref bv (+ stroff name)) + name)) + (bytevector-u64-ref bv (+ offset 8) byte-order) + (bytevector-u64-ref bv (+ offset 16) byte-order) + (bytevector-u8-ref bv (+ offset 4)) + (bytevector-u8-ref bv (+ offset 5)) + (bytevector-u16-ref bv (+ offset 6) byte-order)) + (error "corrupt ELF (offset out of range)" offset))) + +(define* (elf-symbol-table-ref elf section n #:optional strtab) + (let ((bv (elf-bytes elf)) + (byte-order (elf-byte-order elf)) + (stroff (and strtab (elf-section-offset strtab))) + (base (elf-section-offset section)) + (len (elf-section-size section)) + (entsize (elf-section-entsize section))) + (unless (<= (* (1+ n) entsize) len) + (error "out of range symbol table access" section n)) + (case (elf-word-size elf) + ((4) + (unless (<= 16 entsize) + (error "bad entsize for symbol table" section)) + (parse-elf32-symbol bv (+ base (* n entsize)) stroff byte-order)) + ((8) + (unless (<= 24 entsize) + (error "bad entsize for symbol table" section)) + (parse-elf64-symbol bv (+ base (* n entsize)) stroff byte-order)) + (else (error "bad word size" elf))))) + +;; Legal values for ST_BIND subfield of st_info (symbol binding). + +(define STB_LOCAL 0) ; Local symbol +(define STB_GLOBAL 1) ; Global symbol +(define STB_WEAK 2) ; Weak symbol +(define STB_NUM 3) ; Number of defined types. +(define STB_LOOS 10) ; Start of OS-specific +(define STB_GNU_UNIQUE 10) ; Unique symbol. +(define STB_HIOS 12) ; End of OS-specific +(define STB_LOPROC 13) ; Start of processor-specific +(define STB_HIPROC 15) ; End of processor-specific + +;; Legal values for ST_TYPE subfield of st_info (symbol type). + +(define STT_NOTYPE 0) ; Symbol type is unspecified +(define STT_OBJECT 1) ; Symbol is a data object +(define STT_FUNC 2) ; Symbol is a code object +(define STT_SECTION 3) ; Symbol associated with a section +(define STT_FILE 4) ; Symbol's name is file name +(define STT_COMMON 5) ; Symbol is a common data object +(define STT_TLS 6) ; Symbol is thread-local data objec +(define STT_NUM 7) ; Number of defined types. +(define STT_LOOS 10) ; Start of OS-specific +(define STT_GNU_IFUNC 10) ; Symbol is indirect code object +(define STT_HIOS 12) ; End of OS-specific +(define STT_LOPROC 13) ; Start of processor-specific +(define STT_HIPROC 15) ; End of processor-specific + +;; Symbol visibility specification encoded in the st_other field. + +(define STV_DEFAULT 0) ; Default symbol visibility rules +(define STV_INTERNAL 1) ; Processor specific hidden class +(define STV_HIDDEN 2) ; Sym unavailable in other modules +(define STV_PROTECTED 3) ; Not preemptible, not exported + +(define (elf-symbol-binding sym) + (ash (elf-symbol-info sym) -4)) + +(define (elf-symbol-type sym) + (logand (elf-symbol-info sym) #xf)) + +(define (elf-symbol-visibility sym) + (logand (elf-symbol-other sym) #x3)) + +(define NT_GNU_ABI_TAG 1) +(define NT_GNU_HWCAP 2) +(define NT_GNU_BUILD_ID 3) +(define NT_GNU_GOLD_VERSION 4) + +(define-record-type <elf-note> + (make-elf-note name desc type) + elf-note? + (name elf-note-name) + (desc elf-note-desc) + (type elf-note-type)) + +(define (parse-elf-note elf section) + (let ((bv (elf-bytes elf)) + (byte-order (elf-byte-order elf)) + (offset (elf-section-offset section))) + (unless (<= (+ offset 12) (bytevector-length bv)) + (error "corrupt ELF (offset out of range)" offset)) + (let ((namesz (bytevector-u32-ref bv offset byte-order)) + (descsz (bytevector-u32-ref bv (+ offset 4) byte-order)) + (type (bytevector-u32-ref bv (+ offset 8) byte-order))) + (unless (<= (+ offset 12 namesz descsz) (bytevector-length bv)) + (error "corrupt ELF (offset out of range)" offset)) + (let ((name (make-bytevector (1- namesz))) + (desc (make-bytevector descsz))) + (bytevector-copy! bv (+ offset 12) name 0 (1- namesz)) + (bytevector-copy! bv (+ offset 12 namesz) desc 0 descsz) + (make-elf-note (utf8->string name) desc type))))) + + + + +;;; +;;; All of that was the parser. Now, on to a linker. +;;; + +;; A relocation records a reference to a symbol. When the symbol is +;; resolved to an address, the reloc location will be updated to point +;; to the address. +;; +;; Two types. Abs32/1 and Abs64/1 are absolute offsets in bytes. +;; Rel32/4 is a relative signed offset in 32-bit units. Either can have +;; an arbitrary addend as well. +;; +(define-record-type <reloc> + (make-reloc type loc addend symbol) + reloc? + (type reloc-type) ;; rel32/4, abs32/1, abs64/1 + (loc reloc-loc) + (addend reloc-addend) + (symbol reloc-symbol)) + +;; A symbol is an association between a name and an address. The +;; address is always in regard to some particular address space. When +;; objects come into the linker, their symbols live in the object +;; address space. When the objects are allocated into ELF segments, the +;; symbols will be relocated into memory address space, corresponding to +;; the position the ELF will be loaded at. +;; +(define-record-type <symbol> + (make-symbol name address) + symbol? + (name symbol-name) + (address symbol-address)) + +(define-record-type <object> + (make-object section bv relocs symbols) + object? + (section object-section) + (bv object-bv) + (relocs object-relocs) + (symbols object-symbols)) + +(define (make-string-table) + '(("" 0 #vu8()))) + +(define (string-table-length table) + (let ((last (car table))) + ;; The + 1 is for the trailing NUL byte. + (+ (cadr last) (bytevector-length (caddr last)) 1))) + +(define (string-table-intern table str) + (cond + ((assoc str table) + => (lambda (ent) + (values table (cadr ent)))) + (else + (let* ((next (string-table-length table))) + (values (cons (list str next (string->utf8 str)) + table) + next))))) + +(define (link-string-table table) + (let ((out (make-bytevector (string-table-length table) 0))) + (for-each + (lambda (ent) + (let ((bytes (caddr ent))) + (bytevector-copy! bytes 0 out (cadr ent) (bytevector-length bytes)))) + table) + out)) + +(define (segment-kind section) + (let ((flags (elf-section-flags section))) + (cons (cond + ((= (elf-section-type section) SHT_DYNAMIC) PT_DYNAMIC) + ((zero? (logand SHF_ALLOC flags)) PT_NOTE) + (else PT_LOAD)) + (logior (if (zero? (logand SHF_ALLOC flags)) + 0 + PF_R) + (if (zero? (logand SHF_EXECINSTR flags)) + 0 + PF_X) + (if (zero? (logand SHF_WRITE flags)) + 0 + PF_W))))) + +(define (group-by-cars ls) + (let lp ((in ls) (k #f) (group #f) (out '())) + (cond + ((null? in) + (reverse! + (if group + (cons (cons k (reverse! group)) out) + out))) + ((and group (equal? k (caar in))) + (lp (cdr in) k (cons (cdar in) group) out)) + (else + (lp (cdr in) (caar in) (list (cdar in)) + (if group + (cons (cons k (reverse! group)) out) + out)))))) + +(define (collate-objects-into-segments objects) + (group-by-cars + (stable-sort! + (map (lambda (o) + (cons (segment-kind (object-section o)) o)) + objects) + (lambda (x y) + (let ((x-type (caar x)) (y-type (caar y)) + (x-flags (cdar x)) (y-flags (cdar y)) + (x-section (object-section (cdr x))) + (y-section (object-section (cdr y)))) + (cond + ((not (equal? x-flags y-flags)) + (< x-flags y-flags)) + ((not (equal? x-type y-type)) + (< x-type y-type)) + ((not (equal? (elf-section-type x-section) + (elf-section-type y-section))) + (cond + ((equal? (elf-section-type x-section) SHT_NOBITS) #t) + ((equal? (elf-section-type y-section) SHT_NOBITS) #f) + (else (< (elf-section-type x-section) + (elf-section-type y-section))))) + (else + (< (elf-section-size x-section) + (elf-section-size y-section))))))))) + +(define (align address alignment) + (+ address + (modulo (- alignment (modulo address alignment)) alignment))) + +(define (fold1 proc ls s0) + (let lp ((ls ls) (s0 s0)) + (if (null? ls) + s0 + (lp (cdr ls) (proc (car ls) s0))))) + +(define (fold2 proc ls s0 s1) + (let lp ((ls ls) (s0 s0) (s1 s1)) + (if (null? ls) + (values s0 s1) + (receive (s0 s1) (proc (car ls) s0 s1) + (lp (cdr ls) s0 s1))))) + +(define (fold4 proc ls s0 s1 s2 s3) + (let lp ((ls ls) (s0 s0) (s1 s1) (s2 s2) (s3 s3)) + (if (null? ls) + (values s0 s1 s2 s3) + (receive (s0 s1 s2 s3) (proc (car ls) s0 s1 s2 s3) + (lp (cdr ls) s0 s1 s2 s3))))) + +(define (fold5 proc ls s0 s1 s2 s3 s4) + (let lp ((ls ls) (s0 s0) (s1 s1) (s2 s2) (s3 s3) (s4 s4)) + (if (null? ls) + (values s0 s1 s2 s3 s4) + (receive (s0 s1 s2 s3 s4) (proc (car ls) s0 s1 s2 s3 s4) + (lp (cdr ls) s0 s1 s2 s3 s4))))) + +(define (relocate-section-header sec fileaddr memaddr) + (make-elf-section (elf-section-name sec) (elf-section-type sec) + (elf-section-flags sec) memaddr + fileaddr (elf-section-size sec) + (elf-section-link sec) (elf-section-info sec) + (elf-section-addralign sec) (elf-section-entsize sec))) + +(define *page-size* 4096) + +;; Adds object symbols to global table, relocating them from object +;; address space to memory address space. +(define (add-symbols symbols offset symtab) + (fold1 (lambda (symbol symtab) + (let ((name (symbol-name symbol)) + (addr (symbol-address symbol))) + (vhash-consq name (make-symbol name (+ addr offset)) symtab))) + symbols + symtab)) + +(define (alloc-segment type flags objects fileaddr memaddr symtab alignment) + (let* ((loadable? (not (zero? flags))) + (alignment (fold1 (lambda (o alignment) + (lcm (elf-section-addralign (object-section o)) + alignment)) + objects + alignment)) + (fileaddr (align fileaddr alignment)) + (memaddr (align memaddr alignment))) + (receive (objects fileend memend symtab) + (fold4 (lambda (o out fileaddr memaddr symtab) + (let* ((section (object-section o)) + (fileaddr + (if (= (elf-section-type section) SHT_NOBITS) + fileaddr + (align fileaddr (elf-section-addralign section)))) + (memaddr + (align memaddr (elf-section-addralign section)))) + (values + (cons (make-object (relocate-section-header section fileaddr + memaddr) + (object-bv o) + (object-relocs o) + (object-symbols o)) + out) + (if (= (elf-section-type section) SHT_NOBITS) + fileaddr + (+ fileaddr (elf-section-size section))) + (+ memaddr (elf-section-size section)) + (add-symbols (object-symbols o) memaddr symtab)))) + objects '() fileaddr memaddr symtab) + (values + (make-elf-segment* #:type type #:offset fileaddr + #:vaddr (if loadable? memaddr 0) + #:filesz (- fileend fileaddr) + #:memsz (if loadable? (- memend memaddr) 0) + #:flags flags #:align alignment) + (reverse objects) + symtab)))) + +(define (process-reloc reloc bv file-offset mem-offset symtab endianness) + (let ((ent (vhash-assq (reloc-symbol reloc) symtab))) + (unless ent + (error "Undefined symbol" (reloc-symbol reloc))) + (let* ((file-loc (+ (reloc-loc reloc) file-offset)) + (mem-loc (+ (reloc-loc reloc) mem-offset)) + (addr (symbol-address (cdr ent)))) + (case (reloc-type reloc) + ((rel32/4) + (let ((diff (- addr mem-loc))) + (unless (zero? (modulo diff 4)) + (error "Bad offset" reloc symbol mem-offset)) + (bytevector-s32-set! bv file-loc + (+ (/ diff 4) (reloc-addend reloc)) + endianness))) + ((abs32/1) + (bytevector-u32-set! bv file-loc addr endianness)) + ((abs64/1) + (bytevector-u64-set! bv file-loc addr endianness)) + (else + (error "bad reloc type" reloc)))))) + +(define (write-object bv o symtab endianness) + (let* ((section (object-section o)) + (offset (elf-section-offset section)) + (addr (elf-section-addr section)) + (len (elf-section-size section)) + (bytes (object-bv o)) + (relocs (object-relocs o))) + (if (not (= (elf-section-type section) SHT_NOBITS)) + (begin + (if (not (= (elf-section-size section) (bytevector-length bytes))) + (error "unexpected length" section bytes)) + (bytevector-copy! bytes 0 bv offset len) + (for-each (lambda (reloc) + (process-reloc reloc bv offset addr symtab endianness)) + relocs))))) + +(define (compute-sections-by-name seglists) + (let lp ((in (apply append (map cdr seglists))) + (n 1) (out '()) (shstrtab #f)) + (if (null? in) + (fold1 (lambda (x tail) + (cond + ((false-if-exception + (string-table-ref shstrtab (car x))) + => (lambda (str) (acons str (cdr x) tail))) + (else tail))) + out '()) + (let* ((section (object-section (car in))) + (bv (object-bv (car in))) + (name (elf-section-name section))) + (lp (cdr in) (1+ n) (acons name n out) + (or shstrtab + (and (= (elf-section-type section) SHT_STRTAB) + (equal? (false-if-exception + (string-table-ref bv name)) + ".shstrtab") + bv))))))) + +;; Given a list of section-header/bytevector pairs, collate the sections +;; into segments, allocate the segments, allocate the ELF bytevector, +;; and write the segments into the bytevector, relocating as we go. +;; +(define* (link-elf objects #:key + (page-aligned? #t) + (endianness (target-endianness)) + (word-size (target-word-size))) + (let* ((seglists (collate-objects-into-segments objects)) + (sections-by-name (compute-sections-by-name seglists)) + (nsegments (length seglists)) + (nsections (1+ (length objects))) ;; 1+ for the first reserved entry. + (program-headers-offset (elf-header-len word-size)) + (fileaddr (+ program-headers-offset + (* nsegments (elf-program-header-len word-size)))) + (memaddr 0)) + (receive (out fileend memend symtab _) + (fold5 + (lambda (x out fileaddr memaddr symtab prev-flags) + (let ((type (caar x)) + (flags (cdar x)) + (objects (cdr x))) + (receive (segment objects symtab) + (alloc-segment type flags objects fileaddr memaddr symtab + (if (and page-aligned? + (not (= flags prev-flags))) + *page-size* + 8)) + (values + (cons (cons segment objects) out) + (+ (elf-segment-offset segment) (elf-segment-filesz segment)) + (if (zero? (elf-segment-memsz segment)) + memaddr + (+ (elf-segment-vaddr segment) + (elf-segment-memsz segment))) + symtab + flags)))) + seglists '() fileaddr memaddr vlist-null 0) + (let* ((out (reverse! out)) + (section-table-offset (+ (align fileend word-size))) + (fileend (+ section-table-offset + (* nsections (elf-section-header-len word-size)))) + (bv (make-bytevector fileend 0))) + (write-elf-header bv #:byte-order endianness #:word-size word-size + #:phoff program-headers-offset #:phnum nsegments + #:shoff section-table-offset #:shnum nsections + #:shstrndx (or (assoc-ref sections-by-name ".shstrtab") + SHN_UNDEF)) + (write-elf-section-header bv section-table-offset + endianness word-size + (make-elf-section* #:type SHT_NULL #:flags 0 + #:addralign 0)) + (fold2 (lambda (x phidx shidx) + (write-elf-program-header + bv (+ program-headers-offset + (* (elf-program-header-len word-size) phidx)) + endianness word-size (car x)) + (values + (1+ phidx) + (fold1 (lambda (o shidx) + (write-object bv o symtab endianness) + (write-elf-section-header + bv (+ section-table-offset + (* (elf-section-header-len word-size) shidx)) + endianness word-size (object-section o)) + (1+ shidx)) + (cdr x) shidx))) + out 0 1) + bv)))) diff --git a/module/system/vm/objcode.scm b/module/system/vm/objcode.scm index 966f34585..f939a5551 100644 --- a/module/system/vm/objcode.scm +++ b/module/system/vm/objcode.scm @@ -1,6 +1,6 @@ ;;; Guile VM object code -;; Copyright (C) 2001, 2010 Free Software Foundation, Inc. +;; Copyright (C) 2001, 2010, 2012 Free Software Foundation, Inc. ;;; This library is free software; you can redistribute it and/or ;;; modify it under the terms of the GNU Lesser General Public @@ -21,7 +21,7 @@ (define-module (system vm objcode) #:export (objcode? objcode-meta bytecode->objcode objcode->bytecode - load-objcode write-objcode + load-thunk-from-file load-thunk-from-memory word-size byte-order)) (load-extension (string-append "libguile-" (effective-version)) diff --git a/module/web/server.scm b/module/web/server.scm index 54ab9e335..affc2e6b6 100644 --- a/module/web/server.scm +++ b/module/web/server.scm @@ -164,11 +164,13 @@ values." #:post-error (lambda _ (values #f #f #f)))) (define (extend-response r k v . additional) + (define (extend-alist alist k v) + (let ((pair (assq k alist))) + (acons k v (if pair (delq pair alist) alist)))) (let ((r (build-response #:version (response-version r) #:code (response-code r) #:headers - (assoc-set! (copy-tree (response-headers r)) - k v) + (extend-alist (response-headers r) k v) #:port (response-port r)))) (if (null? additional) r diff --git a/test-suite/Makefile.am b/test-suite/Makefile.am index 9fba7b8b3..b1e90bac3 100644 --- a/test-suite/Makefile.am +++ b/test-suite/Makefile.am @@ -78,6 +78,7 @@ SCM_TESTS = tests/00-initial-env.test \ tests/optargs.test \ tests/options.test \ tests/parameters.test \ + tests/peg.test \ tests/peval.test \ tests/print.test \ tests/procprop.test \ diff --git a/test-suite/standalone/test-num2integral.c b/test-suite/standalone/test-num2integral.c index 0246a3303..c8dc3a7e4 100644 --- a/test-suite/standalone/test-num2integral.c +++ b/test-suite/standalone/test-num2integral.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1999, 2000, 2001, 2003, 2004, 2006, 2008, 2010, +/* Copyright (C) 1999, 2000, 2001, 2003, 2004, 2006, 2008, 2010, 2011 * 2012 Free Software Foundation, Inc. * * This library is free software; you can redistribute it and/or @@ -25,6 +25,7 @@ #include <stdio.h> #include <assert.h> +#include <limits.h> SCM out_of_range_handler (void *data, SCM key, SCM args); SCM call_num2long_long_body (void *data); @@ -56,14 +57,14 @@ static void test_long_long () { { - SCM n = scm_from_long_long (SCM_I_LLONG_MIN); + SCM n = scm_from_long_long (LLONG_MIN); long long result = scm_to_long_long(n); - assert (result == SCM_I_LLONG_MIN); + assert (result == LLONG_MIN); } /* LLONG_MIN - 1 */ { - SCM n = scm_difference (scm_from_long_long (SCM_I_LLONG_MIN), scm_from_int (1)); + SCM n = scm_difference (scm_from_long_long (LLONG_MIN), scm_from_int (1)); SCM caught = scm_internal_catch (SCM_BOOL_T, call_num2long_long_body, &n, out_of_range_handler, NULL); assert (scm_is_true (caught)); @@ -71,8 +72,8 @@ test_long_long () /* SCM_I_LLONG_MIN + SCM_I_LLONG_MIN/2 */ { - SCM n = scm_sum (scm_from_long_long (SCM_I_LLONG_MIN), - scm_from_long_long (SCM_I_LLONG_MIN / 2)); + SCM n = scm_sum (scm_from_long_long (LLONG_MIN), + scm_from_long_long (LLONG_MIN / 2)); SCM caught = scm_internal_catch (SCM_BOOL_T, call_num2long_long_body, &n, out_of_range_handler, NULL); assert (scm_is_true (caught)); @@ -80,7 +81,7 @@ test_long_long () /* SCM_I_LLONG_MAX + 1 */ { - SCM n = scm_sum (scm_from_long_long (SCM_I_LLONG_MAX), scm_from_int (1)); + SCM n = scm_sum (scm_from_long_long (LLONG_MAX), scm_from_int (1)); SCM caught = scm_internal_catch (SCM_BOOL_T, call_num2long_long_body, &n, out_of_range_handler, NULL); assert (scm_is_true (caught)); @@ -108,9 +109,9 @@ static void test_ulong_long () { { - SCM n = scm_from_ulong_long (SCM_I_ULLONG_MAX); + SCM n = scm_from_ulong_long (ULLONG_MAX); unsigned long long result = scm_to_ulong_long(n); - assert (result == SCM_I_ULLONG_MAX); + assert (result == ULLONG_MAX); } /* -1 */ @@ -123,7 +124,7 @@ test_ulong_long () /* SCM_I_ULLONG_MAX + 1 */ { - SCM n = scm_sum (scm_from_ulong_long (SCM_I_ULLONG_MAX), scm_from_int (1)); + SCM n = scm_sum (scm_from_ulong_long (ULLONG_MAX), scm_from_int (1)); SCM caught = scm_internal_catch (SCM_BOOL_T, call_num2ulong_long_body, &n, out_of_range_handler, NULL); assert (scm_is_true (caught)); diff --git a/test-suite/tests/00-socket.test b/test-suite/tests/00-socket.test index 6deb28542..e74d376e5 100644 --- a/test-suite/tests/00-socket.test +++ b/test-suite/tests/00-socket.test @@ -1,7 +1,7 @@ -;;;; socket.test --- test socket functions -*- scheme -*- +;;;; 00-socket.test --- test socket functions -*- scheme -*- ;;;; ;;;; Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, -;;;; 2011 Free Software Foundation, Inc. +;;;; 2011, 2012 Free Software Foundation, Inc. ;;;; ;;;; This library is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Lesser General Public @@ -17,6 +17,9 @@ ;;;; License along with this library; if not, write to the Free Software ;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +;; This test runs early, so that we can fork before any threads are +;; created in other tests. + (define-module (test-suite test-socket) #:use-module (rnrs bytevectors) #:use-module (srfi srfi-26) diff --git a/test-suite/tests/asm-to-bytecode.test b/test-suite/tests/asm-to-bytecode.test index 4ea3dd309..ddbe2eeac 100644 --- a/test-suite/tests/asm-to-bytecode.test +++ b/test-suite/tests/asm-to-bytecode.test @@ -22,7 +22,9 @@ #:use-module (test-suite lib) #:use-module (system vm instruction) #:use-module (system vm objcode) + #:use-module (system vm elf) #:use-module (system base target) + #:use-module (language objcode elf) #:use-module (language assembly) #:use-module (language assembly compile-bytecode)) @@ -136,7 +138,7 @@ ((@ (system foreign) sizeof) '*)) (define %objcode-cookie-size - (string-length "GOOF----LE-8-2.0")) + (string-length "GOOF----LE-8")) (define (test-target triplet endian word-size) (pass-if (format #f "target `~a' honored" triplet) @@ -167,21 +169,12 @@ (nop) (nop) (nop) (nop) (nop)) #f))) - (write-objcode (bytecode->objcode b) p) - (let ((cookie (make-bytevector %objcode-cookie-size)) - (expected (format #f "GOOF----~a-~a-~a" - (cond ((eq? endian (endianness little)) - "LE") - ((eq? endian (endianness big)) - "BE") - (else - (error "unknown endianness" - endian))) - word-size - (effective-version)))) - (bytevector-copy! (get-objcode) 0 cookie 0 - %objcode-cookie-size) - (string=? (utf8->string cookie) expected))))))))) + (write-objcode (bytecode->objcode b (target-endianness)) p) + (let* ((bv (get-objcode))) + (and=> (parse-elf bv) + (lambda (elf) + (and (equal? (elf-byte-order elf) endian) + (equal? (elf-word-size elf) word-size)))))))))))) (with-test-prefix "cross-compilation" @@ -203,7 +196,7 @@ (make-int8 77) (return)) #f)) - (o (bytecode->objcode b))) + (o (bytecode->objcode b (target-endianness)))) (with-target "fcpu-unknown-gnu1.0" (lambda () (write-objcode o p)))))))) diff --git a/test-suite/tests/cse.test b/test-suite/tests/cse.test index e0219e84d..f9b85d495 100644 --- a/test-suite/tests/cse.test +++ b/test-suite/tests/cse.test @@ -70,7 +70,7 @@ (lambda _ (lambda-case (((x y) #f #f #f () (_ _)) - (apply (primitive eq?) (lexical x _) (lexical y _)))))) + (primcall eq? (lexical x _) (lexical y _)))))) ;; The eq? propagates, and (if TEST #f #t) folds to (not TEST). (pass-if-cse @@ -79,8 +79,8 @@ (lambda _ (lambda-case (((x y) #f #f #f () (_ _)) - (apply (primitive not) - (apply (primitive eq?) (lexical x _) (lexical y _))))))) + (primcall not + (primcall eq? (lexical x _) (lexical y _))))))) ;; (if TEST (not TEST) #f) ;; => (if TEST #f #f) @@ -110,13 +110,13 @@ (lambda _ (lambda-case (((x y) #f #f #f () (_ _)) - (if (apply (primitive set-car!) - (lexical x _) - (lexical y _)) - (apply (primitive not) - (apply (primitive set-car!) - (lexical x _) - (lexical y _))) + (if (primcall set-car! + (lexical x _) + (lexical y _)) + (primcall not + (primcall set-car! + (lexical x _) + (lexical y _))) (const #f)))))) ;; Primitives that access mutable memory can propagate, as long as @@ -130,11 +130,10 @@ (lambda _ (lambda-case (((x y) #f #f #f () (_ _)) - (begin - (apply (primitive string-ref) - (lexical x _) - (lexical y _)) - (const #f)))))) + (seq (primcall string-ref + (lexical x _) + (lexical y _)) + (const #f)))))) ;; However, expressions with dependencies on effects do not propagate ;; through a lambda. @@ -146,15 +145,15 @@ (lambda _ (lambda-case (((x y) #f #f #f () (_ _)) - (if (apply (primitive string-ref) - (lexical x _) - (lexical y _)) + (if (primcall string-ref + (lexical x _) + (lexical y _)) (lambda _ (lambda-case ((() #f #f #f () ()) - (if (apply (primitive string-ref) - (lexical x _) - (lexical y _)) + (if (primcall string-ref + (lexical x _) + (lexical y _)) (const #t) (const #f))))) (const #f)))))) @@ -169,17 +168,16 @@ (lambda _ (lambda-case (((x y) #f #f #f () (_ _)) - (if (apply (primitive string-ref) - (lexical x _) - (lexical y _)) - (begin - (apply (primitive string-set!) - (lexical x _) - (const #\!)) - (apply (primitive not) - (apply (primitive string-ref) - (lexical x _) - (lexical y _)))) + (if (primcall string-ref + (lexical x _) + (lexical y _)) + (seq (primcall string-set! + (lexical x _) + (const #\!)) + (primcall not + (primcall string-ref + (lexical x _) + (lexical y _)))) (const #f)))))) ;; Predicates are only added to the database if they are in a @@ -190,7 +188,7 @@ (lambda _ (lambda-case (((x y) #f #f #f () (_ _)) - (apply (primitive eq?) (lexical x _) (lexical y _)))))) + (primcall eq? (lexical x _) (lexical y _)))))) ;; Conditional bailouts do cause primitives to be added to the DB. (pass-if-cse @@ -199,12 +197,11 @@ (lambda _ (lambda-case (((x y) #f #f #f () (_ _)) - (begin - (if (apply (primitive eq?) - (lexical x _) (lexical y _)) - (void) - (apply (primitive 'throw) (const 'foo))) - (const #t)))))) + (seq (if (primcall eq? + (lexical x _) (lexical y _)) + (void) + (primcall throw (const foo))) + (const #t)))))) ;; A chain of tests in a conditional bailout add data to the DB ;; correctly. @@ -219,21 +216,20 @@ (lambda _ (lambda-case (((x y) #f #f #f () (_ _)) - (begin + (seq (fix (failure) (_) ((lambda _ (lambda-case ((() #f #f #f () ()) - (apply (primitive throw) (const foo)))))) - (if (apply (primitive struct?) (lexical x _)) - (if (apply (primitive eq?) - (apply (primitive struct-vtable) - (lexical x _)) - (toplevel x-vtable)) + (primcall throw (const foo)))))) + (if (primcall struct? (lexical x _)) + (if (primcall eq? + (primcall struct-vtable (lexical x _)) + (toplevel x-vtable)) (void) - (apply (lexical failure _))) - (apply (lexical failure _)))) - (apply (primitive struct-ref) (lexical x _) (lexical y _))))))) + (call (lexical failure _))) + (call (lexical failure _)))) + (primcall struct-ref (lexical x _) (lexical y _))))))) ;; Strict argument evaluation also adds info to the DB. (pass-if-cse @@ -254,24 +250,23 @@ ((lambda _ (lambda-case ((() #f #f #f () ()) - (apply (primitive throw) (const foo)))))) - (if (apply (primitive struct?) (lexical x _)) - (if (apply (primitive eq?) - (apply (primitive struct-vtable) - (lexical x _)) - (toplevel x-vtable)) - (apply (primitive struct-ref) (lexical x _) (const 1)) - (apply (lexical failure _))) - (apply (lexical failure _))))) - (apply (primitive +) (lexical z _) - (apply (primitive struct-ref) (lexical x _) (const 2)))))))) + (primcall throw (const foo)))))) + (if (primcall struct? (lexical x _)) + (if (primcall eq? + (primcall struct-vtable (lexical x _)) + (toplevel x-vtable)) + (primcall struct-ref (lexical x _) (const 1)) + (call (lexical failure _))) + (call (lexical failure _))))) + (primcall + (lexical z _) + (primcall struct-ref (lexical x _) (const 2)))))))) ;; Replacing named expressions with lexicals. (pass-if-cse (let ((x (car y))) (cons x (car y))) - (let (x) (_) ((apply (primitive car) (toplevel y))) - (apply (primitive cons) (lexical x _) (lexical x _)))) + (let (x) (_) ((primcall car (toplevel y))) + (primcall cons (lexical x _) (lexical x _)))) ;; Dominating expressions only provide predicates when evaluated in ;; test context. @@ -282,16 +277,16 @@ 'two)) ;; Actually this one should reduce in other ways, but this is the ;; current reduction: - (begin - (apply (primitive car) (toplevel x)) - (if (apply (primitive car) (toplevel x)) + (seq + (primcall car (toplevel x)) + (if (primcall car (toplevel x)) (const one) (const two)))) (pass-if-cse (begin (cons 1 2 3) 4) - (begin - (apply (primitive cons) (const 1) (const 2) (const 3)) + (seq + (primcall cons (const 1) (const 2) (const 3)) (const 4))) (pass-if "http://bugs.gnu.org/12883" diff --git a/test-suite/tests/ecmascript.test b/test-suite/tests/ecmascript.test index 96b1d6666..17036f93d 100644 --- a/test-suite/tests/ecmascript.test +++ b/test-suite/tests/ecmascript.test @@ -23,9 +23,11 @@ (define (eread str) - (call-with-input-string str read-ecmascript)) + (with-fluids ((%default-port-encoding "utf-8")) + (call-with-input-string str read-ecmascript))) (define (eread/1 str) - (call-with-input-string str read-ecmascript/1)) + (with-fluids ((%default-port-encoding "utf-8")) + (call-with-input-string str read-ecmascript/1))) (define-syntax parse (syntax-rules () diff --git a/test-suite/tests/elisp-compiler.test b/test-suite/tests/elisp-compiler.test index 230dc772d..ddfa80a9a 100644 --- a/test-suite/tests/elisp-compiler.test +++ b/test-suite/tests/elisp-compiler.test @@ -47,6 +47,8 @@ ; Test control structures. ; ======================== +(compile '(%set-lexical-binding-mode #nil) #:from 'elisp #:to 'value) + (with-test-prefix/compile "Sequencing" (pass-if-equal "progn" 1 @@ -54,6 +56,9 @@ (setq a (1+ a)) a)) + (pass-if-equal "empty progn" #nil + (progn)) + (pass-if "prog1" (progn (setq a 0) (setq b (prog1 a (setq a (1+ a)))) @@ -77,17 +82,8 @@ 3) (equal (if nil 1) nil))) - (pass-if-equal "failing when" nil-value - (when nil 1 2 3)) - (pass-if-equal "succeeding when" 42 - (progn (setq a 0) - (when t (setq a 42) a))) - - (pass-if-equal "failing unless" nil-value - (unless t 1 2 3)) - (pass-if-equal "succeeding unless" 42 - (progn (setq a 0) - (unless nil (setq a 42) a))) + (pass-if-equal "if with no else" #nil + (if nil t)) (pass-if-equal "empty cond" nil-value (cond)) @@ -127,27 +123,7 @@ (while (<= i 5) (setq prod (* i prod)) (setq i (1+ i))) - prod)) - - (pass-if "dotimes" - (progn (setq a 0) - (setq count 100) - (setq b (dotimes (i count) - (setq j (1+ i)) - (setq a (+ a j)))) - (setq c (dotimes (i 10 42) nil)) - (and (= a 5050) (equal b nil) (= c 42)))) - - (pass-if "dolist" - (let ((mylist '(7 2 5))) - (setq sum 0) - (setq a (dolist (i mylist) - (setq sum (+ sum i)))) - (setq b (dolist (i mylist 5) 0)) - (and (= sum (+ 7 2 5)) - (equal a nil) - (equal mylist '(7 2 5)) - (equal b 5))))) + prod))) (with-test-prefix/compile "Exceptions" @@ -169,7 +145,7 @@ (= (catch 'abc (throw 'abc 2) 1) 2) (= (catch 'abc (catch 'def (throw 'abc (1+ 0)) 2) 3) 1) (= (catch 'abc (catch 'def (throw 'def 1) 2) 3) 3) - (= (catch mylist (catch '(1 2) (throw mylist 1) 2) 3) 1))) + (= (catch mylist (catch (list 1 2) (throw mylist 1) 2) 3) 1))) (pass-if "unwind-protect" (progn (setq a 0 b 1 c 1) @@ -246,6 +222,8 @@ (b a)) b))) + (pass-if-equal "empty let" #nil (let ())) + (pass-if "let*" (progn (setq a 0) (and (let* ((a 1) @@ -257,6 +235,9 @@ (= a 0) (not (boundp 'b))))) + (pass-if-equal "empty let*" #nil + (let* ())) + (pass-if "local scope" (progn (setq a 0) (setq b (let (a) @@ -303,9 +284,11 @@ (lexical-let ((a 2)) (and (= a 2) (equal (dynvals) '(1 . 1)) (let ((a 3) (b a)) + (declare (lexical a)) (and (= a 3) (= b 2) (equal (dynvals) '(1 . 2)))) (let* ((a 4) (b a)) + (declare (lexical a)) (and (= a 4) (= b 4) (equal (dynvals) '(1 . 4)))) (= a 2))) @@ -316,8 +299,11 @@ (defun dyna () a) (lexical-let ((a 2) (b 42)) (and (= a 2) (= (dyna) 1) - ((lambda (a) (and (= a 3) (= b 42) (= (dyna) 3))) 3) + ((lambda (a) + (declare (lexical a)) + (and (= a 3) (= b 42) (= (dyna) 1))) 3) ((lambda () (let ((a 3)) + (declare (lexical a)) (and (= a 3) (= (dyna) 1))))) (= a 2) (= (dyna) 1))) (= a 1))) @@ -336,34 +322,13 @@ (= (funcall c1) 4) (= (funcall c2) 3))) - (pass-if "always lexical option (all)" - (progn (setq a 0) - (defun dyna () a) - (let ((a 1)) - (and (= a 1) (= (dyna) 0)))) - #:opts '(#:always-lexical all)) - (pass-if "always lexical option (list)" - (progn (setq a 0 b 0) - (defun dyna () a) - (defun dynb () b) - (let ((a 1) - (b 1)) - (and (= a 1) (= (dyna) 0) - (= b 1) (= (dynb) 1)))) - #:opts '(#:always-lexical (a))) - (pass-if "with-always-lexical" - (progn (setq a 0) - (defun dyna () a) - (with-always-lexical (a) - (let ((a 1)) - (and (= a 1) (= (dyna) 0)))))) - (pass-if "lexical lambda args" (progn (setq a 1 b 1) (defun dyna () a) (defun dynb () b) - (with-always-lexical (a c) + (lexical-let (a c) ((lambda (a b &optional c) + (declare (lexical a c)) (and (= a 3) (= (dyna) 1) (= b 2) (= (dynb) 2) (= c 1))) @@ -373,9 +338,10 @@ ; is tail-optimized by doing a deep recursion that would otherwise overflow ; the stack. (pass-if "lexical lambda tail-recursion" - (with-always-lexical (i) + (lexical-let (i) (setq to 1000000) (defun iteration-1 (i) + (declare (lexical i)) (if (< i to) (iteration-1 (1+ i)))) (iteration-1 0) @@ -422,14 +388,17 @@ ((lambda (a b c) c) 1 2 3)) (pass-if-equal "optional argument" 3 - ((function (lambda (a &optional b c) c)) 1 2 3)) + ((lambda (a &optional b c) c) 1 2 3)) (pass-if-equal "optional missing" nil-value ((lambda (&optional a) a))) (pass-if-equal "rest argument" '(3 4 5) ((lambda (a b &rest c) c) 1 2 3 4 5)) - (pass-if-equal "rest missing" nil-value - ((lambda (a b &rest c) c) 1 2))) + (pass-if "rest missing" + (null ((lambda (a b &rest c) c) 1 2))) + + (pass-if-equal "empty lambda" #nil + ((lambda ())))) (with-test-prefix/compile "Function Definitions" @@ -453,18 +422,16 @@ (not (fboundp 'a)) (= a 1)))) - (pass-if "flet and flet*" + (pass-if "flet" (progn (defun foobar () 42) (defun test () (foobar)) (and (= (test) 42) - (flet ((foobar (lambda () 0)) - (myfoo (symbol-function 'foobar))) + (flet ((foobar () 0) + (myfoo () + (funcall (symbol-function 'foobar)))) (and (= (myfoo) 42) (= (test) 42))) - (flet* ((foobar (lambda () 0)) - (myfoo (symbol-function 'foobar))) - (= (myfoo) 42)) - (flet (foobar) + (flet ((foobar () nil)) (defun foobar () 0) (= (test) 42)) (= (test) 42))))) @@ -563,8 +530,8 @@ (setq some-string "abc") (and (eq 2 2) (not (eq 1 2)) (eq 'abc 'abc) (not (eq 'abc 'def)) - (eq some-string some-string) (not (eq some-string "abc")) - (eq some-list some-list) (not (eq some-list '(1 2))))))) + (eq some-string some-string) (not (eq some-string (string 97 98 99))) + (eq some-list some-list) (not (eq some-list (list 1 2))))))) (with-test-prefix/compile "Number Built-Ins" @@ -607,11 +574,11 @@ (with-test-prefix/compile "List Built-Ins" - (pass-if "consp and atomp" + (pass-if "consp and atom" (and (consp '(1 2 3)) (consp '(1 2 . 3)) (consp '(a . b)) (not (consp '())) (not (consp 1)) (not (consp "abc")) - (atomp 'a) (atomp '()) (atomp -1.5) (atomp "abc") - (not (atomp '(1 . 2))) (not (atomp '(1))))) + (atom 'a) (atom '()) (atom -1.5) (atom "abc") + (not (atom '(1 . 2))) (not (atom '(1))))) (pass-if "listp and nlistp" (and (listp '(1 2 3)) (listp '(1)) (listp '()) (listp '(1 . 2)) (not (listp 'a)) (not (listp 42)) (nlistp 42) @@ -628,15 +595,6 @@ (and (equal (car-safe '(1 2)) 1) (equal (cdr-safe '(1 2)) '(2)) (equal (car-safe 5) nil) (equal (cdr-safe 5) nil))) - (pass-if "pop" - (progn (setq mylist '(a b c)) - (setq value (pop mylist)) - (and (equal value 'a) - (equal mylist '(b c))))) - (pass-if-equal "push" '(a b c) - (progn (setq mylist '(b c)) - (push 'a mylist))) - (pass-if "nth and nthcdr" (and (equal (nth -5 '(1 2 3)) 1) (equal (nth 3 '(1 2 3)) nil) (equal (nth 0 '(1 2 3)) 1) (equal (nth 2 '(1 2 3)) 3) @@ -662,20 +620,6 @@ (pass-if "reverse" (and (equal (reverse '(5 4 3 2 1)) '(1 2 3 4 5)) (equal (reverse '()) '()))) - (pass-if "copy-tree" - (progn (setq mylist '(1 2 (3 4))) - (and (not (eq mylist (copy-tree mylist))) - (equal mylist (copy-tree mylist))))) - - (pass-if "number-sequence" - (and (equal (number-sequence 5) '(5)) - (equal (number-sequence 5 9) '(5 6 7 8 9)) - (equal (number-sequence 5 9 3) '(5 8)) - (equal (number-sequence 5 1 -2) '(5 3 1)) - (equal (number-sequence 5 8 -1) '()) - (equal (number-sequence 5 1) '()) - (equal (number-sequence 5 5 0) '(5)))) - (pass-if "setcar and setcdr" (progn (setq pair '(1 . 2)) (setq copy pair) diff --git a/test-suite/tests/eval.test b/test-suite/tests/eval.test index 6ab3b8ac8..24afe2da0 100644 --- a/test-suite/tests/eval.test +++ b/test-suite/tests/eval.test @@ -334,50 +334,64 @@ 1+ 0)) +(define (make-tagged-trimmed-stack tag spec) + (catch 'result + (lambda () + (call-with-prompt + tag + (lambda () + (with-throw-handler 'wrong-type-arg + (lambda () (substring 'wrong 'type 'arg)) + (lambda _ (throw 'result (apply make-stack spec))))) + (lambda () (throw 'make-stack-failed)))) + (lambda (key result) result))) + +(define tag (make-prompt-tag "foo")) + (with-test-prefix "stacks" (pass-if "stack involving a primitive" ;; The primitive involving the error must appear exactly once on the ;; stack. - (catch 'result - (lambda () - (start-stack 'foo - (with-throw-handler 'wrong-type-arg - (lambda () - ;; Trigger a `wrong-type-arg' exception. - (hashq-ref 'wrong 'type 'arg)) - (lambda _ - (let* ((stack (make-stack #t)) - (frames (stack->frames stack))) - (throw 'result - (count (lambda (frame) - (eq? (frame-procedure frame) - hashq-ref)) - frames))))))) - (lambda (key result) - (= 1 result)))) + (let* ((stack (make-tagged-trimmed-stack tag '(#t))) + (frames (stack->frames stack)) + (num (count (lambda (frame) (eq? (frame-procedure frame) + substring)) + frames))) + (= num 1))) (pass-if "arguments of a primitive stack frame" ;; Create a stack with two primitive frames and make sure the ;; arguments are correct. - (catch 'result - (lambda () - (start-stack 'foo - (with-throw-handler 'wrong-type-arg - (lambda () - ;; Trigger a `wrong-type-arg' exception. - (substring 'wrong 'type 'arg)) - (lambda _ - (let* ((stack (make-stack #t)) - (frames (stack->frames stack))) - (throw 'result - (map (lambda (frame) - (cons (frame-procedure frame) - (frame-arguments frame))) - frames))))))) - (lambda (key result) - (and (equal? (car result) `(,make-stack #t)) - (pair? (member `(,substring wrong type arg) - (cdr result)))))))) + (let* ((stack (make-tagged-trimmed-stack tag '(#t))) + (call-list (map (lambda (frame) + (cons (frame-procedure frame) + (frame-arguments frame))) + (stack->frames stack)))) + (and (equal? (car call-list) `(,make-stack #t)) + (pair? (member `(,substring wrong type arg) + (cdr call-list)))))) + + (pass-if "inner trim with prompt tag" + (let* ((stack (make-tagged-trimmed-stack tag `(#t ,tag))) + (frames (stack->frames stack))) + ;; the top frame on the stack is the lambda inside the 'catch, and the + ;; next frame is the (catch 'result ...) + (and (eq? (frame-procedure (cadr frames)) + catch) + (eq? (car (frame-arguments (cadr frames))) + 'result)))) + + (pass-if "outer trim with prompt tag" + (let* ((stack (make-tagged-trimmed-stack tag `(#t 0 ,tag))) + (frames (stack->frames stack))) + ;; the top frame on the stack is the make-stack call, and the last + ;; frame is the (with-throw-handler 'wrong-type-arg ...) + (and (eq? (frame-procedure (car frames)) + make-stack) + (eq? (frame-procedure (car (last-pair frames))) + with-throw-handler) + (eq? (car (frame-arguments (car (last-pair frames)))) + 'wrong-type-arg))))) ;;; ;;; letrec init evaluation diff --git a/test-suite/tests/foreign.test b/test-suite/tests/foreign.test index 540effb26..204fde7c9 100644 --- a/test-suite/tests/foreign.test +++ b/test-suite/tests/foreign.test @@ -332,6 +332,10 @@ (= (sizeof (list int8 double)) (+ (alignof double) (sizeof double)))) + (pass-if "sizeof { double, int8 }" + (= (sizeof (list double int8)) + (+ (alignof double) (sizeof double)))) + (pass-if "sizeof { short, int, long, pointer }" (let ((layout (list short int long '*))) (>= (sizeof layout) diff --git a/test-suite/tests/iconv.test b/test-suite/tests/iconv.test index 9083cd256..be36336f3 100644 --- a/test-suite/tests/iconv.test +++ b/test-suite/tests/iconv.test @@ -94,6 +94,11 @@ (pass-if-exception "misparse latin1 as utf8" exception:decoding-error (bytevector->string (string->bytevector s "latin1") "utf-8")) + (pass-if "misparse latin1 as utf8 with substitutions" + (equal? (bytevector->string (string->bytevector s "latin1") + "utf-8" 'substitute) + "?t?")) + (pass-if-exception "misparse latin1 as ascii" exception:decoding-error (bytevector->string (string->bytevector s "latin1") "ascii")))) diff --git a/test-suite/tests/peg.bench b/test-suite/tests/peg.bench new file mode 100644 index 000000000..7baad5c73 --- /dev/null +++ b/test-suite/tests/peg.bench @@ -0,0 +1,173 @@ +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;; PEG benchmark suite (minimal right now). +;; Parses very long equations several times; outputs the average time +;; it took and the standard deviation of times. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(use-modules (ice-9 pretty-print)) +(use-modules (srfi srfi-1)) +(use-modules (ice-9 peg)) +(use-modules (ice-9 popen)) + +;; Generate random equations. +(define (gen-rand-eq len) + (if (= len 0) + (random 1000) + (let ((len (if (even? len) (+ len 1) len))) + (map (lambda (x) + (if (odd? x) + (gen-rand len 'op) + (gen-rand len 'number))) + (iota len))))) +(define (gen-rand len type) + (cond ((eq? type 'number) + (cond + ((= (random 5) 0) (gen-rand-eq (floor (/ len 5)))) + (#t (random 1000)))) + (#t (list-ref '(+ - * /) (random 4))))) + +;; Generates a random equation string (len is a rough indicator of the +;; resulting length). +(define (gen-str len) + (with-output-to-string (lambda () (write (gen-rand-eq len))))) + +;; Generates a left-associative parser (see tutorial). +(define (make-left-parser next-func) + (lambda (sum first . rest) + (if (null? rest) + (apply next-func first) + (if (string? (cadr first)) + (list (string->symbol (cadr first)) + (apply next-func (car first)) + (apply next-func (car rest))) + (car + (reduce + (lambda (l r) + (list (list (cadr r) (car r) (apply next-func (car l))) + (string->symbol (cadr l)))) + 'ignore + (append + (list (list (apply next-func (caar first)) + (string->symbol (cadar first)))) + (cdr first) + (list (append rest '("done")))))))))) + +;; Functions for parsing equations (see tutorial). +(define (parse-value value first . rest) + (if (null? rest) + (string->number (cadr first)) + (apply parse-sum (car rest)))) +(define parse-product (make-left-parser parse-value)) +(define parse-sum (make-left-parser parse-product)) +(define parse-expr parse-sum) +(define (eq-parse str) (apply parse-expr (peg:tree (match-pattern expr str)))) + +;; PEG for parsing equations (see tutorial). +(define-peg-string-patterns + "expr <- sum +sum <-- (product ('+' / '-'))* product +product <-- (value ('*' / '/'))* value +value <-- sp number sp / sp '(' expr ')' sp +number <-- [0-9]+ +sp < [ \t\n]*") + +;; gets the time in seconds (with a fractional part) +(define (canon-time) + (let ((pair (gettimeofday))) + (+ (+ (car pair) (* (cdr pair) (expt 10 -6))) 0.0))) + +;; Times how long it takes for FUNC to complete when called on ARGS. +;; **SIDE EFFECT** Writes the time FUNC took to stdout. +;; Returns the return value of FUNC. +(define (time-func func . args) + (let ((start (canon-time))) + (let ((res (apply func args))) + (pretty-print `(took ,(- (canon-time) start) seconds)) + res))) +;; Times how long it takes for FUNC to complete when called on ARGS. +;; Returns the time FUNC took to complete. +(define (time-ret-func func . args) + (let ((start (canon-time))) + (let ((res (apply func args))) + (- (canon-time) start)))) + +;; test string (randomly generated) +(define tst1 "(621 - 746 * 945 - 194 * (204 * (965 - 738 + (846)) - 450 / (116 * 293 * 543) + 858 / 693 - (890 * (260) - 855) + 875 - 684 / (749 - (846) + 127) / 670) - 293 - 815 - 628 * 93 - 662 + 561 / 645 + 112 - 71 - (286 - ((324) / 424 + 956) / 190 + ((848) / 132 * 602) + 5 + 765 * 220 - ((801) / 191 - 299) * 708 + 151 * 682) + (943 + 847 - 145 - 816 / 550 - 217 / 9 / 969 * 524 * 447 / 323) * 991 - 283 * 915 / 733 / 478 / (680 + 343 * 186 / 341 * ((571) * 848 - 47) - (492 + 398 * (616)) + 270 - 539 * 34 / 47 / 458) * 417 / 406 / 354 * 678 + 524 + 40 / 282 - 792 * 570 - 305 * 14 + (248 - 678 * 8 - 53 - 215 / 677 - 665 / 216 - 275 - 462 / 502) - 24 - 780 + (967 / (636 / 400 * 823) + 933 - 361 - 620 - 255 / 372 + 394 * 869 / 839 * 727) + (436 + 993 - 668 + 772 - 33 + 64 - 252 * 957 * 320 + 540 / (23 * 74 / (422))) + (516 / (348 * 219 * 986) * 85 * 149 * 957 * 602 / 141 / 80 / 456 / 92 / (443 * 468 * 466)) * 568 / (271 - 42 + 271 + 592 + 71 * (766 + (11) * 946) / 728 / 137 / 111 + 557 / 962) * 179 - 936 / 821 * 101 - 206 / (267 - (11 / 906 * 290) / 722 / 98 - 987 / 989 - 470 * 833 - (720 / 34 - 280) + 638 / 940) - 889 * 84 * 630 + ((214 - 888 + (46)) / 540 + 941 * 724 / 759 * (679 / 527 - 764) * 413 + 831 / 559 - (308 / 796 / 737) / 20))") + +;; appends two equations (adds them together) +(define (eq-append . eqs) + (if (null? eqs) + "0" + (if (null? (cdr eqs)) + (car eqs) + (string-append + (car eqs) + " + " + (apply eq-append (cdr eqs)))))) + +;; concatenates an equation onto itself n times using eq-append +(define (string-n str n) + (if (<= n 0) + "0" + (if (= n 1) + str + (eq-append str (string-n str (- n 1)))))) + +;; standard deviation (no bias-correction) +;; (also called population standard deviation) +(define (stddev . lst) + (let ((llen (length lst))) + (if (<= llen 0) + 0 + (let* ((avg (/ (reduce + 0 lst) llen)) + (mapfun (lambda (x) (real-part (expt (- x avg) 2))))) + (sqrt (/ (reduce + 0 (map mapfun lst)) llen)))))) + +;; average +(define (avg . lst) + (if (null? lst) + 0 + (/ (reduce + 0 lst) (length lst)))) + +(pretty-print "Parsing equations (see PEG in tutorial). Sample size of 10 for each test.") +(pretty-print + (let ((lst + (map + (lambda (ignore) + (reduce-right + append + 0 + (map + (lambda (x) + (let* ((mstr (string-n tst1 x)) + (strlen (string-length mstr))) + (let ((func (lambda () (begin (match-pattern expr mstr) + 'done)))) + `(((string of length ,strlen first pass) + ,(time-ret-func func)) + ((string of length ,strlen second pass) + ,(time-ret-func func)))))) + (filter (lambda (x) (= (modulo x 25) 0)) (iota 100))))) + (iota 10)))) + (let ((compacted + (reduce-right + (lambda (accum conc) + (map (lambda (l r) (append l (cdr r))) accum conc)) + 0 + lst))) + (map + (lambda (els) + `(,(car els) + (average time in seconds ,(apply avg (cdr els))) + (standard deviation ,(apply stddev (cdr els))))) + compacted)))) + +(define (sys-calc str) + (let* ((pipe (open-input-pipe (string-append "echo \"" str "\" | bc -l"))) + (str (read pipe))) + (close-pipe pipe) + str)) +(define (lisp-calc str) + (+ (eval (eq-parse str) (interaction-environment)) 0.0)) + +;; (pretty-print `(,(sys-calc tst1) ,(lisp-calc tst1))) diff --git a/test-suite/tests/peg.test b/test-suite/tests/peg.test new file mode 100644 index 000000000..f516571e8 --- /dev/null +++ b/test-suite/tests/peg.test @@ -0,0 +1,278 @@ +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;; PEG test suite. +;; Tests the parsing capabilities of (ice-9 peg). Could use more +;; tests for edge cases. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(define-module (test-suite test-peg) + :use-module (test-suite lib) + :use-module (ice-9 peg) + :use-module (ice-9 pretty-print) + :use-module (srfi srfi-1)) + +;; Doubled up for pasting into REPL. +(use-modules (test-suite lib)) +(use-modules (ice-9 peg)) +(use-modules (ice-9 pretty-print)) +(use-modules (srfi srfi-1)) + +;; Evaluates an expression at the toplevel. Not the prettiest +;; solution to runtime issues ever, but m3h. Runs at toplevel so that +;; symbols are bound globally instead of in the scope of the pass-if +;; expression. +(define (eeval exp) + (eval exp (interaction-environment))) +(define make-prec (@@ (ice-9 peg) make-prec)) + +;; Maps the nonterminals defined in the PEG parser written as a PEG to +;; the nonterminals defined in the PEG parser written with +;; S-expressions. +(define grammar-mapping + '((grammar peg-grammar) + (pattern peg-pattern) + (alternative peg-alternative) + (suffix peg-suffix) + (primary peg-primary) + (literal peg-literal) + (charclass peg-charclass) + (CCrange charclass-range) + (CCsingle charclass-single) + (nonterminal peg-nonterminal) + (sp peg-sp))) + +;; Transforms the nonterminals defined in the PEG parser written as a PEG to the nonterminals defined in the PEG parser written with S-expressions. +(define (grammar-transform x) + (let ((res (assoc x grammar-mapping))) + (if res (cadr res) x))) + +;; Maps a function onto a tree (recurses until it finds atoms, then calls the function on the atoms). +(define (tree-map fn lst) + (if (list? lst) + (if (null? lst) + lst + (cons (tree-map fn (car lst)) + (tree-map fn (cdr lst)))) + (fn lst))) + +;; Tests to make sure that we can parse a PEG defining a grammar for +;; PEGs, then uses that grammar to parse the same PEG again to make +;; sure we get the same result (i.e. make sure our PEG grammar +;; expressed as a PEG is equivalent to our PEG grammar expressed with +;; S-expressions). +(with-test-prefix "PEG Grammar" + (pass-if + "defining PEGs with PEG" + (and (eeval `(define-peg-string-patterns ,(@@ (ice-9 peg) peg-as-peg))) #t)) + (pass-if + "equivalence of definitions" + (equal? + (peg:tree (match-pattern (@@ (ice-9 peg) peg-grammar) (@@ (ice-9 peg) peg-as-peg))) + (tree-map + grammar-transform + (peg:tree (match-pattern grammar (@@ (ice-9 peg) peg-as-peg))))))) + +;; A grammar for pascal-style comments from Wikipedia. +(define comment-grammar + "Begin <-- '(*' +End <-- '*)' +C <- Begin N* End +N <- C / (!Begin !End Z) +Z <- .") + +;; A short /etc/passwd file. +(define *etc-passwd* + "root:x:0:0:root:/root:/bin/bash +daemon:x:1:1:daemon:/usr/sbin:/bin/sh +bin:x:2:2:bin:/bin:/bin/sh +sys:x:3:3:sys:/dev:/bin/sh +nobody:x:65534:65534:nobody:/nonexistent:/bin/sh +messagebus:x:103:107::/var/run/dbus:/bin/false +") + +;; A grammar for parsing /etc/passwd files. +(define-peg-string-patterns + "passwd <-- entry* !. +entry <-- login CO pass CO uid CO gid CO nameORcomment CO homedir CO shell NL* +login <-- text +pass <-- text +uid <-- [0-9]* +gid <-- [0-9]* +nameORcomment <-- text +homedir <-- path +shell <-- path +path <-- (SLASH pathELEMENT)* +pathELEMENT <-- (!NL !CO !'/' .)* +text <- (!NL !CO .)* +CO < ':' +NL < '\n' +SLASH < '/'") + +;; Tests some actual parsing using PEGs. +(with-test-prefix "Parsing" + (eeval `(define-peg-string-patterns ,comment-grammar)) + (pass-if + ;; Pascal-style comment parsing + "simple comment" + (equal? + (match-pattern C "(*blah*)") + (make-prec 0 8 "(*blah*)" + '((Begin "(*") "blah" (End "*)"))))) + (pass-if + "simple comment padded" + (equal? + (match-pattern C "(*blah*)abc") + (make-prec 0 8 "(*blah*)abc" + '((Begin "(*") "blah" (End "*)"))))) + (pass-if + "nested comment" + (equal? + (match-pattern C "(*1(*2*)*)") + (make-prec 0 10 "(*1(*2*)*)" + '((Begin "(*") ("1" ((Begin "(*") "2" (End "*)"))) (End "*)"))))) + (pass-if + "early termination" + (not (match-pattern C "(*blah"))) + (pass-if + "never starts" + (not (match-pattern C "blah"))) + ;; /etc/passwd parsing + (pass-if + "/etc/passwd" + (equal? + (match-pattern passwd *etc-passwd*) + (make-prec 0 220 *etc-passwd* + '(passwd (entry (login "root") (pass "x") (uid "0") (gid "0") (nameORcomment "root") (homedir (path (pathELEMENT "root"))) (shell (path (pathELEMENT "bin") (pathELEMENT "bash")))) (entry (login "daemon") (pass "x") (uid "1") (gid "1") (nameORcomment "daemon") (homedir (path (pathELEMENT "usr") (pathELEMENT "sbin"))) (shell (path (pathELEMENT "bin") (pathELEMENT "sh")))) (entry (login "bin") (pass "x") (uid "2") (gid "2") (nameORcomment "bin") (homedir (path (pathELEMENT "bin"))) (shell (path (pathELEMENT "bin") (pathELEMENT "sh")))) (entry (login "sys") (pass "x") (uid "3") (gid "3") (nameORcomment "sys") (homedir (path (pathELEMENT "dev"))) (shell (path (pathELEMENT "bin") (pathELEMENT "sh")))) (entry (login "nobody") (pass "x") (uid "65534") (gid "65534") (nameORcomment "nobody") (homedir (path (pathELEMENT "nonexistent"))) (shell (path (pathELEMENT "bin") (pathELEMENT "sh")))) (entry (login "messagebus") (pass "x") (uid "103") (gid "107") nameORcomment (homedir (path (pathELEMENT "var") (pathELEMENT "run") (pathELEMENT "dbus"))) (shell (path (pathELEMENT "bin") (pathELEMENT "false"))))))))) + +;; Tests the functions for pulling data out of PEG Match Records. +(with-test-prefix "PEG Match Records" + (define-peg-pattern bs all (peg "'b'+")) + (pass-if + "basic parameter extraction" + (equal? + (let ((pm (search-for-pattern bs "aabbcc"))) + `((string ,(peg:string pm)) + (start ,(peg:start pm)) + (end ,(peg:end pm)) + (substring ,(peg:substring pm)) + (tree ,(peg:tree pm)) + (record? ,(peg-record? pm)))) + '((string "aabbcc") + (start 2) + (end 4) + (substring "bb") + (tree (bs "bb")) + (record? #t))))) + +;; PEG for parsing right-associative equations. +(define-peg-string-patterns + "expr <- sum +sum <-- (product ('+' / '-') sum) / product +product <-- (value ('*' / '/') product) / value +value <-- number / '(' expr ')' +number <-- [0-9]+") + +;; Functions to actually evaluate the equations parsed with the PEG. +(define (parse-sum sum left . rest) + (if (null? rest) + (apply parse-product left) + (list (string->symbol (car rest)) + (apply parse-product left) + (apply parse-sum (cadr rest))))) + +(define (parse-product product left . rest) + (if (null? rest) + (apply parse-value left) + (list (string->symbol (car rest)) + (apply parse-value left) + (apply parse-product (cadr rest))))) + +(define (parse-value value first . rest) + (if (null? rest) + (string->number (cadr first)) + (apply parse-sum (car rest)))) + +(define parse-expr parse-sum) +(define (eq-parse str) (apply parse-expr (peg:tree (match-pattern expr str)))) + +(with-test-prefix "Parsing right-associative equations" + (pass-if + "1" + (equal? (eq-parse "1") 1)) + (pass-if + "1+2" + (equal? (eq-parse "1+2") '(+ 1 2))) + (pass-if + "1+2+3" + (equal? (eq-parse "1+2+3") '(+ 1 (+ 2 3)))) + (pass-if + "1+2*3+4" + (equal? (eq-parse "1+2*3+4") '(+ 1 (+ (* 2 3) 4)))) + (pass-if + "1+2/3*(4+5)/6-7-8" + (equal? (eq-parse "1+2/3*(4+5)/6-7-8") + '(+ 1 (- (/ 2 (* 3 (/ (+ 4 5) 6))) (- 7 8))))) + (pass-if + "1+1/2*3+(1+1)/2" + (equal? (eq-parse "1+1/2*3+(1+1)/2") + '(+ 1 (+ (/ 1 (* 2 3)) (/ (+ 1 1) 2)))))) + +;; PEG for parsing left-associative equations (normal ones). +(define-peg-string-patterns + "expr <- sum +sum <-- (product ('+' / '-'))* product +product <-- (value ('*' / '/'))* value +value <-- number / '(' expr ')' +number <-- [0-9]+") + +;; Functions to actually evaluate the equations parsed with the PEG. +(define (make-left-parser next-func) + (lambda (sum first . rest) + (if (null? rest) + (apply next-func first) + (if (string? (cadr first)) + (list (string->symbol (cadr first)) + (apply next-func (car first)) + (apply next-func (car rest))) + (car + (reduce + (lambda (l r) + (list (list (cadr r) (car r) (apply next-func (car l))) + (string->symbol (cadr l)))) + 'ignore + (append + (list (list (apply next-func (caar first)) + (string->symbol (cadar first)))) + (cdr first) + (list (append rest '("done")))))))))) + +(define (parse-value value first . rest) + (if (null? rest) + (string->number (cadr first)) + (apply parse-sum (car rest)))) +(define parse-product (make-left-parser parse-value)) +(define parse-sum (make-left-parser parse-product)) +(define parse-expr parse-sum) +(define (eq-parse str) (apply parse-expr (peg:tree (match-pattern expr str)))) + +(with-test-prefix "Parsing left-associative equations" + (pass-if + "1" + (equal? (eq-parse "1") 1)) + (pass-if + "1+2" + (equal? (eq-parse "1+2") '(+ 1 2))) + (pass-if + "1+2+3" + (equal? (eq-parse "1+2+3") '(+ (+ 1 2) 3))) + (pass-if + "1+2*3+4" + (equal? (eq-parse "1+2*3+4") '(+ (+ 1 (* 2 3)) 4))) + (pass-if + "1+2/3*(4+5)/6-7-8" + (equal? (eq-parse "1+2/3*(4+5)/6-7-8") + '(- (- (+ 1 (/ (* (/ 2 3) (+ 4 5)) 6)) 7) 8))) + (pass-if + "1+1/2*3+(1+1)/2" + (equal? (eq-parse "1+1/2*3+(1+1)/2") + '(+ (+ 1 (* (/ 1 2) 3)) (/ (+ 1 1) 2))))) + diff --git a/test-suite/tests/peval.test b/test-suite/tests/peval.test index 923b0d16a..ecc5dd187 100644 --- a/test-suite/tests/peval.test +++ b/test-suite/tests/peval.test @@ -33,12 +33,9 @@ (@@ (language tree-il optimize) peval)) (define-syntax pass-if-peval - (syntax-rules (resolve-primitives) + (syntax-rules () ((_ in pat) (pass-if-peval in pat - (compile 'in #:from 'scheme #:to 'tree-il))) - ((_ resolve-primitives in pat) - (pass-if-peval in pat (expand-primitives! (resolve-primitives! (compile 'in #:from 'scheme #:to 'tree-il) @@ -75,7 +72,7 @@ (f))) (const 3)) - (pass-if-peval resolve-primitives + (pass-if-peval ;; First order, let-values (requires primitive expansion for ;; `call-with-values'.) (let ((x 0)) @@ -85,19 +82,19 @@ (+ a b)))) (const 3)) - (pass-if-peval resolve-primitives + (pass-if-peval ;; First order, multiple values. (let ((x 1) (y 2)) (values x y)) - (apply (primitive values) (const 1) (const 2))) + (primcall values (const 1) (const 2))) - (pass-if-peval resolve-primitives + (pass-if-peval ;; First order, multiple values truncated. (let ((x (values 1 'a)) (y 2)) (values x y)) - (apply (primitive values) (const 1) (const 2))) + (primcall values (const 1) (const 2))) - (pass-if-peval resolve-primitives + (pass-if-peval ;; First order, multiple values truncated. (or (values 1 2) 3) (const 1)) @@ -105,16 +102,16 @@ (pass-if-peval ;; First order, coalesced, mutability preserved. (cons 0 (cons 1 (cons 2 (list 3 4 5)))) - (apply (primitive list) - (const 0) (const 1) (const 2) (const 3) (const 4) (const 5))) + (primcall list + (const 0) (const 1) (const 2) (const 3) (const 4) (const 5))) (pass-if-peval ;; First order, coalesced, immutability preserved. (cons 0 (cons 1 (cons 2 '(3 4 5)))) - (apply (primitive cons) (const 0) - (apply (primitive cons) (const 1) - (apply (primitive cons) (const 2) - (const (3 4 5)))))) + (primcall cons (const 0) + (primcall cons (const 1) + (primcall cons (const 2) + (const (3 4 5)))))) ;; These two tests doesn't work any more because we changed the way we ;; deal with constants -- now the algorithm will see a construction as @@ -139,10 +136,10 @@ (if (zero? i) r (loop (1- i) (cons (cons i i) r)))) - (apply (primitive list) - (apply (primitive cons) (const 1) (const 1)) - (apply (primitive cons) (const 2) (const 2)) - (apply (primitive cons) (const 3) (const 3)))) + (primcall list + (primcall cons (const 1) (const 1)) + (primcall cons (const 2) (const 2)) + (primcall cons (const 3) (const 3)))) ;; ;; See above. #; @@ -163,15 +160,15 @@ r (loop (1- i) (cons (cons i i) r)))) (let (r) (_) - ((apply (primitive list) - (apply (primitive cons) (const 3) (const 3)))) + ((primcall list + (primcall cons (const 3) (const 3)))) (let (r) (_) - ((apply (primitive cons) - (apply (primitive cons) (const 2) (const 2)) - (lexical r _))) - (apply (primitive cons) - (apply (primitive cons) (const 1) (const 1)) - (lexical r _))))) + ((primcall cons + (primcall cons (const 2) (const 2)) + (lexical r _))) + (primcall cons + (primcall cons (const 1) (const 1)) + (lexical r _))))) ;; See above. (pass-if-peval @@ -181,21 +178,21 @@ (car r) (loop (1- i) (cons i r)))) (let (r) (_) - ((apply (primitive list) (const 4))) + ((primcall list (const 4))) (let (r) (_) - ((apply (primitive cons) - (const 3) - (lexical r _))) + ((primcall cons + (const 3) + (lexical r _))) (let (r) (_) - ((apply (primitive cons) - (const 2) - (lexical r _))) + ((primcall cons + (const 2) + (lexical r _))) (let (r) (_) - ((apply (primitive cons) - (const 1) - (lexical r _))) - (apply (primitive car) - (lexical r _))))))) + ((primcall cons + (const 1) + (lexical r _))) + (primcall car + (lexical r _))))))) ;; Static sums. (pass-if-peval @@ -205,7 +202,7 @@ (loop (cdr l) (+ sum (car l))))) (const 10)) - (pass-if-peval resolve-primitives + (pass-if-peval (let ((string->chars (lambda (s) (define (char-at n) @@ -218,7 +215,7 @@ (loop (1+ i))) '()))))) (string->chars "yo")) - (apply (primitive list) (const #\y) (const #\o))) + (primcall list (const #\y) (const #\o))) (pass-if-peval ;; Primitives in module-refs are resolved (the expansion of `pmatch' @@ -229,14 +226,13 @@ (pmatch '(a b c d) ((a b . _) #t))) - (begin - (apply . _) - (const #t))) + (seq (call . _) + (const #t))) (pass-if-peval ;; Mutability preserved. ((lambda (x y z) (list x y z)) 1 2 3) - (apply (primitive list) (const 1) (const 2) (const 3))) + (primcall list (const 1) (const 2) (const 3))) (pass-if-peval ;; Don't propagate effect-free expressions that operate on mutable @@ -245,10 +241,10 @@ (y (car x))) (set-car! x 0) y) - (let (x) (_) ((apply (primitive list) (const 1))) - (let (y) (_) ((apply (primitive car) (lexical x _))) - (begin - (apply (toplevel set-car!) (lexical x _) (const 0)) + (let (x) (_) ((primcall list (const 1))) + (let (y) (_) ((primcall car (lexical x _))) + (seq + (primcall set-car! (lexical x _) (const 0)) (lexical y _))))) (pass-if-peval @@ -257,9 +253,9 @@ (let ((y (car x))) (set-car! x 0) y) - (let (y) (_) ((apply (primitive car) (toplevel x))) - (begin - (apply (toplevel set-car!) (toplevel x) (const 0)) + (let (y) (_) ((primcall car (toplevel x))) + (seq + (primcall set-car! (toplevel x) (const 0)) (lexical y _)))) (pass-if-peval @@ -269,8 +265,8 @@ ((lambda _ (lambda-case (((x) _ _ _ _ _) - (apply (lexical x _) (lexical x _)))))) - (apply (lexical x _) (lexical x _)))) + (call (lexical x _) (lexical x _)))))) + (call (lexical x _) (lexical x _)))) (pass-if-peval ;; First order, aliased primitive. @@ -282,28 +278,28 @@ (begin (define (+ x y) (pk x y)) (+ 1 2)) - (begin + (seq (define + (lambda (_) (lambda-case (((x y) #f #f #f () (_ _)) - (apply (toplevel pk) (lexical x _) (lexical y _)))))) - (apply (toplevel +) (const 1) (const 2)))) + (call (toplevel pk) (lexical x _) (lexical y _)))))) + (call (toplevel +) (const 1) (const 2)))) (pass-if-peval ;; First-order, effects preserved. (let ((x 2)) (do-something!) x) - (begin - (apply (toplevel do-something!)) + (seq + (call (toplevel do-something!)) (const 2))) (pass-if-peval ;; First order, residual bindings removed. (let ((x 2) (y 3)) (* (+ x y) z)) - (apply (primitive *) (const 5) (toplevel z))) + (primcall * (const 5) (toplevel z))) (pass-if-peval ;; First order, with lambda. @@ -314,7 +310,7 @@ (lambda (_) (lambda-case (((x) #f #f #f () (_)) - (apply (primitive +) (lexical x _) (const 9))))))) + (primcall + (lexical x _) (const 9))))))) (pass-if-peval ;; First order, with lambda inlined & specialized twice. @@ -324,22 +320,22 @@ (y 3)) (+ (* x (f x y)) (f something x))) - (apply (primitive +) - (apply (primitive *) - (const 2) - (apply (primitive +) ; (f 2 3) - (apply (primitive *) - (const 2) - (toplevel top)) - (const 3))) - (let (x) (_) ((toplevel something)) ; (f something 2) - ;; `something' is not const, so preserve order of - ;; effects with a lexical binding. - (apply (primitive +) - (apply (primitive *) - (lexical x _) - (toplevel top)) - (const 2))))) + (primcall + + (primcall * + (const 2) + (primcall + ; (f 2 3) + (primcall * + (const 2) + (toplevel top)) + (const 3))) + (let (x) (_) ((toplevel something)) ; (f something 2) + ;; `something' is not const, so preserve order of + ;; effects with a lexical binding. + (primcall + + (primcall * + (lexical x _) + (toplevel top)) + (const 2))))) (pass-if-peval ;; First order, with lambda inlined & specialized 3 times. @@ -349,15 +345,22 @@ (f -1 y) (f 2 y) (f z y))) - (apply (primitive +) - (const -1) ; (f -1 0) - (const 0) ; (f 1 0) - (begin (toplevel y) (const -1)) ; (f -1 y) - (toplevel y) ; (f 2 y) - (let (x y) (_ _) ((toplevel z) (toplevel y)) ; (f z y) - (if (apply (primitive >) (lexical x _) (const 0)) - (lexical y _) - (lexical x _))))) + (primcall + + + (const -1) ; (f -1 0) + (primcall + + + (const 0) ; (f 1 0) + (primcall + + + (seq (toplevel y) (const -1)) ; (f -1 y) + (primcall + + + (toplevel y) ; (f 2 y) + (let (x y) (_ _) ((toplevel z) (toplevel y)) ; (f z y) + (if (primcall > (lexical x _) (const 0)) + (lexical y _) + (lexical x _)))))))) (pass-if-peval ;; First order, conditional. @@ -369,7 +372,7 @@ (lambda () (lambda-case (((x) #f #f #f () (_)) - (apply (toplevel display) (lexical x _)))))) + (call (toplevel display) (lexical x _)))))) (pass-if-peval ;; First order, recursive procedure. @@ -388,8 +391,8 @@ (foo) x) (let (x) (_) ((toplevel top)) - (begin - (apply (toplevel foo)) + (seq + (call (toplevel foo)) (lexical x _)))) (pass-if-peval @@ -428,8 +431,8 @@ (lambda (x) (+ x 1)) '(2 3)) - (let (y) (_) ((apply (toplevel foo))) - (apply (primitive +) (lexical y _) (const 7)))) + (let (y) (_) ((call (toplevel foo))) + (primcall + (lexical y _) (const 7)))) (pass-if-peval ;; Higher order with optional argument (caller-supplied value). @@ -451,7 +454,7 @@ ;; <https://lists.gnu.org/archive/html/bug-guile/2011-09/msg00019.html>. (let ((fold (lambda (f g) (f (g top))))) (fold 1+ (lambda (x) x))) - (apply (primitive 1+) (toplevel top))) + (primcall 1+ (toplevel top))) (pass-if-peval ;; Procedure not inlined when residual code contains recursive calls. @@ -462,7 +465,7 @@ (f (car x3) (fold f (cdr x3) b null? car cdr)))))) (fold * x 1 zero? (lambda (x1) x1) (lambda (x2) (- x2 1)))) (letrec (fold) (_) (_) - (apply (lexical fold _) + (call (lexical fold _) (primitive *) (toplevel x) (const 1) @@ -474,7 +477,7 @@ (lambda () (lambda-case (((x2) #f #f #f () (_)) - (apply (primitive -) (lexical x2 _) (const 1)))))))) + (primcall 1- (lexical x2 _)))))))) (pass-if "inlined lambdas are alpha-renamed" ;; In this example, `make-adder' is inlined more than once; thus, @@ -485,24 +488,27 @@ ;; <https://lists.gnu.org/archive/html/bug-guile/2011-09/msg00019.html> and ;; <https://lists.gnu.org/archive/html/bug-guile/2011-09/msg00029.html>. (pmatch (unparse-tree-il - (peval (compile - '(let ((make-adder - (lambda (x) (lambda (y) (+ x y))))) - (cons (make-adder 1) (make-adder 2))) - #:to 'tree-il))) - ((apply (primitive cons) - (lambda () - (lambda-case - (((y) #f #f #f () (,gensym1)) - (apply (primitive +) - (const 1) - (lexical y ,ref1))))) - (lambda () - (lambda-case - (((y) #f #f #f () (,gensym2)) - (apply (primitive +) - (const 2) - (lexical y ,ref2)))))) + (peval (expand-primitives! + (resolve-primitives! + (compile + '(let ((make-adder + (lambda (x) (lambda (y) (+ x y))))) + (cons (make-adder 1) (make-adder 2))) + #:to 'tree-il) + (current-module))))) + ((primcall cons + (lambda () + (lambda-case + (((y) #f #f #f () (,gensym1)) + (primcall + + (const 1) + (lexical y ,ref1))))) + (lambda () + (lambda-case + (((y) #f #f #f () (,gensym2)) + (primcall + + (const 2) + (lexical y ,ref2)))))) (and (eq? gensym1 ref1) (eq? gensym2 ref2) (not (eq? gensym1 gensym2)))) @@ -522,8 +528,8 @@ (b (lambda () (a))) (c (lambda (x) x))) (c 10)) - (begin (apply (toplevel foo!)) - (const 10))) + (seq (call (toplevel foo!)) + (const 10))) (pass-if-peval ;; Higher order, mutually recursive procedures. @@ -544,9 +550,9 @@ ;; Memv with non-constant list. It could fold but doesn't ;; currently. (memv 1 (list 3 2 1)) - (apply (primitive memv) - (const 1) - (apply (primitive list) (const 3) (const 2) (const 1)))) + (primcall memv + (const 1) + (primcall list (const 3) (const 2) (const 1)))) (pass-if-peval ;; Memv with non-constant key, constant list, test context @@ -554,21 +560,20 @@ ((3 2 1) 'a) (else 'b)) (let (key) (_) ((toplevel foo)) - (if (if (apply (primitive eqv?) (lexical key _) (const 3)) + (if (if (primcall eqv? (lexical key _) (const 3)) (const #t) - (if (apply (primitive eqv?) (lexical key _) (const 2)) + (if (primcall eqv? (lexical key _) (const 2)) (const #t) - (apply (primitive eqv?) (lexical key _) (const 1)))) + (primcall eqv? (lexical key _) (const 1)))) (const a) (const b)))) (pass-if-peval - ;; Memv with non-constant key, empty list, test context. Currently - ;; doesn't fold entirely. + ;; Memv with non-constant key, empty list, test context. (case foo (() 'a) (else 'b)) - (begin (toplevel foo) (const b))) + (seq (toplevel foo) (const 'b))) ;; ;; Below are cases where constant propagation should bail out. @@ -580,12 +585,12 @@ (lambda (n) (vector-set! v n n))) (let (v) (_) - ((apply (toplevel make-vector) (const 6) (const #f))) + ((call (toplevel make-vector) (const 6) (const #f))) (lambda () (lambda-case (((n) #f #f #f () (_)) - (apply (toplevel vector-set!) - (lexical v _) (lexical n _) (lexical n _))))))) + (primcall vector-set! + (lexical v _) (lexical n _) (lexical n _))))))) (pass-if-peval ;; Mutable lexical is not propagated. @@ -593,7 +598,7 @@ (lambda () v)) (let (v) (_) - ((apply (primitive vector) (const 1) (const 2) (const 3))) + ((primcall vector (const 1) (const 2) (const 3))) (lambda () (lambda-case ((() #f #f #f () ()) @@ -604,12 +609,13 @@ (let* ((x (if (> p q) (frob!) (display 'chbouib))) (y (* x 2))) (+ x x y)) - (let (x) (_) ((if (apply (primitive >) (toplevel p) (toplevel q)) - (apply (toplevel frob!)) - (apply (toplevel display) (const chbouib)))) - (let (y) (_) ((apply (primitive *) (lexical x _) (const 2))) - (apply (primitive +) - (lexical x _) (lexical x _) (lexical y _))))) + (let (x) (_) ((if (primcall > (toplevel p) (toplevel q)) + (call (toplevel frob!)) + (call (toplevel display) (const chbouib)))) + (let (y) (_) ((primcall * (lexical x _) (const 2))) + (primcall + + (lexical x _) + (primcall + (lexical x _) (lexical y _)))))) (pass-if-peval ;; Non-constant arguments not propagated to lambdas. @@ -621,16 +627,16 @@ (make-list 10) (list 1 2 3)) (let (x y z) (_ _ _) - ((apply (primitive vector) (const 1) (const 2) (const 3)) - (apply (toplevel make-list) (const 10)) - (apply (primitive list) (const 1) (const 2) (const 3))) - (begin - (apply (toplevel vector-set!) - (lexical x _) (const 0) (const 0)) - (apply (toplevel set-car!) - (lexical y _) (const 0)) - (apply (toplevel set-cdr!) - (lexical z _) (const ()))))) + ((primcall vector (const 1) (const 2) (const 3)) + (call (toplevel make-list) (const 10)) + (primcall list (const 1) (const 2) (const 3))) + (seq + (primcall vector-set! + (lexical x _) (const 0) (const 0)) + (seq (primcall set-car! + (lexical y _) (const 0)) + (primcall set-cdr! + (lexical z _) (const ())))))) (pass-if-peval (let ((foo top-foo) (bar top-bar)) @@ -638,9 +644,9 @@ (f (lambda (g x) (g x x)))) (+ (f g foo) (f g bar)))) (let (foo bar) (_ _) ((toplevel top-foo) (toplevel top-bar)) - (apply (primitive +) - (apply (primitive +) (lexical foo _) (lexical foo _)) - (apply (primitive +) (lexical bar _) (lexical bar _))))) + (primcall + + (primcall + (lexical foo _) (lexical foo _)) + (primcall + (lexical bar _) (lexical bar _))))) (pass-if-peval ;; Fresh objects are not turned into constants, nor are constants @@ -649,8 +655,8 @@ (x (cons 1 c)) (y (cons 0 x))) y) - (let (x) (_) ((apply (primitive cons) (const 1) (const (2 3)))) - (apply (primitive cons) (const 0) (lexical x _)))) + (let (x) (_) ((primcall cons (const 1) (const (2 3)))) + (primcall cons (const 0) (lexical x _)))) (pass-if-peval ;; Bindings mutated. @@ -658,7 +664,7 @@ (set! x 3) x) (let (x) (_) ((const 2)) - (begin + (seq (set! (lexical x _) (const 3)) (lexical x _)))) @@ -671,8 +677,8 @@ (frob f) ; may mutate `x' x) (letrec (x) (_) ((const 0)) - (begin - (apply (toplevel frob) (lambda _ _)) + (seq + (call (toplevel frob) (lambda _ _)) (lexical x _)))) (pass-if-peval @@ -688,9 +694,9 @@ (let ((x (make-foo))) (frob! x) ; may mutate `x' x) - (let (x) (_) ((apply (toplevel make-foo))) - (begin - (apply (toplevel frob!) (lexical x _)) + (let (x) (_) ((call (toplevel make-foo))) + (seq + (call (toplevel frob!) (lexical x _)) (lexical x _)))) (pass-if-peval @@ -701,10 +707,10 @@ (lambda-case (((x) #f #f #f () (_)) (if _ _ - (apply (lexical loop _) - (apply (primitive 1-) - (lexical x _)))))))) - (apply (lexical loop _) (toplevel x)))) + (call (lexical loop _) + (primcall 1- + (lexical x _)))))))) + (call (lexical loop _) (toplevel x)))) (pass-if-peval ;; Recursion on the 2nd argument is fully evaluated. @@ -713,8 +719,8 @@ (if (> y 0) (loop x (1- y)) (foo x y)))) - (let (x) (_) ((apply (toplevel top))) - (apply (toplevel foo) (lexical x _) (const 0)))) + (let (x) (_) ((call (toplevel top))) + (call (toplevel foo) (lexical x _) (const 0)))) (pass-if-peval ;; Inlining aborted when residual code contains recursive calls. @@ -729,10 +735,10 @@ (letrec (loop) (_) ((lambda (_) (lambda-case (((x y) #f #f #f () (_ _)) - (if (apply (primitive >) - (lexical y _) (const 0)) + (if (primcall > + (lexical y _) (const 0)) _ _))))) - (apply (lexical loop _) (toplevel x) (const 0)))) + (call (lexical loop _) (toplevel x) (const 0)))) (pass-if-peval ;; Infinite recursion: `peval' gives up and leaves it as is. @@ -749,7 +755,7 @@ (and (< x top) (loop (1+ x)))) (letrec (loop) (_) ((lambda . _)) - (apply (lexical loop _) (const 0)))) + (call (lexical loop _) (const 0)))) (pass-if-peval ;; This test checks that the `start' binding is indeed residualized. @@ -760,10 +766,10 @@ (here))) (let (pos) (_) ((const 0)) (let (here) (_) (_) - (begin - (set! (lexical pos _) (const 1)) - (apply (lexical here _)))))) - + (seq + (set! (lexical pos _) (const 1)) + (call (lexical here _)))))) + (pass-if-peval ;; FIXME: should this one residualize the binding? (letrec ((a a)) @@ -799,7 +805,7 @@ ((lambda _ (lambda-case ((() #f #f #f () ()) - (apply (lexical a _))))) + (call (lexical a _))))) (lambda _ (lambda-case (((x) #f #f #f () (_)) @@ -807,12 +813,11 @@ (lambda _ (lambda-case ((() #f #f #f () ()) - (apply (lexical a _)))))) + (call (lexical a _)))))) (let (d) (_) - ((apply (toplevel foo) (lexical b _))) - (apply (lexical c _) - (lexical d _))))) + ((call (toplevel foo) (lexical b _))) + (call (lexical c _) (lexical d _))))) (pass-if-peval ;; In this case, we can prune the bindings. `a' ends up being copied @@ -821,17 +826,17 @@ (letrec* ((a (lambda (x) (top x))) (b (lambda () a))) (foo (b) (b))) - (apply (toplevel foo) - (lambda _ - (lambda-case - (((x) #f #f #f () (_)) - (apply (toplevel top) (lexical x _))))) - (lambda _ - (lambda-case - (((x) #f #f #f () (_)) - (apply (toplevel top) (lexical x _))))))) + (call (toplevel foo) + (lambda _ + (lambda-case + (((x) #f #f #f () (_)) + (call (toplevel top) (lexical x _))))) + (lambda _ + (lambda-case + (((x) #f #f #f () (_)) + (call (toplevel top) (lexical x _))))))) - (pass-if-peval resolve-primitives + (pass-if-peval ;; The inliner sees through a `let'. ((let ((a 10)) (lambda (b) (* b 2))) 30) (const 60)) @@ -848,39 +853,39 @@ ((lambda (x y . z) (list x y z)) 1 2 3 4) - (let (z) (_) ((apply (primitive list) (const 3) (const 4))) - (apply (primitive list) (const 1) (const 2) (lexical z _)))) + (let (z) (_) ((primcall list (const 3) (const 4))) + (primcall list (const 1) (const 2) (lexical z _)))) - (pass-if-peval resolve-primitives + (pass-if-peval ;; Unmutated lists can get inlined. (let ((args (list 2 3))) (apply (lambda (x y z w) (list x y z w)) 0 1 args)) - (apply (primitive list) (const 0) (const 1) (const 2) (const 3))) + (primcall list (const 0) (const 1) (const 2) (const 3))) - (pass-if-peval resolve-primitives + (pass-if-peval ;; However if the list might have been mutated, it doesn't propagate. (let ((args (list 2 3))) (foo! args) (apply (lambda (x y z w) (list x y z w)) 0 1 args)) - (let (args) (_) ((apply (primitive list) (const 2) (const 3))) - (begin - (apply (toplevel foo!) (lexical args _)) - (apply (primitive @apply) - (lambda () - (lambda-case - (((x y z w) #f #f #f () (_ _ _ _)) - (apply (primitive list) - (lexical x _) (lexical y _) - (lexical z _) (lexical w _))))) - (const 0) - (const 1) - (lexical args _))))) - - (pass-if-peval resolve-primitives + (let (args) (_) ((primcall list (const 2) (const 3))) + (seq + (call (toplevel foo!) (lexical args _)) + (primcall @apply + (lambda () + (lambda-case + (((x y z w) #f #f #f () (_ _ _ _)) + (primcall list + (lexical x _) (lexical y _) + (lexical z _) (lexical w _))))) + (const 0) + (const 1) + (lexical args _))))) + + (pass-if-peval ;; Here the `args' that gets built by the application of the lambda ;; takes more than effort "10" to visit. Test that we fall back to ;; the source expression of the operand, which is still a call to @@ -909,27 +914,27 @@ (lambda () (lambda-case (((bv offset n) #f #f #f () (_ _ _)) - (let (x y) (_ _) ((apply (primitive bytevector-ieee-single-native-ref) - (lexical bv _) - (apply (primitive +) - (lexical offset _) (const 0))) - (apply (primitive bytevector-ieee-single-native-ref) - (lexical bv _) - (apply (primitive +) - (lexical offset _) (const 4)))) - (begin - (apply (primitive bytevector-ieee-single-native-set!) - (lexical bv _) - (apply (primitive +) - (lexical offset _) (const 0)) - (lexical x _)) - (apply (primitive bytevector-ieee-single-native-set!) - (lexical bv _) - (apply (primitive +) - (lexical offset _) (const 4)) - (lexical y _)))))))) - - (pass-if-peval resolve-primitives + (let (x y) (_ _) ((primcall bytevector-ieee-single-native-ref + (lexical bv _) + (primcall + + (lexical offset _) (const 0))) + (primcall bytevector-ieee-single-native-ref + (lexical bv _) + (primcall + + (lexical offset _) (const 4)))) + (seq + (primcall bytevector-ieee-single-native-set! + (lexical bv _) + (primcall + + (lexical offset _) (const 0)) + (lexical x _)) + (primcall bytevector-ieee-single-native-set! + (lexical bv _) + (primcall + + (lexical offset _) (const 4)) + (lexical y _)))))))) + + (pass-if-peval ;; Here we ensure that non-constant expressions are not copied. (lambda () (let ((args (list (foo!)))) @@ -943,13 +948,13 @@ (lambda () (lambda-case ((() #f #f #f () ()) - (let (_) (_) ((apply (toplevel foo!))) + (let (_) (_) ((call (toplevel foo!))) (let (z) (_) ((toplevel z)) - (apply (primitive 'list) - (lexical z _) - (lexical _ _)))))))) + (primcall 'list + (lexical z _) + (lexical _ _)))))))) - (pass-if-peval resolve-primitives + (pass-if-peval ;; Rest args referenced more than once are not destructured. (lambda () (let ((args (list 'foo))) @@ -963,25 +968,25 @@ (lambda-case ((() #f #f #f () ()) (let (args) (_) - ((apply (primitive list) (const foo))) - (begin - (apply (primitive set-car!) (lexical args _) (const bar)) - (apply (primitive @apply) - (lambda . _) - (toplevel z) - (lexical args _)))))))) - - (pass-if-peval resolve-primitives + ((primcall list (const foo))) + (seq + (primcall set-car! (lexical args _) (const bar)) + (primcall @apply + (lambda . _) + (toplevel z) + (lexical args _)))))))) + + (pass-if-peval ;; Let-values inlining, even with consumers with rest args. (call-with-values (lambda () (values 1 2)) (lambda args (apply list args))) - (apply (primitive list) (const 1) (const 2))) + (primcall list (const 1) (const 2))) (pass-if-peval ;; Constant folding: cons of #nil does not make list (cons 1 #nil) - (apply (primitive cons) (const 1) (const '#nil))) + (primcall cons (const 1) (const '#nil))) (pass-if-peval ;; Constant folding: cons @@ -991,7 +996,7 @@ (pass-if-peval ;; Constant folding: cons (begin (cons (foo) 2) #f) - (begin (apply (toplevel foo)) (const #f))) + (seq (call (toplevel foo)) (const #f))) (pass-if-peval ;; Constant folding: cons @@ -1011,12 +1016,12 @@ (pass-if-peval ;; Constant folding: car+cons, impure (car (cons 1 (bar))) - (begin (apply (toplevel bar)) (const 1))) + (seq (call (toplevel bar)) (const 1))) (pass-if-peval ;; Constant folding: cdr+cons, impure (cdr (cons (bar) 0)) - (begin (apply (toplevel bar)) (const 0))) + (seq (call (toplevel bar)) (const 0))) (pass-if-peval ;; Constant folding: car+list @@ -1026,40 +1031,53 @@ (pass-if-peval ;; Constant folding: cdr+list (cdr (list 1 0)) - (apply (primitive list) (const 0))) + (primcall list (const 0))) (pass-if-peval ;; Constant folding: car+list, impure (car (list 1 (bar))) - (begin (apply (toplevel bar)) (const 1))) + (seq (call (toplevel bar)) (const 1))) (pass-if-peval ;; Constant folding: cdr+list, impure (cdr (list (bar) 0)) - (begin (apply (toplevel bar)) (apply (primitive list) (const 0)))) + (seq (call (toplevel bar)) (primcall list (const 0)))) + + (pass-if-peval + ;; Equality primitive: same lexical + (let ((x (random))) (eq? x x)) + (seq (call (toplevel random)) (const #t))) + + (pass-if-peval + ;; Equality primitive: merge lexical identities + (let* ((x (random)) (y x)) (eq? x y)) + (seq (call (toplevel random)) (const #t))) (pass-if-peval - resolve-primitives ;; Non-constant guards get lexical bindings. (dynamic-wind foo (lambda () bar) baz) - (let (pre post) (_ _) ((toplevel foo) (toplevel baz)) - (dynwind (lexical pre _) (toplevel bar) (lexical post _)))) + (let (w u) (_ _) ((toplevel foo) (toplevel baz)) + (dynwind (lexical w _) + (call (lexical w _)) + (toplevel bar) + (call (lexical u _)) + (lexical u _)))) (pass-if-peval - resolve-primitives ;; Constant guards don't need lexical bindings. (dynamic-wind (lambda () foo) (lambda () bar) (lambda () baz)) (dynwind (lambda () (lambda-case ((() #f #f #f () ()) (toplevel foo)))) + (toplevel foo) (toplevel bar) + (toplevel baz) (lambda () (lambda-case ((() #f #f #f () ()) (toplevel baz)))))) (pass-if-peval - resolve-primitives ;; Prompt is removed if tag is unreferenced (let ((tag (make-prompt-tag))) (call-with-prompt tag @@ -1068,7 +1086,6 @@ (const 1)) (pass-if-peval - resolve-primitives ;; Prompt is removed if tag is unreferenced, with explicit stem (let ((tag (make-prompt-tag "foo"))) (call-with-prompt tag @@ -1078,7 +1095,6 @@ ;; Handler lambda inlined (pass-if-peval - resolve-primitives (call-with-prompt tag (lambda () 1) (lambda (k x) x)) @@ -1090,7 +1106,6 @@ ;; Handler toplevel not inlined (pass-if-peval - resolve-primitives (call-with-prompt tag (lambda () 1) handler) @@ -1099,12 +1114,11 @@ (const 1) (lambda-case ((() #f args #f () (_)) - (apply (primitive @apply) - (lexical handler _) - (lexical args _))))))) + (primcall @apply + (lexical handler _) + (lexical args _))))))) (pass-if-peval - resolve-primitives ;; `while' without `break' or `continue' has no prompts and gets its ;; condition folded. Unfortunately the outer `lp' does not yet get ;; elided, and the continuation tag stays around. (The continue tag @@ -1113,7 +1127,7 @@ ;; twice before aborting. The abort doesn't unroll the recursive ;; reference.) (while #t #t) - (let (_) (_) ((apply (primitive make-prompt-tag) . _)) + (let (_) (_) ((primcall make-prompt-tag . _)) (letrec (lp) (_) ((lambda _ (lambda-case @@ -1122,12 +1136,11 @@ ((lambda _ (lambda-case ((() #f #f #f () ()) - (apply (lexical loop _)))))) - (apply (lexical loop _))))))) - (apply (lexical lp _))))) + (call (lexical loop _)))))) + (call (lexical loop _))))))) + (call (lexical lp _))))) (pass-if-peval - resolve-primitives (lambda (a . rest) (apply (lambda (x y) (+ x y)) a rest)) @@ -1136,7 +1149,7 @@ (((x y) #f #f #f () (_ _)) _)))) - (pass-if-peval resolve-primitives + (pass-if-peval (car '(1 2)) (const 1)) @@ -1145,17 +1158,17 @@ ;; residualizing a reference to the leaf identifier. The bailout is ;; driven by the recursive-effort-limit, which is currently 100. We ;; make sure to trip it with this recursive sum thing. - (pass-if-peval resolve-primitives + (pass-if-peval (let ((x (let sum ((n 0) (out 0)) (if (< n 10000) (sum (1+ n) (+ out n)) out)))) ((lambda (y) (list y)) x)) (let (x) (_) (_) - (apply (primitive list) (lexical x _)))) + (primcall list (lexical x _)))) ;; Here we test that a common test in a chain of ifs gets lifted. - (pass-if-peval resolve-primitives + (pass-if-peval (if (and (struct? x) (eq? (struct-vtable x) A)) (foo x) (if (and (struct? x) (eq? (struct-vtable x) B)) @@ -1166,25 +1179,25 @@ (let (failure) (_) ((lambda _ (lambda-case ((() #f #f #f () ()) - (apply (toplevel qux) (toplevel x)))))) - (if (apply (primitive struct?) (toplevel x)) - (if (apply (primitive eq?) - (apply (primitive struct-vtable) (toplevel x)) - (toplevel A)) - (apply (toplevel foo) (toplevel x)) - (if (apply (primitive eq?) - (apply (primitive struct-vtable) (toplevel x)) - (toplevel B)) - (apply (toplevel bar) (toplevel x)) - (if (apply (primitive eq?) - (apply (primitive struct-vtable) (toplevel x)) - (toplevel C)) - (apply (toplevel baz) (toplevel x)) - (apply (lexical failure _))))) - (apply (lexical failure _))))) + (call (toplevel qux) (toplevel x)))))) + (if (primcall struct? (toplevel x)) + (if (primcall eq? + (primcall struct-vtable (toplevel x)) + (toplevel A)) + (call (toplevel foo) (toplevel x)) + (if (primcall eq? + (primcall struct-vtable (toplevel x)) + (toplevel B)) + (call (toplevel bar) (toplevel x)) + (if (primcall eq? + (primcall struct-vtable (toplevel x)) + (toplevel C)) + (call (toplevel baz) (toplevel x)) + (call (lexical failure _))))) + (call (lexical failure _))))) ;; Multiple common tests should get lifted as well. - (pass-if-peval resolve-primitives + (pass-if-peval (if (and (struct? x) (eq? (struct-vtable x) A) B) (foo x) (if (and (struct? x) (eq? (struct-vtable x) A) C) @@ -1195,32 +1208,32 @@ (let (failure) (_) ((lambda _ (lambda-case ((() #f #f #f () ()) - (apply (toplevel qux) (toplevel x)))))) - (if (apply (primitive struct?) (toplevel x)) - (if (apply (primitive eq?) - (apply (primitive struct-vtable) (toplevel x)) - (toplevel A)) + (call (toplevel qux) (toplevel x)))))) + (if (primcall struct? (toplevel x)) + (if (primcall eq? + (primcall struct-vtable (toplevel x)) + (toplevel A)) (if (toplevel B) - (apply (toplevel foo) (toplevel x)) + (call (toplevel foo) (toplevel x)) (if (toplevel C) - (apply (toplevel bar) (toplevel x)) + (call (toplevel bar) (toplevel x)) (if (toplevel D) - (apply (toplevel baz) (toplevel x)) - (apply (lexical failure _))))) - (apply (lexical failure _))) - (apply (lexical failure _))))) + (call (toplevel baz) (toplevel x)) + (call (lexical failure _))))) + (call (lexical failure _))) + (call (lexical failure _))))) - (pass-if-peval resolve-primitives + (pass-if-peval (apply (lambda (x y) (cons x y)) '(1 2)) - (apply (primitive cons) (const 1) (const 2))) + (primcall cons (const 1) (const 2))) - (pass-if-peval resolve-primitives + (pass-if-peval (apply (lambda (x y) (cons x y)) (list 1 2)) - (apply (primitive cons) (const 1) (const 2))) + (primcall cons (const 1) (const 2))) - (pass-if-peval resolve-primitives + (pass-if-peval (let ((t (make-prompt-tag))) (call-with-prompt t (lambda () (abort-to-prompt t 1 2 3)) (lambda (k x y z) (list x y z)))) - (apply (primitive 'list) (const 1) (const 2) (const 3)))) + (primcall list (const 1) (const 2) (const 3)))) diff --git a/test-suite/tests/procprop.test b/test-suite/tests/procprop.test index ceb6e562b..9407791f7 100644 --- a/test-suite/tests/procprop.test +++ b/test-suite/tests/procprop.test @@ -72,10 +72,4 @@ (pass-if "opt, eval" (equal? (procedure-minimum-arity (eval '(lambda* (a b #:optional c) #t) (current-module))) - '(2 1 #f))) - - (if (include-deprecated-features) - (pass-if-exception "set-procedure-properties! arity" - '(misc-error . "arity is a read-only property") - (set-procedure-properties! (lambda x x) '((arity . 3)))) - #t)) + '(2 1 #f)))) diff --git a/test-suite/tests/r6rs-ports.test b/test-suite/tests/r6rs-ports.test index ed4959826..3e36cca57 100644 --- a/test-suite/tests/r6rs-ports.test +++ b/test-suite/tests/r6rs-ports.test @@ -693,9 +693,6 @@ (put-string tp "The letter λ cannot be represented in Latin-1.") #f)))) - (pass-if "port-transcoder [binary port]" - (not (port-transcoder (open-bytevector-input-port #vu8())))) - (pass-if "port-transcoder [transcoded port]" (let* ((p (transcoded-port (open-bytevector-input-port (string->utf8 "foo")) (make-transcoder (utf-8-codec)))) diff --git a/test-suite/tests/r6rs-records-syntactic.test b/test-suite/tests/r6rs-records-syntactic.test index 9f9d37368..edc88aa72 100644 --- a/test-suite/tests/r6rs-records-syntactic.test +++ b/test-suite/tests/r6rs-records-syntactic.test @@ -30,12 +30,14 @@ (define-record-type simple-rtd) (define-record-type (specified-rtd specified-rtd-constructor specified-rtd-predicate)) -(define-record-type parent-rtd (fields x y)) +;; Can't be named as `parent-rtd', as that shadows the `parent-rtd' +;; literal. +(define-record-type *parent-rtd (fields x y)) (define-record-type child-parent-rtd-rtd - (parent-rtd (record-type-descriptor parent-rtd) - (record-constructor-descriptor parent-rtd)) + (parent-rtd (record-type-descriptor *parent-rtd) + (record-constructor-descriptor *parent-rtd)) (fields z)) -(define-record-type child-parent-rtd (parent parent-rtd) (fields z)) +(define-record-type child-parent-rtd (parent *parent-rtd) (fields z)) (define-record-type mutable-fields-rtd (fields (mutable mutable-bar) (mutable mutable-baz mutable-baz-accessor mutable-baz-mutator))) @@ -69,10 +71,10 @@ (defined? 'specified-rtd-constructor))) (pass-if "parent-rtd clause includes specified parent" - (eq? (record-type-parent child-parent-rtd-rtd) parent-rtd)) + (eq? (record-type-parent child-parent-rtd-rtd) *parent-rtd)) (pass-if "parent clause includes specified parent" - (eq? (record-type-parent child-parent-rtd) parent-rtd)) + (eq? (record-type-parent child-parent-rtd) *parent-rtd)) (pass-if "protocol clause includes specified protocol" (let ((protocol-record (make-protocol-rtd 1 2))) diff --git a/test-suite/tests/regexp.test b/test-suite/tests/regexp.test index b5c59f030..6799423fc 100644 --- a/test-suite/tests/regexp.test +++ b/test-suite/tests/regexp.test @@ -153,6 +153,8 @@ (with-latin1-locale body ...) (begin body ...))))) +(define char-code-limit 256) + ;; Since `regexp-quote' uses string ports, and since it is used below ;; with non-ASCII characters, these ports must be Unicode-capable. (define-syntax with-unicode diff --git a/test-suite/tests/syntax.test b/test-suite/tests/syntax.test index cdaee716b..e55cba11e 100644 --- a/test-suite/tests/syntax.test +++ b/test-suite/tests/syntax.test @@ -842,7 +842,73 @@ (pass-if-syntax-error "(define)" exception:generic-syncase-error (eval '(define) - (interaction-environment))))) + (interaction-environment)))) + + (pass-if "module scoping" + (equal? + (eval + '(begin + (define-module (top-level-define/module-scoping-1) + #:export (define-10)) + (define-syntax-rule (define-10 name) + (begin + (define t 10) + (define (name) t))) + (define-module (top-level-define/module-scoping-2) + #:use-module (top-level-define/module-scoping-1)) + (define-10 foo) + (foo)) + (current-module)) + 10)) + + (pass-if "module scoping, same symbolic name" + (equal? + (eval + '(begin + (define-module (top-level-define/module-scoping-3)) + (define a 10) + (define-module (top-level-define/module-scoping-4) + #:use-module (top-level-define/module-scoping-3)) + (define a (@@ (top-level-define/module-scoping-3) a)) + a) + (current-module)) + 10)) + + (pass-if "module scoping, introduced names" + (equal? + (eval + '(begin + (define-module (top-level-define/module-scoping-5) + #:export (define-constant)) + (define-syntax-rule (define-constant name val) + (begin + (define t val) + (define (name) t))) + (define-module (top-level-define/module-scoping-6) + #:use-module (top-level-define/module-scoping-5)) + (define-constant foo 10) + (define-constant bar 20) + (foo)) + (current-module)) + 10)) + + (pass-if "module scoping, duplicate introduced name" + (equal? + (eval + '(begin + (define-module (top-level-define/module-scoping-7) + #:export (define-constant)) + (define-syntax-rule (define-constant name val) + (begin + (define t val) + (define (name) t))) + (define-module (top-level-define/module-scoping-8) + #:use-module (top-level-define/module-scoping-7)) + (define-constant foo 10) + (define-constant foo 20) + (foo)) + (current-module)) + 20))) (with-test-prefix "internal define" diff --git a/test-suite/tests/tree-il.test b/test-suite/tests/tree-il.test index 2217ffcf2..6d501ec1c 100644 --- a/test-suite/tests/tree-il.test +++ b/test-suite/tests/tree-il.test @@ -89,62 +89,62 @@ (with-test-prefix "eqv?" (pass-if-primitives-resolved - (apply (primitive eqv?) (const #f) (toplevel x)) - (apply (primitive eq?) (const #f) (toplevel x))) + (primcall eqv? (toplevel x) (const #f)) + (primcall eq? (const #f) (toplevel x))) (pass-if-primitives-resolved - (apply (primitive eqv?) (const ()) (toplevel x)) - (apply (primitive eq?) (const ()) (toplevel x))) + (primcall eqv? (toplevel x) (const ())) + (primcall eq? (const ()) (toplevel x))) (pass-if-primitives-resolved - (apply (primitive eqv?) (const #t) (lexical x y)) - (apply (primitive eq?) (const #t) (lexical x y))) + (primcall eqv? (const #t) (lexical x y)) + (primcall eq? (const #t) (lexical x y))) (pass-if-primitives-resolved - (apply (primitive eqv?) (const this-is-a-symbol) (toplevel x)) - (apply (primitive eq?) (const this-is-a-symbol) (toplevel x))) + (primcall eqv? (const this-is-a-symbol) (toplevel x)) + (primcall eq? (const this-is-a-symbol) (toplevel x))) (pass-if-primitives-resolved - (apply (primitive eqv?) (const 42) (toplevel x)) - (apply (primitive eq?) (const 42) (toplevel x))) + (primcall eqv? (const 42) (toplevel x)) + (primcall eq? (const 42) (toplevel x))) (pass-if-primitives-resolved - (apply (primitive eqv?) (const 42.0) (toplevel x)) - (apply (primitive eqv?) (const 42.0) (toplevel x))) + (primcall eqv? (const 42.0) (toplevel x)) + (primcall eqv? (const 42.0) (toplevel x))) (pass-if-primitives-resolved - (apply (primitive eqv?) (const #nil) (toplevel x)) - (apply (primitive eq?) (const #nil) (toplevel x)))) + (primcall eqv? (const #nil) (toplevel x)) + (primcall eq? (const #nil) (toplevel x)))) (with-test-prefix "equal?" (pass-if-primitives-resolved - (apply (primitive equal?) (const #f) (toplevel x)) - (apply (primitive eq?) (const #f) (toplevel x))) + (primcall equal? (toplevel x) (const #f)) + (primcall eq? (const #f) (toplevel x))) (pass-if-primitives-resolved - (apply (primitive equal?) (const ()) (toplevel x)) - (apply (primitive eq?) (const ()) (toplevel x))) + (primcall equal? (toplevel x) (const ())) + (primcall eq? (const ()) (toplevel x))) (pass-if-primitives-resolved - (apply (primitive equal?) (const #t) (lexical x y)) - (apply (primitive eq?) (const #t) (lexical x y))) + (primcall equal? (const #t) (lexical x y)) + (primcall eq? (const #t) (lexical x y))) (pass-if-primitives-resolved - (apply (primitive equal?) (const this-is-a-symbol) (toplevel x)) - (apply (primitive eq?) (const this-is-a-symbol) (toplevel x))) + (primcall equal? (const this-is-a-symbol) (toplevel x)) + (primcall eq? (const this-is-a-symbol) (toplevel x))) (pass-if-primitives-resolved - (apply (primitive equal?) (const 42) (toplevel x)) - (apply (primitive eq?) (const 42) (toplevel x))) + (primcall equal? (const 42) (toplevel x)) + (primcall eq? (const 42) (toplevel x))) (pass-if-primitives-resolved - (apply (primitive equal?) (const 42.0) (toplevel x)) - (apply (primitive equal?) (const 42.0) (toplevel x))) + (primcall equal? (const 42.0) (toplevel x)) + (primcall equal? (const 42.0) (toplevel x))) (pass-if-primitives-resolved - (apply (primitive equal?) (const #nil) (toplevel x)) - (apply (primitive eq?) (const #nil) (toplevel x))))) + (primcall equal? (const #nil) (toplevel x)) + (primcall eq? (const #nil) (toplevel x))))) (with-test-prefix "tree-il->scheme" @@ -161,15 +161,15 @@ (begin (void) (const 1)) (program () (std-prelude 0 0 #f) (label _) (const 1) (call return 1))) (assert-tree-il->glil - (apply (primitive +) (void) (const 1)) + (primcall + (void) (const 1)) (program () (std-prelude 0 0 #f) (label _) (void) (call add1 1) (call return 1)))) (with-test-prefix "application" (assert-tree-il->glil - (apply (toplevel foo) (const 1)) + (call (toplevel foo) (const 1)) (program () (std-prelude 0 0 #f) (label _) (toplevel ref foo) (const 1) (call tail-call 1))) (assert-tree-il->glil - (begin (apply (toplevel foo) (const 1)) (void)) + (begin (call (toplevel foo) (const 1)) (void)) (program () (std-prelude 0 0 #f) (label _) (call new-frame 0) (toplevel ref foo) (const 1) (mv-call 1 ,l1) (call drop 1) (branch br ,l2) (label ,l3) (mv-bind 0 #f) @@ -177,7 +177,7 @@ (void) (call return 1)) (and (eq? l1 l3) (eq? l2 l4))) (assert-tree-il->glil - (apply (toplevel foo) (apply (toplevel bar))) + (call (toplevel foo) (call (toplevel bar))) (program () (std-prelude 0 0 #f) (label _) (toplevel ref foo) (call new-frame 0) (toplevel ref bar) (call call 0) (call tail-call 1)))) @@ -196,7 +196,7 @@ (eq? l1 l3) (eq? l2 l4)) (assert-tree-il->glil - (apply (primitive null?) (if (toplevel foo) (const 1) (const 2))) + (primcall null? (if (toplevel foo) (const 1) (const 2))) (program () (std-prelude 0 0 #f) (label _) (toplevel ref foo) (branch br-if-not ,l1) (const 1) (branch br ,l2) (label ,l3) (const 2) (label ,l4) @@ -213,7 +213,7 @@ (program () (std-prelude 0 0 #f) (label _) (const #f) (call return 1))) (assert-tree-il->glil - (apply (primitive null?) (primitive +)) + (primcall null? (primitive +)) (program () (std-prelude 0 0 #f) (label _) (toplevel ref +) (call null? 1) (call return 1)))) @@ -233,7 +233,7 @@ (unbind))) (assert-tree-il->glil without-partial-evaluation - (let (x) (y) ((const 1)) (apply (primitive null?) (lexical x y))) + (let (x) (y) ((const 1)) (primcall null? (lexical x y))) (program () (std-prelude 0 1 #f) (label _) (const 1) (bind (x #f 0)) (lexical #t #f set 0) (lexical #t #f ref 0) (call null? 1) (call return 1) @@ -243,7 +243,7 @@ (assert-tree-il->glil ;; unreferenced sets may be optimized away -- make sure they are ref'd (let (x) (y) ((const 1)) - (set! (lexical x y) (apply (primitive 1+) (lexical x y)))) + (set! (lexical x y) (primcall 1+ (lexical x y)))) (program () (std-prelude 0 1 #f) (label _) (const 1) (bind (x #t 0)) (lexical #t #t box 0) (lexical #t #t ref 0) (call add1 1) (lexical #t #t set 0) @@ -252,7 +252,7 @@ (assert-tree-il->glil (let (x) (y) ((const 1)) - (begin (set! (lexical x y) (apply (primitive 1+) (lexical x y))) + (begin (set! (lexical x y) (primcall 1+ (lexical x y))) (lexical x y))) (program () (std-prelude 0 1 #f) (label _) (const 1) (bind (x #t 0)) (lexical #t #t box 0) @@ -262,8 +262,8 @@ (assert-tree-il->glil (let (x) (y) ((const 1)) - (apply (primitive null?) - (set! (lexical x y) (apply (primitive 1+) (lexical x y))))) + (primcall null? + (set! (lexical x y) (primcall 1+ (lexical x y))))) (program () (std-prelude 0 1 #f) (label _) (const 1) (bind (x #t 0)) (lexical #t #t box 0) (lexical #t #t ref 0) (call add1 1) (lexical #t #t set 0) (void) @@ -284,7 +284,7 @@ (const #f) (call return 1))) (assert-tree-il->glil - (apply (primitive null?) (@ (foo) bar)) + (primcall null? (@ (foo) bar)) (program () (std-prelude 0 0 #f) (label _) (module public ref (foo) bar) (call null? 1) (call return 1))) @@ -302,7 +302,7 @@ (const #f) (call return 1))) (assert-tree-il->glil - (apply (primitive null?) (@@ (foo) bar)) + (primcall null? (@@ (foo) bar)) (program () (std-prelude 0 0 #f) (label _) (module private ref (foo) bar) (call null? 1) (call return 1)))) @@ -321,7 +321,7 @@ (const #f) (call return 1))) (assert-tree-il->glil - (apply (primitive null?) (set! (@ (foo) bar) (const 2))) + (primcall null? (set! (@ (foo) bar) (const 2))) (program () (std-prelude 0 0 #f) (label _) (const 2) (module public set (foo) bar) (void) (call null? 1) (call return 1))) @@ -339,7 +339,7 @@ (const #f) (call return 1))) (assert-tree-il->glil - (apply (primitive null?) (set! (@@ (foo) bar) (const 2))) + (primcall null? (set! (@@ (foo) bar) (const 2))) (program () (std-prelude 0 0 #f) (label _) (const 2) (module private set (foo) bar) (void) (call null? 1) (call return 1)))) @@ -358,7 +358,7 @@ (const #f) (call return 1))) (assert-tree-il->glil - (apply (primitive null?) (toplevel bar)) + (primcall null? (toplevel bar)) (program () (std-prelude 0 0 #f) (label _) (toplevel ref bar) (call null? 1) (call return 1)))) @@ -377,7 +377,7 @@ (const #f) (call return 1))) (assert-tree-il->glil - (apply (primitive null?) (set! (toplevel bar) (const 2))) + (primcall null? (set! (toplevel bar) (const 2))) (program () (std-prelude 0 0 #f) (label _) (const 2) (toplevel set bar) (void) (call null? 1) (call return 1)))) @@ -396,7 +396,7 @@ (const #f) (call return 1))) (assert-tree-il->glil - (apply (primitive null?) (define bar (const 2))) + (primcall null? (define bar (const 2))) (program () (std-prelude 0 0 #f) (label _) (const 2) (toplevel define bar) (void) (call null? 1) (call return 1)))) @@ -414,7 +414,7 @@ (assert-tree-il->glil ;; This gets simplified by `peval'. - (apply (primitive null?) (const 2)) + (primcall null? (const 2)) (program () (std-prelude 0 0 #f) (label _) (const #f) (call return 1)))) @@ -422,7 +422,7 @@ ;; simple bindings -> let (assert-tree-il->glil without-partial-evaluation (letrec (x y) (x1 y1) ((const 10) (const 20)) - (apply (toplevel foo) (lexical x x1) (lexical y y1))) + (call (toplevel foo) (lexical x x1) (lexical y y1))) (program () (std-prelude 0 2 #f) (label _) (const 10) (const 20) (bind (x #f 0) (y #f 1)) @@ -434,8 +434,8 @@ ;; complex bindings -> box and set! within let (assert-tree-il->glil without-partial-evaluation - (letrec (x y) (x1 y1) ((apply (toplevel foo)) (apply (toplevel bar))) - (apply (primitive +) (lexical x x1) (lexical y y1))) + (letrec (x y) (x1 y1) ((call (toplevel foo)) (call (toplevel bar))) + (primcall + (lexical x x1) (lexical y y1))) (program () (std-prelude 0 4 #f) (label _) (void) (void) ;; what are these? (bind (x #t 0) (y #t 1)) @@ -452,8 +452,8 @@ ;; complex bindings in letrec* -> box and set! in order (assert-tree-il->glil without-partial-evaluation - (letrec* (x y) (x1 y1) ((apply (toplevel foo)) (apply (toplevel bar))) - (apply (primitive +) (lexical x x1) (lexical y y1))) + (letrec* (x y) (x1 y1) ((call (toplevel foo)) (call (toplevel bar))) + (primcall + (lexical x x1) (lexical y y1))) (program () (std-prelude 0 2 #f) (label _) (void) (void) ;; what are these? (bind (x #t 0) (y #t 1)) @@ -572,38 +572,38 @@ (assert-tree-il->glil ;; This gets simplified by `peval'. - (apply (primitive null?) (begin (const #f) (const 2))) + (primcall null? (begin (const #f) (const 2))) (program () (std-prelude 0 0 #f) (label _) (const #f) (call return 1)))) (with-test-prefix "values" (assert-tree-il->glil - (apply (primitive values) - (apply (primitive values) (const 1) (const 2))) + (primcall values + (primcall values (const 1) (const 2))) (program () (std-prelude 0 0 #f) (label _) (const 1) (call return 1))) (assert-tree-il->glil - (apply (primitive values) - (apply (primitive values) (const 1) (const 2)) - (const 3)) + (primcall values + (primcall values (const 1) (const 2)) + (const 3)) (program () (std-prelude 0 0 #f) (label _) (const 1) (const 3) (call return/values 2))) (assert-tree-il->glil - (apply (primitive +) - (apply (primitive values) (const 1) (const 2))) + (primcall + + (primcall values (const 1) (const 2))) (program () (std-prelude 0 0 #f) (label _) (const 1) (call return 1))) ;; Testing `(values foo)' in push context with RA. (assert-tree-il->glil without-partial-evaluation - (apply (primitive cdr) - (letrec (lp) (#{lp ~V9KrhVD4PFEL6oCTrLg3A}#) - ((lambda ((name . lp)) - (lambda-case ((() #f #f #f () ()) - (apply (toplevel values) (const (one two))))))) - (apply (lexical lp #{lp ~V9KrhVD4PFEL6oCTrLg3A}#)))) + (primcall cdr + (letrec (lp) (#{lp ~V9KrhVD4PFEL6oCTrLg3A}#) + ((lambda ((name . lp)) + (lambda-case ((() #f #f #f () ()) + (primcall values (const (one two))))))) + (call (lexical lp #{lp ~V9KrhVD4PFEL6oCTrLg3A}#)))) (program () (std-prelude 0 0 #f) (label _) (branch br _) ;; entering the fix, jump to :2 ;; :1 body of lp, jump to :3 @@ -651,10 +651,10 @@ (with-test-prefix "apply" (assert-tree-il->glil - (apply (primitive @apply) (toplevel foo) (toplevel bar)) + (primcall @apply (toplevel foo) (toplevel bar)) (program () (std-prelude 0 0 #f) (label _) (toplevel ref foo) (toplevel ref bar) (call tail-apply 2))) (assert-tree-il->glil - (begin (apply (primitive @apply) (toplevel foo) (toplevel bar)) (void)) + (begin (primcall @apply (toplevel foo) (toplevel bar)) (void)) (program () (std-prelude 0 0 #f) (label _) (call new-frame 0) (toplevel ref apply) (toplevel ref foo) (toplevel ref bar) (mv-call 2 ,l1) (call drop 1) (branch br ,l2) (label ,l3) (mv-bind 0 #f) @@ -662,7 +662,7 @@ (void) (call return 1)) (and (eq? l1 l3) (eq? l2 l4))) (assert-tree-il->glil - (apply (toplevel foo) (apply (toplevel @apply) (toplevel bar) (toplevel baz))) + (call (toplevel foo) (call (toplevel @apply) (toplevel bar) (toplevel baz))) (program () (std-prelude 0 0 #f) (label _) (toplevel ref foo) (call new-frame 0) (toplevel ref bar) (toplevel ref baz) (call apply 2) @@ -670,10 +670,10 @@ (with-test-prefix "call/cc" (assert-tree-il->glil - (apply (primitive @call-with-current-continuation) (toplevel foo)) + (primcall @call-with-current-continuation (toplevel foo)) (program () (std-prelude 0 0 #f) (label _) (toplevel ref foo) (call tail-call/cc 1))) (assert-tree-il->glil - (begin (apply (primitive @call-with-current-continuation) (toplevel foo)) (void)) + (begin (primcall @call-with-current-continuation (toplevel foo)) (void)) (program () (std-prelude 0 0 #f) (label _) (call new-frame 0) (toplevel ref call-with-current-continuation) (toplevel ref foo) (mv-call 1 ,l1) (call drop 1) (branch br ,l2) (label ,l3) (mv-bind 0 #f) @@ -681,8 +681,8 @@ (void) (call return 1)) (and (eq? l1 l3) (eq? l2 l4))) (assert-tree-il->glil - (apply (toplevel foo) - (apply (toplevel @call-with-current-continuation) (toplevel bar))) + (call (toplevel foo) + (call (toplevel @call-with-current-continuation) (toplevel bar))) (program () (std-prelude 0 0 #f) (label _) (toplevel ref foo) (toplevel ref bar) (call call/cc 1) @@ -732,9 +732,9 @@ '(lambda () (lambda-case (((x y) #f #f #f () (x1 y1)) - (apply (toplevel +) - (lexical x x1) - (lexical y y1))) + (call (toplevel +) + (lexical x x1) + (lexical y y1))) #f)))))) (and (equal? (map strip-source leaves) (list (make-lexical-ref #f 'y 'y1) diff --git a/test-suite/tests/vlist.test b/test-suite/tests/vlist.test index d939284c1..d9bbbebce 100644 --- a/test-suite/tests/vlist.test +++ b/test-suite/tests/vlist.test @@ -220,11 +220,11 @@ (and (fold (lambda (k v result) (and result (equal? (cons k v) - (vhash-assq k vh)))) + (vhash-assoc k vh)))) #t keys values) - (not (vhash-assq 'x vh))))) + (not (vhash-assoc 'x vh))))) (pass-if "vhash as vlist" (let* ((keys '(a b c d e f g h i)) diff --git a/test-suite/tests/weaks.test b/test-suite/tests/weaks.test index d0f6c5ef5..1d53fc422 100644 --- a/test-suite/tests/weaks.test +++ b/test-suite/tests/weaks.test @@ -1,5 +1,5 @@ ;;;; weaks.test --- tests guile's weaks -*- scheme -*- -;;;; Copyright (C) 1999, 2001, 2003, 2006, 2009, 2010, 2011 Free Software Foundation, Inc. +;;;; Copyright (C) 1999, 2001, 2003, 2006, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. ;;;; ;;;; This library is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Lesser General Public @@ -68,28 +68,28 @@ exception:wrong-type-arg (list->weak-vector 32))) - (with-test-prefix "make-weak-key-alist-vector" + (with-test-prefix "make-weak-key-hash-table" (pass-if "create" - (make-weak-key-alist-vector 17) + (make-weak-key-hash-table 17) #t) (pass-if-exception "bad-args" exception:wrong-type-arg - (make-weak-key-alist-vector '(bad arg)))) - (with-test-prefix "make-weak-value-alist-vector" + (make-weak-key-hash-table '(bad arg)))) + (with-test-prefix "make-weak-value-hash-table" (pass-if "create" - (make-weak-value-alist-vector 17) + (make-weak-value-hash-table 17) #t) (pass-if-exception "bad-args" exception:wrong-type-arg - (make-weak-value-alist-vector '(bad arg)))) + (make-weak-value-hash-table '(bad arg)))) - (with-test-prefix "make-doubly-weak-alist-vector" + (with-test-prefix "make-doubly-weak-hash-table" (pass-if "create" - (make-doubly-weak-alist-vector 17) + (make-doubly-weak-hash-table 17) #t) (pass-if-exception "bad-args" exception:wrong-type-arg - (make-doubly-weak-alist-vector '(bad arg))))) + (make-doubly-weak-hash-table '(bad arg))))) @@ -138,9 +138,9 @@ (or (not value) (equal? value initial-value))) - (let ((x (make-weak-key-alist-vector 17)) - (y (make-weak-value-alist-vector 17)) - (z (make-doubly-weak-alist-vector 17)) + (let ((x (make-weak-key-hash-table 17)) + (y (make-weak-value-hash-table 17)) + (z (make-doubly-weak-hash-table 17)) (test-key "foo") (test-value "bar")) (with-test-prefix @@ -232,6 +232,14 @@ (hash-set! t "foo" 1) (equal? (hash-ref t "foo") 1))) + (pass-if "hash-set!, weak key, returns value" + (let ((t (make-weak-value-hash-table)) + (val (string #\f #\o #\o))) + (eq? (hashq-set! t "bar" val) + (hashv-set! t "bar" val) + (hash-set! t "bar" val) + val))) + (pass-if "assoc can do anything" ;; Until 1.9.12, as hash table's custom ASSOC procedure was ;; called with the GC lock alloc held, which imposed severe diff --git a/test-suite/tests/web-response.test b/test-suite/tests/web-response.test index f9679f5e2..4f88aa67e 100644 --- a/test-suite/tests/web-response.test +++ b/test-suite/tests/web-response.test @@ -1,6 +1,6 @@ ;;;; web-response.test --- HTTP responses -*- mode: scheme; coding: utf-8; -*- ;;;; -;;;; Copyright (C) 2010, 2011, 2012 Free Software Foundation, Inc. +;;;; Copyright (C) 2010, 2011, 2012, 2013 Free Software Foundation, Inc. ;;;; ;;;; This library is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Lesser General Public @@ -113,7 +113,7 @@ consectetur adipisicing elit,\r (response-content-encoding r)) (pass-if-equal "response-body-port" - `("utf-8" ,body) + `("UTF-8" ,body) (with-fluids ((%default-port-encoding #f)) (let* ((r (read-response (open-input-string example-1))) (p (response-body-port r))) |