2011-03-16 Stefan Monnier * image.c (parse_image_spec): Use Ffunctionp. * lisp.h: Declare Ffunctionp. 2011-03-13 Stefan Monnier * eval.c (Ffunction): Use simpler format for closures. (Fcommandp, funcall_lambda): * doc.c (Fdocumentation, store_function_docstring): * data.c (Finteractive_form): Adjust to new closure format. 2011-03-11 Stefan Monnier * eval.c (Fprog1, Fprog2): Simplify and use XCDR/XCAR. (Fdefvar): Remove redundant SYMBOLP check. (Ffunctionp): Don't signal an error for undefined aliases. 2011-03-06 Stefan Monnier * bytecode.c (exec_byte_code): Remove old lexical binding slot handling and replace it with the a integer args-desc handling. * eval.c (funcall_lambda): Adjust arglist test accordingly. 2011-03-01 Stefan Monnier * callint.c (quotify_arg): Simplify the logic. (Fcall_interactively): Use lexical binding when evaluating the interactive spec of a lexically bound function. 2011-02-25 Stefan Monnier * eval.c (Qcurry): Remove. (funcall_funvec): Remove. (funcall_lambda): Move new byte-code handling to reduce impact. Treat all args as lexical in the case of lexbind. (Fcurry): Remove. * data.c (Qfunction_vector): Remove. (Ffunvecp): Remove. * lread.c (read1): Revert to calling make_byte_code here. (read_vector): Don't call make_byte_code any more. * lisp.h (enum pvec_type): Rename back to PVEC_COMPILED. (XSETCOMPILED): Rename back from XSETFUNVEC. (FUNVEC_SIZE): Remove. (FUNVEC_COMPILED_TAG_P, FUNVEC_COMPILED_P): Remove. (COMPILEDP): Rename back from FUNVECP. * fns.c (Felt): Remove unexplained FUNVEC check. * doc.c (Fdocumentation): Don't handle funvec. * alloc.c (make_funvec, Ffunvec): Remove. 2011-02-21 Stefan Monnier * bytecode.c (exec_byte_code): Change stack_ref and stack_set to use offsets relative to top rather than to bottom. * alloc.c (Fgarbage_collect): Don't mark the byte-stack redundantly. 2011-02-19 Stefan Monnier * window.c (Fsave_window_excursion): Remove. Moved to Lisp. (syms_of_window): Don't defsubr it. * window.h (Fsave_window_excursion): Don't declare it. * bytecode.c (exec_byte_code): Inline Fsave_window_excursion. 2011-02-17 Stefan Monnier * eval.c (Vinternal_interpreter_environment): Remove. (syms_of_eval): Do declare Vinternal_interpreter_environment as a global lisp var, but unintern it to hide it. (Fcommandp): * data.c (Finteractive_form): Understand `closure's. * bytecode.c (exec_byte_code): Fix handling of &rest. 2011-02-12 Stefan Monnier * bytecode.c (Bvec_ref, Bvec_set): Remove. (exec_byte_code): Don't handle them. 2010-12-27 Stefan Monnier * eval.c (Fdefvar): Record specialness before computing initial value. 2010-12-15 Stefan Monnier * eval.c (Feval): Add `lexical' argument. Adjust callers. (Ffuncall, eval_sub): Avoid goto. 2010-12-14 Stefan Monnier Try and be more careful about propagation of lexical environment. * eval.c (apply_lambda, funcall_lambda): Remove lexenv arg. (Feval): Always eval in the empty environment. (eval_sub): New function. Use it for all calls to Feval that should evaluate in the lexical environment of the caller. Pass `closure's as is to apply_lambda. (Ffuncall): Pass `closure's as is to funcall_lambda. (funcall_lambda): Extract lexenv for `closure's, when applicable. Also use lexical scoping for the &rest argument, if applicable. * lisp.h (eval_sub): Declare. * lread.c (readevalloop): Remove `evalfun' argument. * print.c (Fwith_output_to_temp_buffer): * data.c (Fsetq_default): Use eval_sub. 2010-12-13 Stefan Monnier Make the effect of (defvar foo) local. * eval.c (apply_lambda): Make static. Remove eval_flag arg. (Fsetq): Don't check declared_special. (Fdefun, Fdefmacro): Use Ffunction. (Fdefvar): Don't set declared_special for (defvar foo). (FletX): Check locally-special vars. Only do specbind once. (Flet): Check locally-special vars. (Feval): Don't check declared_special. (funcall_lambda): Check locally-special vars. * lisp.h (apply_lambda): Remove extern declaration. * lread.c (readevalloop): CSE. 2010-07-23 Andreas Schwab * eval.c (funcall_funvec): Replace bcopy by memcpy. 2010-06-18 Stefan Monnier * eval.c (Fspecial_variable_p): Rename from `specialp'. 2010-06-15 Stefan Monnier * bytecode.c (exec_byte_code): * eval.c (Ffunctionp): Fix up int/Lisp_Object confusions. 2008-04-23 Miles Bader * eval.c (Ffunctionp): Return nil for special forms. (Qunevalled): New variable. (syms_of_eval): Initialize it. 2007-10-18 Miles Bader * eval.c (FletX): Test the type of VARLIST rather than just !NILP. (Flet): Use XCAR instead of Fcar. 2007-10-16 Miles Bader * alloc.c (make_funvec, Fpurecopy): Set the pseudo-vector type. 2006-02-10 Miles Bader * eval.c (Ffunctionp): Supply new 2nd arg to Findirect_function. 2005-03-04 Miles Bader * eval.c (FletX): Update Vinterpreter_lexical_environment for each variable we bind, instead of all at once like `let'. 2004-08-09 Miles Bader Changes from merging the funvec patch: * eval.c (Feval, Ffuncall): Don't special-case vectors. (funcall_lambda): Use FUNVEC_SIZE. (Fcurry): Remove function. Merge funvec patch. 2004-05-20 Miles Bader * lisp.h: Declare make_funvec and Ffunvec. (enum pvec_type): Rename `PVEC_COMPILED' to `PVEC_FUNVEC'. (XSETFUNVEC): Rename from `XSETCOMPILED'. (FUNVEC_SIZE, FUNVEC_COMPILED_TAG_P, FUNVEC_COMPILED_P): New macros. (COMPILEDP): Define in terms of funvec macros. (FUNVECP, GC_FUNVECP): Rename from `COMPILEDP' & `GC_COMPILEDP'. (FUNCTIONP): Use FUNVECP instead of COMPILEDP. * alloc.c (make_funvec, funvec): New functions. (Fmake_byte_code): Make sure the first element is a list. * eval.c (Qcurry): New variable. (funcall_funvec, Fcurry): New functions. (syms_of_eval): Initialize them. (funcall_lambda): Handle non-bytecode funvec objects by calling funcall_funvec. (Ffuncall, Feval): Use FUNVECP insetad of COMPILEDP. * lread.c (read1): Return result of read_vector for `#[' syntax directly; read_vector now does any extra work required. (read_vector): Handle both funvec and byte-code objects, converting the type as necessary. `bytecodeflag' argument is now called `read_funvec'. * data.c (Ffunvecp): New function. * doc.c (Fdocumentation): Return nil for unknown funvecs. * fns.c (mapcar1, Felt, concat): Allow funvecs. * eval.c (Ffunctionp): Use `funvec' operators instead of `compiled' operators. * alloc.c (Fmake_byte_code, Fpurecopy, mark_object): Likewise. * keyboard.c (Fcommand_execute): Likewise. * image.c (parse_image_spec): Likewise. * fns.c (Flength, concat, internal_equal): Likewise. * data.c (Faref, Ftype_of): Likewise. * print.c (print_preprocess, print_object): Likewise. 2004-04-10 Miles Bader * eval.c (Fspecialp): New function. (syms_of_eval): Initialize it. 2004-04-03 Miles Bader * eval.c (Feval): If a variable isn't bound lexically, fall back to looking it up dynamically even if it isn't declared special. 2002-08-26 Miles Bader * bytecode.c (Fbyte_code): Fsub1 can GC, so protect it. 2002-06-12 Miles Bader Lexical binding changes to the byte-code interpreter: * bytecode.c (Bstack_ref, Bstack_set, Bstack_set2, Bvec_ref, Bvec_set) (BdiscardN): New constants. (exec_byte_code): Rename from `Fbyte_code'. Implement above new bytecodes. Add ARGS-TEMPLATE, NARGS and ARGS parameters, and optionally use them push initial args on the stack. (Fbyte_code): New function, just call `exec_byte_code'. Add additional optional arguments for `exec_byte_code'. (Qand_optional, Qand_rest): New extern declarations. * eval.c (Fcurry, Ffunctionp): New functions. (syms_of_eval): Initialize them. (funcall_lambda): Call `exec_byte_code' instead of Fbyte_code. If a compiled-function object has a `push-args' slot, call the byte-code interpreter without binding any arguments. (Ffuncall): Add support for curried functions. * lisp.h (Fbyte_code): Declare max-args as MANY. (exec_byte_code): New declaration. Lexical binding changes to the lisp interpreter: * lisp.h (struct Lisp_Symbol): Add `declared_special' field. (apply_lambda): Add new 3rd arg to decl. * alloc.c (Fmake_symbol): Initialize `declared_special' field. * eval.c (Vinterpreter_lexical_environment): New variable. (syms_of_eval): Initialize it. (Fsetq): Modify SYM's lexical binding if appropriate. (Ffunction): Return a closure if within a lexical environment. (Flet, FletX): Lexically bind non-defvar'd variables if inside a lexical environment. (Feval): Return lexical binding of variables, if they have one. Pass current lexical environment to embedded lambdas. Handle closures. (Ffuncall): Pass nil lexical environment to lambdas. Handle closures. (funcall_lambda): Add new LEXENV argument, and lexically bind arguments if it's non-nil. Bind `interpreter-lexenv' if it changed. (apply_lambda): Add new LEXENV argument and pass it to funcall_lambda. (Fdefvaralias, Fdefvar, Fdefconst): Mark the variable as special. (Qinternal_interpreter_environment, Qclosure): New constants. (syms_of_eval): Initialize them. (Fdefun, Fdefmacro): Use a closure if lexical binding is active. * lread.c (defvar_bool, defvar_lisp_nopro, defvar_per_buffer) (defvar_kboard, defvar_int): Mark the variable as special. (Vlexical_binding, Qlexical_binding): New variables. (syms_of_lread): Initialize them. (Fload): Bind `lexically-bound' to nil unless specified otherwise in the file header. (lisp_file_lexically_bound_p): New function. (Qinternal_interpreter_environment): New variable. * doc.c (Qclosure): New extern declaration. (Fdocumentation, store_function_docstring): Handle interpreted closures. ;; arch-tag: 7cf884aa-6b48-40cb-bfca-265a1e99b3c5