Mercurial > emacs

changeset 108395:e36c1160a378

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge from mainline.
author Katsumi Yamaoka <yamaoka@jpl.org>
date Sun, 10 Jan 2010 06:54:49 +0000
parents 1790c59702ec (current diff) a32698d5bb0c (diff)
children 842d29bdc9a5
files
diffstat 19 files changed, 1318 insertions(+), 155 deletions(-) [+]
line wrap: on
line diff
--- a/doc/man/ChangeLog	Sat Jan 09 09:37:44 2010 +0000
+++ b/doc/man/ChangeLog	Sun Jan 10 06:54:49 2010 +0000
@@ -1,3 +1,8 @@
+2010-01-09  Chong Yidong  <cyd@stupidchicken.com>
+
+	* emacs.1: Copyedits.  Update options -Q, -mm and --daemon.  Remove
+	deprecated --unibyte option.
+
 2009-06-21  Chong Yidong  <cyd@stupidchicken.com>
 
 	* Branch for 23.1.
--- a/doc/man/emacs.1	Sat Jan 09 09:37:44 2010 +0000
+++ b/doc/man/emacs.1	Sun Jan 10 06:54:49 2010 +0000
@@ -22,20 +22,15 @@
 written by the author of the original (PDP-10)
 .IR Emacs ,
 Richard Stallman.
-.br
+The user functionality of GNU Emacs encompasses everything other
+editors do, and it is easily extensible since its editing commands are
+written in Lisp.
+.PP
 The primary documentation of GNU Emacs is in the GNU Emacs Manual,
 which you can read using Info, either from Emacs or as a standalone
 program.
 Please look there for complete and up-to-date documentation.
-This man page is updated only when someone volunteers to do so; the
-Emacs maintainers' priority goal is to minimize the amount of time
-this man page takes away from other more useful projects.
-.br
-The user functionality of GNU Emacs encompasses
-everything other
-.I Emacs
-editors do, and it is easily extensible since its
-editing commands are written in Lisp.
+This man page is updated only when someone volunteers to do so.
 .PP
 .I Emacs
 has an extensive interactive help facility,
@@ -43,18 +38,12 @@
 .I Emacs
 windows and buffers.
 CTRL-h or F1 enters the Help facility.
-Help Tutorial (CTRL-h t) starts an interactive tutorial which can
+Help Tutorial (CTRL-h t) starts an interactive tutorial to quickly
 teach beginners the fundamentals of
-.I Emacs
-in a few minutes.
-Help Apropos (CTRL-h a) helps you
-find a command given its functionality, Help Character (CTRL-h c)
-describes a given character's effect, and Help Function (CTRL-h f)
-describes a given Lisp function specified by name.
-.PP
-.IR Emacs 's
-Undo can undo several steps of modification to your buffers, so it is
-easy to recover from editing mistakes.
+.I Emacs.
+Help Apropos (CTRL-h a) helps you find a command given its
+functionality, Help Key (CTRL-h k) describes a given key sequence, and
+Help Function (CTRL-h f) describes a given Lisp function.
 .PP
 .IR "GNU Emacs" 's
 many special packages handle mail reading (RMail) and sending (Mail),
@@ -63,16 +52,6 @@
 .I Emacs
 windows (Shell), running a Lisp read-eval-print loop
 (Lisp-Interaction-Mode), automated psychotherapy (Doctor), and much more.
-.PP
-There is an extensive reference manual, but
-users of other Emacses
-should have little trouble adapting even
-without a copy.
-Users new to
-.I Emacs
-will be able
-to use basic features fairly rapidly by studying the tutorial and
-using the self-documentation features.
 .
 .SS Emacs Options
 The following options are of general interest:
@@ -109,11 +88,9 @@
 .B \-\-no\-desktop
 Do not load a saved desktop.
 .TP
-.BR \-nl ", " \-\-no\-shared\-memory
-Do not use shared memory.
-.TP
 .BR \-Q ", " \-\-quick
-Equivalent to "\-q \-\-no\-site\-file \-\-no\-splash".
+Similar to "\-q \-\-no\-site\-file \-\-no\-splash".  Also, avoid
+processing X resources.
 .TP
 .B \-\-no\-splash
 Do not display a splash screen during start-up.
@@ -136,11 +113,11 @@
 as the terminal instead of using stdin/stdout.
 This must be the first argument specified in the command line.
 .TP
-.BR \-\-multibyte ", " \-\-no-unibyte
-Enable multibyte mode (enabled by default).
-.TP
-.BR \-\-unibyte ", " \-\-no-multibyte
-Enable unibyte mode.
+.B \-\-daemon
+Start Emacs as a daemon, enabling the Emacs server and disconnecting
+from the terminal.  You can then use the emacsclient command to
+connect to the server (see
+.BR emacsclient (1)).
 .TP
 .B \-\-version
 Display
@@ -151,7 +128,7 @@
 Display this help and exit.
 .RE
 .PP
-The following options are lisp-oriented
+The following options are Lisp-oriented
 (these options are processed in the order encountered):
 .RS
 .TP 8
@@ -176,7 +153,6 @@
 .B \-\-batch
 Edit in batch mode.
 The editor will send messages to stderr.
-This option must be the first in the argument list.
 You must use \-l and \-f options to specify files to execute
 and functions to call.
 .TP
@@ -309,6 +285,9 @@
 .BR \-fw ", " \-\-fullwidth
 Make the first frame as wide as the screen.
 .TP
+.BR \-mm ", " \-\-maximized
+Maximize the first frame, like "\-fw \-fh".
+.TP
 .BI \-fg " color\fR,\fP " \-\-foreground\-color " color"
 On color displays, set the color of the text.
 
@@ -349,7 +328,7 @@
 .BR \-nw ", " \-\-no\-window\-system
 Tell
 .I Emacs
-not to use its special interface to X.
+not to create a graphical frame.
 If you use this switch when invoking
 .I Emacs
 from an
@@ -547,54 +526,6 @@
 .I depth
 is the number of color planes.
 .RE
-.PP
-If you try to set color values while using a black and white display,
-the window's characteristics will default as follows:
-the foreground color will be set to black,
-the background color will be set to white,
-the border color will be set to grey,
-and the text and mouse cursors will be set to black.
-.
-.SS Using the Mouse
-.PP
-The following lists some of the mouse button bindings for the
-.I Emacs
-window under X11.
-.
-.RS
-.TS
-l l
-- -
-l l.
-MOUSE BUTTON	FUNCTION
-left	Set point.
-middle	Paste text.
-right	Cut text into X cut buffer.
-SHIFT-middle	Cut text into X cut buffer.
-SHIFT-right	Paste text.
-CTRL-middle	Cut text into X cut buffer and kill it.
-CTRL-right	T{
-Select this window, then split it into two windows.
-Same as typing CTRL\-x 2.
-T}
-.\" START DELETING HERE IF YOU'RE NOT USING X MENUS
-CTRL-SHIFT-left	T{
-X buffer menu \(em hold the buttons and keys
-down, wait for menu to appear, select buffer, and release.
-Move mouse out of menu and release to cancel.
-T}
-CTRL-SHIFT-middle	T{
-X help menu \(em pop up index card menu for Emacs help.
-T}
-.\" STOP DELETING HERE IF YOU'RE NOT USING X MENUS
-CTRL-SHIFT-right	T{
-Select window with mouse, and delete all other windows.
-Same as typing CTRL\-x 1.
-T}
-.\" STOP DELETING HERE IF YOU'RE NOT USING X
-.TE
-.RE
-.
 .
 .SH MANUALS
 You can order printed copies of the GNU Emacs Manual from the Free
@@ -705,15 +636,17 @@
 .SH AUTHORS
 .I Emacs
 was written by Richard Stallman and the Free Software Foundation.
-Joachim Martillo and Robert Krawitz added the X features.
+For detailed credits and acknowledgements, see the GNU Emacs manual.
+.
 .
 .
 .SH COPYING
 Copyright
 .if t \(co
 .if n (C)
-1995, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-      2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+1995, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+2009, 2010
+Free Software Foundation, Inc.
 .PP
 Permission is granted to make and distribute verbatim copies of this
 document provided the copyright notice and this permission notice are
--- a/lisp/ChangeLog	Sat Jan 09 09:37:44 2010 +0000
+++ b/lisp/ChangeLog	Sun Jan 10 06:54:49 2010 +0000
@@ -1,7 +1,46 @@
+2010-01-10  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+	* format.el (format-annotate-function): Only set
+	write-region-post-annotation-function after running to-fn so as not to
+	affect nested write-region calls (bug#5273).
+
+2010-01-10  Chong Yidong  <cyd@stupidchicken.com>
+
+	* cedet/semantic.el (semantic-new-buffer-setup-functions):
+	Add python parser.
+
+	* Makefile.in (ELCFILES): Add wisent/python-wy.el and
+	wisent/python.el.
+
+2010-01-10  Richard Kim  <emacs18@gmail.com>
+
+	* cedet/semantic/wisent/python-wy.el:
+	* cedet/semantic/wisent/python.el: New files.
+
+2010-01-09  Chong Yidong  <cyd@stupidchicken.com>
+
+	* man.el (Man-goto-section): Signal error if the section is not
+	found (Bug#5317).
+
+2010-01-09  Juanma Barranquero  <lekktu@gmail.com>
+
+	* vc-bzr.el (vc-bzr-working-revision): On Windows and MS-DOS, accept
+	URLs with a leading triple slash in the file: scheme.  (Bug#5345)
+
+2010-01-09  Chong Yidong  <cyd@stupidchicken.com>
+
+	* progmodes/compile.el: Don't treat compile-command as safe if
+	compilation-read-command might be nil (Bug#4218).
+
+2010-01-09  Jan Djärv  <jan.h.d@swipnet.se>
+
+	* startup.el (command-line-1): Use orig-argi to check for ignored X and
+	NS options.
+
 2010-01-08  Kenichi Handa  <handa@m17n.org>
 
-	* international/fontset.el (build-default-fontset-data): Exclude
-	characters in scripts kana, hangul, han, or cjk-misc.
+	* international/fontset.el (build-default-fontset-data):
+	Exclude characters in scripts kana, hangul, han, or cjk-misc.
 
 2010-01-07  Juanma Barranquero  <lekktu@gmail.com>
 
@@ -21,8 +60,8 @@
 
 2010-01-05  Tom Tromey  <tromey@redhat.com>
 
-	* progmodes/python.el (python-font-lock-keywords): Handle
-	qualified decorators (Bug#881).
+	* progmodes/python.el (python-font-lock-keywords):
+	Handle qualified decorators (Bug#881).
 
 2010-01-05  Dan Nicolaescu  <dann@ics.uci.edu>
 
@@ -31,8 +70,7 @@
 
 2010-01-05  Kenichi Handa  <handa@m17n.org>
 
-	* language/indian.el (malayalam-composable-pattern): Fix ZWNJ and
-	ZWJ.
+	* language/indian.el (malayalam-composable-pattern): Fix ZWNJ and ZWJ.
 
 2010-01-05  Dan Nicolaescu  <dann@ics.uci.edu>
 
@@ -57,8 +95,8 @@
 2010-01-02  Daniel Elliott  <danelliottster@gmail.com>  (tiny change)
 
 	* progmodes/octave-mod.el (octave-end-keywords)
-	(octave-block-begin-or-end-regexp, octave-block-match-alist): Add
-	"end" keyword (Bug#3061).
+	(octave-block-begin-or-end-regexp, octave-block-match-alist):
+	Add "end" keyword (Bug#3061).
 	(octave-end-as-array-index-p): New function.
 	(calculate-octave-indent): Use it.
 
@@ -88,18 +126,18 @@
 
 2010-01-02  Karl Fogel  <kfogel@red-bean.com>
 
-	* bookmark.el (bookmark-bmenu-select, bookmark-bmenu-1-window,
+	* bookmark.el (bookmark-bmenu-select, bookmark-bmenu-1-window)
 	(bookmark-bmenu-2-window, bookmark-bmenu-this-window)
 	(bookmark-bmenu-other-window, bookmark-bmenu-switch-other-window)
 	(bookmark-bmenu-show-annotation, bookmark-bmenu-edit-annotation)
 	(bookmark-bmenu-rename, bookmark-bmenu-locate)
-	(bookmark-bmenu-relocate, bookmark-bmenu-goto-bookmark): Remove
-	unnecessary calls to `bookmark-bmenu-ensure-position'.
+	(bookmark-bmenu-relocate, bookmark-bmenu-goto-bookmark):
+	Remove unnecessary calls to `bookmark-bmenu-ensure-position'.
 
 2010-01-02  Eli Zaretskii  <eliz@gnu.org>
 
-	* emacs-lisp/easy-mmode.el (define-globalized-minor-mode): Make
-	the lines in the generated doc string shorter.  (Bug#4668)
+	* emacs-lisp/easy-mmode.el (define-globalized-minor-mode):
+	Make the lines in the generated doc string shorter.  (Bug#4668)
 
 2010-01-02  Ryan Yeske  <rcyeske@gmail.com>
 
@@ -107,10 +145,10 @@
 
 2010-01-02  Eli Zaretskii  <eliz@gnu.org>
 
-	* Makefile.in (bzr-update): Renamed from cvs-update.
+	* Makefile.in (bzr-update): Rename from cvs-update.
 	(cvs-update): New target for backward compatibility.
 
-	* makefile.w32-in (bzr-update): Renamed from cvs-update.
+	* makefile.w32-in (bzr-update): Rename from cvs-update.
 	(cvs-update): New target for backward compatibility.
 
 2010-01-02  Karl Fogel  <kfogel@red-bean.com>
@@ -9732,7 +9770,7 @@
 ;; coding: utf-8
 ;; End:
 
-    Copyright (C) 2009  Free Software Foundation, Inc.
+    Copyright (C) 2009, 2010  Free Software Foundation, Inc.
 
   This file is part of GNU Emacs.
 
--- a/lisp/Makefile.in	Sat Jan 09 09:37:44 2010 +0000
+++ b/lisp/Makefile.in	Sun Jan 10 06:54:49 2010 +0000
@@ -419,6 +419,8 @@
 	$(lisp)/cedet/semantic/wisent/javascript.elc \
 	$(lisp)/cedet/semantic/wisent/javat-wy.elc \
 	$(lisp)/cedet/semantic/wisent/js-wy.elc \
+	$(lisp)/cedet/semantic/wisent/python-wy.elc \
+	$(lisp)/cedet/semantic/wisent/python.elc \
 	$(lisp)/cedet/semantic/wisent/wisent.elc \
 	$(lisp)/cedet/srecode.elc \
 	$(lisp)/cedet/srecode/args.elc \
--- a/lisp/cedet/semantic.el	Sat Jan 09 09:37:44 2010 +0000
+++ b/lisp/cedet/semantic.el	Sun Jan 10 06:54:49 2010 +0000
@@ -266,12 +266,13 @@
   :type 'hook)
 
 (defcustom semantic-new-buffer-setup-functions
-  '((js-mode . wisent-javascript-setup-parser)
-    (java-mode . wisent-java-default-setup)
-    (scheme-mode . semantic-default-scheme-setup)
-    (c-mode . semantic-default-c-setup)
+  '((c-mode . semantic-default-c-setup)
     (c++-mode . semantic-default-c-setup)
     (html-mode . semantic-default-html-setup)
+    (java-mode . wisent-java-default-setup)
+    (js-mode . wisent-javascript-setup-parser)
+    (python-mode . wisent-python-default-setup)
+    (scheme-mode . semantic-default-scheme-setup)
     (srecode-template-mode . srecode-template-setup-parser)
     (makefile-automake-mode . semantic-default-make-setup)
     (makefile-gmake-mode . semantic-default-make-setup)
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lisp/cedet/semantic/wisent/python-wy.el	Sun Jan 10 06:54:49 2010 +0000
@@ -0,0 +1,749 @@
+;;; semantic/wisent/python-wy.el --- Generated parser support file
+
+;; Copyright (C) 2002, 2003, 2004, 2007, 2010
+;; Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;
+;; This file was generated from the grammar file
+;; semantic/wisent/wisent-python.wy in the CEDET repository.
+
+;;; Code:
+
+(require 'semantic/lex)
+
+;;; Prologue
+;;
+
+;;; Declarations
+;;
+(defconst wisent-python-wy--keyword-table
+  (semantic-lex-make-keyword-table
+   '(("and" . AND)
+     ("assert" . ASSERT)
+     ("break" . BREAK)
+     ("class" . CLASS)
+     ("continue" . CONTINUE)
+     ("def" . DEF)
+     ("del" . DEL)
+     ("elif" . ELIF)
+     ("else" . ELSE)
+     ("except" . EXCEPT)
+     ("exec" . EXEC)
+     ("finally" . FINALLY)
+     ("for" . FOR)
+     ("from" . FROM)
+     ("global" . GLOBAL)
+     ("if" . IF)
+     ("import" . IMPORT)
+     ("in" . IN)
+     ("is" . IS)
+     ("lambda" . LAMBDA)
+     ("not" . NOT)
+     ("or" . OR)
+     ("pass" . PASS)
+     ("print" . PRINT)
+     ("raise" . RAISE)
+     ("return" . RETURN)
+     ("try" . TRY)
+     ("while" . WHILE)
+     ("yield" . YIELD))
+   '(("yield" summary "Create a generator function")
+     ("while" summary "Start a 'while' loop")
+     ("try" summary "Start of statements protected by exception handlers")
+     ("return" summary "Return from a function")
+     ("raise" summary "Raise an exception")
+     ("print" summary "Print each argument to standard output")
+     ("pass" summary "Statement that does nothing")
+     ("or" summary "Binary logical 'or' operator")
+     ("not" summary "Unary boolean negation operator")
+     ("is" summary "Binary operator that tests for object equality")
+     ("in" summary "Part of 'for' statement ")
+     ("import" summary "Load specified modules")
+     ("if" summary "Start 'if' conditional statement")
+     ("global" summary "Declare one or more symbols as global symbols")
+     ("from" summary "Modify behavior of 'import' statement")
+     ("for" summary "Start a 'for' loop")
+     ("finally" summary "Specify code to be executed after 'try' statements whether or not an exception occured")
+     ("exec" summary "Dynamically execute python code")
+     ("except" summary "Specify exception handlers along with 'try' keyword")
+     ("else" summary "Start the 'else' clause following an 'if' statement")
+     ("elif" summary "Shorthand for 'else if' following an 'if' statement")
+     ("del" summary "Delete specified objects, i.e., undo what assignment did")
+     ("def" summary "Define a new function")
+     ("continue" summary "Skip to the next interation of enclosing for or whilte loop")
+     ("class" summary "Define a new class")
+     ("break" summary "Terminate 'for' or 'while loop")
+     ("assert" summary "Raise AssertionError exception if <expr> is false")
+     ("and" summary "Logical AND binary operator ... ")))
+  "Table of language keywords.")
+
+(defconst wisent-python-wy--token-table
+  (semantic-lex-make-type-table
+   '(("symbol"
+      (NAME))
+     ("number"
+      (NUMBER_LITERAL))
+     ("string"
+      (STRING_LITERAL))
+     ("punctuation"
+      (BACKQUOTE . "`")
+      (ASSIGN . "=")
+      (COMMA . ",")
+      (SEMICOLON . ";")
+      (COLON . ":")
+      (BAR . "|")
+      (TILDE . "~")
+      (PERIOD . ".")
+      (MINUS . "-")
+      (PLUS . "+")
+      (MOD . "%")
+      (DIV . "/")
+      (MULT . "*")
+      (AMP . "&")
+      (GT . ">")
+      (LT . "<")
+      (HAT . "^")
+      (NE . "!=")
+      (LTGT . "<>")
+      (HATEQ . "^=")
+      (OREQ . "|=")
+      (AMPEQ . "&=")
+      (MODEQ . "%=")
+      (DIVEQ . "/=")
+      (MULTEQ . "*=")
+      (MINUSEQ . "-=")
+      (PLUSEQ . "+=")
+      (LE . "<=")
+      (GE . ">=")
+      (EQ . "==")
+      (EXPONENT . "**")
+      (GTGT . ">>")
+      (LTLT . "<<")
+      (DIVDIV . "//")
+      (DIVDIVEQ . "//=")
+      (EXPEQ . "**=")
+      (GTGTEQ . ">>=")
+      (LTLTEQ . "<<="))
+     ("close-paren"
+      (RBRACK . "]")
+      (RBRACE . "}")
+      (RPAREN . ")"))
+     ("open-paren"
+      (LBRACK . "[")
+      (LBRACE . "{")
+      (LPAREN . "("))
+     ("block"
+      (BRACK_BLOCK . "(LBRACK RBRACK)")
+      (BRACE_BLOCK . "(LBRACE RBRACE)")
+      (PAREN_BLOCK . "(LPAREN RPAREN)"))
+     ("indentation"
+      (INDENT_BLOCK . "(INDENT DEDENT)")
+      (DEDENT . "[^:INDENT:]")
+      (INDENT . "^\\s-+"))
+     ("newline"
+      (NEWLINE . "\n"))
+     ("charquote"
+      (BACKSLASH . "\\")))
+   '(("keyword" :declared t)
+     ("symbol" :declared t)
+     ("number" :declared t)
+     ("punctuation" :declared t)
+     ("block" :declared t)))
+  "Table of lexical tokens.")
+
+(defconst wisent-python-wy--parse-table
+  (progn
+    (eval-when-compile
+      (require 'semantic/wisent/comp))
+    (wisent-compile-grammar
+     '((BACKSLASH NEWLINE INDENT DEDENT INDENT_BLOCK PAREN_BLOCK BRACE_BLOCK BRACK_BLOCK LPAREN RPAREN LBRACE RBRACE LBRACK RBRACK LTLTEQ GTGTEQ EXPEQ DIVDIVEQ DIVDIV LTLT GTGT EXPONENT EQ GE LE PLUSEQ MINUSEQ MULTEQ DIVEQ MODEQ AMPEQ OREQ HATEQ LTGT NE HAT LT GT AMP MULT DIV MOD PLUS MINUS PERIOD TILDE BAR COLON SEMICOLON COMMA ASSIGN BACKQUOTE STRING_LITERAL NUMBER_LITERAL NAME AND ASSERT BREAK CLASS CONTINUE DEF DEL ELIF ELSE EXCEPT EXEC FINALLY FOR FROM GLOBAL IF IMPORT IN IS LAMBDA NOT OR PASS PRINT RAISE RETURN TRY WHILE YIELD)
+       nil
+       (goal
+	((NEWLINE))
+	((simple_stmt))
+	((compound_stmt)))
+       (simple_stmt
+	((small_stmt_list semicolon_opt NEWLINE)))
+       (small_stmt_list
+	((small_stmt))
+	((small_stmt_list SEMICOLON small_stmt)))
+       (small_stmt
+	((expr_stmt))
+	((print_stmt))
+	((del_stmt))
+	((pass_stmt))
+	((flow_stmt))
+	((import_stmt))
+	((global_stmt))
+	((exec_stmt))
+	((assert_stmt)))
+       (print_stmt
+	((PRINT print_stmt_trailer)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil))))
+       (print_stmt_trailer
+	((test_list_opt)
+	 nil)
+	((GTGT test trailing_test_list_with_opt_comma_opt)
+	 nil))
+       (trailing_test_list_with_opt_comma_opt
+	(nil)
+	((trailing_test_list comma_opt)
+	 nil))
+       (trailing_test_list
+	((COMMA test)
+	 nil)
+	((trailing_test_list COMMA test)
+	 nil))
+       (expr_stmt
+	((testlist expr_stmt_trailer)
+	 (if
+	     (and $2
+		  (stringp $1)
+		  (string-match "^\\(\\sw\\|\\s_\\)+$" $1))
+	     (wisent-raw-tag
+	      (semantic-tag-new-variable $1 nil nil))
+	   (wisent-raw-tag
+	    (semantic-tag-new-code $1 nil)))))
+       (expr_stmt_trailer
+	((augassign testlist))
+	((eq_testlist_zom)))
+       (eq_testlist_zom
+	(nil)
+	((eq_testlist_zom ASSIGN testlist)
+	 (identity $3)))
+       (augassign
+	((PLUSEQ))
+	((MINUSEQ))
+	((MULTEQ))
+	((DIVEQ))
+	((MODEQ))
+	((AMPEQ))
+	((OREQ))
+	((HATEQ))
+	((LTLTEQ))
+	((GTGTEQ))
+	((EXPEQ))
+	((DIVDIVEQ)))
+       (del_stmt
+	((DEL exprlist)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil))))
+       (exprlist
+	((expr_list comma_opt)
+	 nil))
+       (expr_list
+	((expr)
+	 nil)
+	((expr_list COMMA expr)
+	 nil))
+       (pass_stmt
+	((PASS)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil))))
+       (flow_stmt
+	((break_stmt))
+	((continue_stmt))
+	((return_stmt))
+	((raise_stmt))
+	((yield_stmt)))
+       (break_stmt
+	((BREAK)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil))))
+       (continue_stmt
+	((CONTINUE)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil))))
+       (return_stmt
+	((RETURN testlist_opt)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil))))
+       (testlist_opt
+	(nil)
+	((testlist)
+	 nil))
+       (yield_stmt
+	((YIELD testlist)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil))))
+       (raise_stmt
+	((RAISE zero_one_two_or_three_tests)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil))))
+       (zero_one_two_or_three_tests
+	(nil)
+	((test zero_one_or_two_tests)
+	 nil))
+       (zero_one_or_two_tests
+	(nil)
+	((COMMA test zero_or_one_comma_test)
+	 nil))
+       (zero_or_one_comma_test
+	(nil)
+	((COMMA test)
+	 nil))
+       (import_stmt
+	((IMPORT dotted_as_name_list)
+	 (wisent-raw-tag
+	  (semantic-tag-new-include $2 nil)))
+	((FROM dotted_name IMPORT star_or_import_as_name_list)
+	 (wisent-raw-tag
+	  (semantic-tag-new-include $2 nil))))
+       (dotted_as_name_list
+	((dotted_as_name))
+	((dotted_as_name_list COMMA dotted_as_name)))
+       (star_or_import_as_name_list
+	((MULT)
+	 nil)
+	((import_as_name_list)
+	 nil))
+       (import_as_name_list
+	((import_as_name)
+	 nil)
+	((import_as_name_list COMMA import_as_name)
+	 nil))
+       (import_as_name
+	((NAME name_name_opt)
+	 nil))
+       (dotted_as_name
+	((dotted_name name_name_opt)))
+       (name_name_opt
+	(nil)
+	((NAME NAME)
+	 nil))
+       (dotted_name
+	((NAME))
+	((dotted_name PERIOD NAME)
+	 (format "%s.%s" $1 $3)))
+       (global_stmt
+	((GLOBAL comma_sep_name_list)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil))))
+       (comma_sep_name_list
+	((NAME))
+	((comma_sep_name_list COMMA NAME)))
+       (exec_stmt
+	((EXEC expr exec_trailer)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil))))
+       (exec_trailer
+	(nil)
+	((IN test comma_test_opt)
+	 nil))
+       (comma_test_opt
+	(nil)
+	((COMMA test)
+	 nil))
+       (assert_stmt
+	((ASSERT test comma_test_opt)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil))))
+       (compound_stmt
+	((if_stmt))
+	((while_stmt))
+	((for_stmt))
+	((try_stmt))
+	((funcdef))
+	((class_declaration)))
+       (if_stmt
+	((IF test COLON suite elif_suite_pair_list else_suite_pair_opt)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil))))
+       (elif_suite_pair_list
+	(nil)
+	((elif_suite_pair_list ELIF test COLON suite)
+	 nil))
+       (else_suite_pair_opt
+	(nil)
+	((ELSE COLON suite)
+	 nil))
+       (suite
+	((simple_stmt)
+	 (list $1))
+	((NEWLINE indented_block)
+	 (progn $2)))
+       (indented_block
+	((INDENT_BLOCK)
+	 (semantic-parse-region
+	  (car $region1)
+	  (cdr $region1)
+	  'indented_block_body 1)))
+       (indented_block_body
+	((INDENT)
+	 nil)
+	((DEDENT)
+	 nil)
+	((simple_stmt))
+	((compound_stmt)))
+       (while_stmt
+	((WHILE test COLON suite else_suite_pair_opt)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil))))
+       (for_stmt
+	((FOR exprlist IN testlist COLON suite else_suite_pair_opt)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil))))
+       (try_stmt
+	((TRY COLON suite except_clause_suite_pair_list else_suite_pair_opt)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil)))
+	((TRY COLON suite FINALLY COLON suite)
+	 (wisent-raw-tag
+	  (semantic-tag-new-code $1 nil))))
+       (except_clause_suite_pair_list
+	((except_clause COLON suite)
+	 nil)
+	((except_clause_suite_pair_list except_clause COLON suite)
+	 nil))
+       (except_clause
+	((EXCEPT zero_one_or_two_test)
+	 nil))
+       (zero_one_or_two_test
+	(nil)
+	((test zero_or_one_comma_test)
+	 nil))
+       (funcdef
+	((DEF NAME function_parameter_list COLON suite)
+	 (wisent-raw-tag
+	  (semantic-tag-new-function $2 nil $3))))
+       (function_parameter_list
+	((PAREN_BLOCK)
+	 (let
+	     ((wisent-python-EXPANDING-block t))
+	   (semantic-parse-region
+	    (car $region1)
+	    (cdr $region1)
+	    'function_parameters 1))))
+       (function_parameters
+	((LPAREN)
+	 nil)
+	((RPAREN)
+	 nil)
+	((function_parameter COMMA))
+	((function_parameter RPAREN)))
+       (function_parameter
+	((fpdef_opt_test))
+	((MULT NAME)
+	 (wisent-raw-tag
+	  (semantic-tag-new-variable $2 nil nil)))
+	((EXPONENT NAME)
+	 (wisent-raw-tag
+	  (semantic-tag-new-variable $2 nil nil))))
+       (class_declaration
+	((CLASS NAME paren_class_list_opt COLON suite)
+	 (wisent-raw-tag
+	  (semantic-tag-new-type $2 $1 $5
+				 (cons $3 nil)))))
+       (paren_class_list_opt
+	(nil)
+	((paren_class_list)))
+       (paren_class_list
+	((PAREN_BLOCK)
+	 (let
+	     ((wisent-python-EXPANDING-block t))
+	   (mapcar 'semantic-tag-name
+		   (semantic-parse-region
+		    (car $region1)
+		    (cdr $region1)
+		    'paren_classes 1)))))
+       (paren_classes
+	((LPAREN)
+	 nil)
+	((RPAREN)
+	 nil)
+	((paren_class COMMA)
+	 (wisent-raw-tag
+	  (semantic-tag-new-variable $1 nil nil)))
+	((paren_class RPAREN)
+	 (wisent-raw-tag
+	  (semantic-tag-new-variable $1 nil nil))))
+       (paren_class
+	((dotted_name)))
+       (test
+	((test_test))
+	((lambdef)))
+       (test_test
+	((and_test))
+	((test_test OR and_test)
+	 nil))
+       (and_test
+	((not_test))
+	((and_test AND not_test)
+	 nil))
+       (not_test
+	((NOT not_test)
+	 nil)
+	((comparison)))
+       (comparison
+	((expr))
+	((comparison comp_op expr)
+	 nil))
+       (comp_op
+	((LT))
+	((GT))
+	((EQ))
+	((GE))
+	((LE))
+	((LTGT))
+	((NE))
+	((IN))
+	((NOT IN))
+	((IS))
+	((IS NOT)))
+       (expr
+	((xor_expr))
+	((expr BAR xor_expr)
+	 nil))
+       (xor_expr
+	((and_expr))
+	((xor_expr HAT and_expr)
+	 nil))
+       (and_expr
+	((shift_expr))
+	((and_expr AMP shift_expr)
+	 nil))
+       (shift_expr
+	((arith_expr))
+	((shift_expr shift_expr_operators arith_expr)
+	 nil))
+       (shift_expr_operators
+	((LTLT))
+	((GTGT)))
+       (arith_expr
+	((term))
+	((arith_expr plus_or_minus term)
+	 nil))
+       (plus_or_minus
+	((PLUS))
+	((MINUS)))
+       (term
+	((factor))
+	((term term_operator factor)
+	 nil))
+       (term_operator
+	((MULT))
+	((DIV))
+	((MOD))
+	((DIVDIV)))
+       (factor
+	((prefix_operators factor)
+	 nil)
+	((power)))
+       (prefix_operators
+	((PLUS))
+	((MINUS))
+	((TILDE)))
+       (power
+	((atom trailer_zom exponent_zom)
+	 (concat $1
+		 (if $2
+		     (concat " " $2 " ")
+		   "")
+		 (if $3
+		     (concat " " $3)
+		   ""))))
+       (trailer_zom
+	(nil)
+	((trailer_zom trailer)
+	 nil))
+       (exponent_zom
+	(nil)
+	((exponent_zom EXPONENT factor)
+	 nil))
+       (trailer
+	((PAREN_BLOCK)
+	 nil)
+	((BRACK_BLOCK)
+	 nil)
+	((PERIOD NAME)
+	 nil))
+       (atom
+	((PAREN_BLOCK)
+	 nil)
+	((BRACK_BLOCK)
+	 nil)
+	((BRACE_BLOCK)
+	 nil)
+	((BACKQUOTE testlist BACKQUOTE)
+	 nil)
+	((NAME))
+	((NUMBER_LITERAL))
+	((one_or_more_string)))
+       (test_list_opt
+	(nil)
+	((testlist)
+	 nil))
+       (testlist
+	((comma_sep_test_list comma_opt)))
+       (comma_sep_test_list
+	((test))
+	((comma_sep_test_list COMMA test)
+	 (format "%s, %s" $1 $3)))
+       (one_or_more_string
+	((STRING_LITERAL))
+	((one_or_more_string STRING_LITERAL)
+	 (concat $1 $2)))
+       (lambdef
+	((LAMBDA varargslist_opt COLON test)
+	 (format "%s %s" $1
+		 (or $2 ""))))
+       (varargslist_opt
+	(nil)
+	((varargslist)))
+       (varargslist
+	((fpdef_opt_test_list_comma_zom rest_args)
+	 (nconc $2 $1))
+	((fpdef_opt_test_list comma_opt)))
+       (rest_args
+	((MULT NAME multmult_name_opt)
+	 nil)
+	((EXPONENT NAME)
+	 nil))
+       (multmult_name_opt
+	(nil)
+	((COMMA EXPONENT NAME)
+	 (wisent-raw-tag
+	  (semantic-tag-new-variable $3 nil nil))))
+       (fpdef_opt_test_list_comma_zom
+	(nil)
+	((fpdef_opt_test_list_comma_zom fpdef_opt_test COMMA)
+	 (nconc $2 $1)))
+       (fpdef_opt_test_list
+	((fpdef_opt_test))
+	((fpdef_opt_test_list COMMA fpdef_opt_test)
+	 (nconc $3 $1)))
+       (fpdef_opt_test
+	((fpdef eq_test_opt)))
+       (fpdef
+	((NAME)
+	 (wisent-raw-tag
+	  (semantic-tag-new-variable $1 nil nil))))
+       (fplist
+	((fpdef_list comma_opt)))
+       (fpdef_list
+	((fpdef))
+	((fpdef_list COMMA fpdef)))
+       (eq_test_opt
+	(nil)
+	((ASSIGN test)
+	 nil))
+       (comma_opt
+	(nil)
+	((COMMA)))
+       (semicolon_opt
+	(nil)
+	((SEMICOLON))))
+     '(goal function_parameter paren_class indented_block function_parameters paren_classes indented_block_body)))
+  "Parser table.")
+
+(defun wisent-python-wy--install-parser ()
+  "Setup the Semantic Parser."
+  (semantic-install-function-overrides
+   '((parse-stream . wisent-parse-stream)))
+  (setq semantic-parser-name "LALR"
+	semantic--parse-table wisent-python-wy--parse-table
+	semantic-debug-parser-source "wisent-python.wy"
+	semantic-flex-keywords-obarray wisent-python-wy--keyword-table
+	semantic-lex-types-obarray wisent-python-wy--token-table)
+  ;; Collect unmatched syntax lexical tokens
+  (semantic-make-local-hook 'wisent-discarding-token-functions)
+  (add-hook 'wisent-discarding-token-functions
+	    'wisent-collect-unmatched-syntax nil t))
+
+
+;;; Analyzers
+
+(define-lex-keyword-type-analyzer wisent-python-wy--<keyword>-keyword-analyzer
+  "keyword analyzer for <keyword> tokens."
+  "\\(\\sw\\|\\s_\\)+")
+
+(define-lex-block-type-analyzer wisent-python-wy--<block>-block-analyzer
+  "block analyzer for <block> tokens."
+  "\\s(\\|\\s)"
+  '((("(" LPAREN PAREN_BLOCK)
+     ("{" LBRACE BRACE_BLOCK)
+     ("[" LBRACK BRACK_BLOCK))
+    (")" RPAREN)
+    ("}" RBRACE)
+    ("]" RBRACK))
+  )
+
+(define-lex-regex-type-analyzer wisent-python-wy--<symbol>-regexp-analyzer
+  "regexp analyzer for <symbol> tokens."
+  "\\(\\sw\\|\\s_\\)+"
+  nil
+  'NAME)
+
+(define-lex-regex-type-analyzer wisent-python-wy--<number>-regexp-analyzer
+  "regexp analyzer for <number> tokens."
+  semantic-lex-number-expression
+  nil
+  'NUMBER_LITERAL)
+
+(define-lex-string-type-analyzer wisent-python-wy--<punctuation>-string-analyzer
+  "string analyzer for <punctuation> tokens."
+  "\\(\\s.\\|\\s$\\|\\s'\\)+"
+  '((BACKQUOTE . "`")
+    (ASSIGN . "=")
+    (COMMA . ",")
+    (SEMICOLON . ";")
+    (COLON . ":")
+    (BAR . "|")
+    (TILDE . "~")
+    (PERIOD . ".")
+    (MINUS . "-")
+    (PLUS . "+")
+    (MOD . "%")
+    (DIV . "/")
+    (MULT . "*")
+    (AMP . "&")
+    (GT . ">")
+    (LT . "<")
+    (HAT . "^")
+    (NE . "!=")
+    (LTGT . "<>")
+    (HATEQ . "^=")
+    (OREQ . "|=")
+    (AMPEQ . "&=")
+    (MODEQ . "%=")
+    (DIVEQ . "/=")
+    (MULTEQ . "*=")
+    (MINUSEQ . "-=")
+    (PLUSEQ . "+=")
+    (LE . "<=")
+    (GE . ">=")
+    (EQ . "==")
+    (EXPONENT . "**")
+    (GTGT . ">>")
+    (LTLT . "<<")
+    (DIVDIV . "//")
+    (DIVDIVEQ . "//=")
+    (EXPEQ . "**=")
+    (GTGTEQ . ">>=")
+    (LTLTEQ . "<<="))
+  'punctuation)
+
+
+;;; Epilogue
+;;
+
+(provide 'semantic/wisent/python-wy)
+
+;;; semantic/wisent/python-wy.el ends here
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lisp/cedet/semantic/wisent/python.el	Sun Jan 10 06:54:49 2010 +0000
@@ -0,0 +1,344 @@
+;;; wisent-python.el --- Semantic support for Python
+
+;; Copyright (C) 2002, 2004, 2006, 2007, 2008, 2009, 2010
+;; Free Software Foundation, Inc.
+
+;; Author: Richard Kim  <emacs18@gmail.com>
+;; Maintainer: Richard Kim  <emacs18@gmail.com>
+;; Created: June 2002
+;; Keywords: syntax
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;
+;; Parser support for Python.
+
+;;; Code:
+
+(require 'semantic/wisent)
+(require 'semantic/wisent/python-wy)
+(require 'semantic/dep)
+(require 'semantic/ctxt)
+
+
+;;; Lexical analysis
+;;
+
+;; Python strings are delimited by either single quotes or double
+;; quotes, e.g., "I'm a string" and 'I too am s string'.
+;; In addition a string can have either a 'r' and/or 'u' prefix.
+;; The 'r' prefix means raw, i.e., normal backslash substitutions are
+;; to be suppressed.  For example, r"01\n34" is a string with six
+;; characters 0, 1, \, n, 3 and 4.  The 'u' prefix means the following
+;; string is a unicode.
+(defconst wisent-python-string-re
+  (concat (regexp-opt '("r" "u" "ur" "R" "U" "UR" "Ur" "uR") t)
+          "?['\"]")
+  "Regexp matching beginning of a python string.")
+
+(defvar wisent-python-EXPANDING-block nil
+  "Non-nil when expanding a paren block for Python lexical analyzer.")
+
+(defun wisent-python-implicit-line-joining-p ()
+  "Return non-nil if implicit line joining is active.
+That is, if inside an expressions in parentheses, square brackets or
+curly braces."
+  wisent-python-EXPANDING-block)
+
+(defsubst wisent-python-forward-string ()
+  "Move point at the end of the python string at point."
+  (when (looking-at wisent-python-string-re)
+     ;; skip the prefix
+    (and (match-end 1) (goto-char (match-end 1)))
+    ;; skip the quoted part
+    (cond
+     ((looking-at "\"\"\"[^\"]")
+      (search-forward "\"\"\"" nil nil 2))
+     ((looking-at "'''[^']")
+      (search-forward "'''" nil nil 2))
+     ((forward-sexp 1)))))
+
+(defun wisent-python-forward-line ()
+  "Move point to the beginning of the next logical line.
+Usually this is simply the next physical line unless strings,
+implicit/explicit line continuation, blank lines, or comment lines are
+encountered.  This function skips over such items so that the point is
+at the beginning of the next logical line.  If the current logical
+line ends at the end of the buffer, leave the point there."
+  (while (not (eolp))
+    (when (= (point)
+             (progn
+               (cond
+                ;; Skip over python strings.
+                ((looking-at wisent-python-string-re)
+                 (wisent-python-forward-string))
+                ;; At a comment start just goto end of line.
+                ((looking-at "\\s<")
+                 (end-of-line))
+                ;; Skip over generic lists and strings.
+                ((looking-at "\\(\\s(\\|\\s\"\\)")
+                 (forward-sexp 1))
+                ;; At the explicit line continuation character
+                ;; (backslash) move to next line.
+                ((looking-at "\\s\\")
+                 (forward-line 1))
+                ;; Skip over white space, word, symbol, punctuation,
+                ;; and paired delimiter (backquote) characters.
+                ((skip-syntax-forward "-w_.$)")))
+               (point)))
+      (error "python-forward-line endless loop detected")))
+  ;; The point is at eol, skip blank and comment lines.
+  (forward-comment (point-max))
+  ;; Goto the beginning of the next line.
+  (or (eobp) (beginning-of-line)))
+
+(defun wisent-python-forward-line-skip-indented ()
+  "Move point to the next logical line, skipping indented lines.
+That is the next line whose indentation is less than or equal to the
+identation of the current line."
+  (let ((indent (current-indentation)))
+    (while (progn (wisent-python-forward-line)
+                  (and (not (eobp))
+                       (> (current-indentation) indent))))))
+
+(defun wisent-python-end-of-block ()
+  "Move point to the end of the current block."
+  (let ((indent (current-indentation)))
+    (while (and (not (eobp)) (>= (current-indentation) indent))
+      (wisent-python-forward-line-skip-indented))
+    ;; Don't include final comments in current block bounds
+    (forward-comment (- (point-max)))
+    (or (bolp) (forward-line 1))
+    ))
+
+;; Indentation stack, what the Python (2.3) language spec. says:
+;;
+;; The indentation levels of consecutive lines are used to generate
+;; INDENT and DEDENT tokens, using a stack, as follows.
+;;
+;; Before the first line of the file is read, a single zero is pushed
+;; on the stack; this will never be popped off again. The numbers
+;; pushed on the stack will always be strictly increasing from bottom
+;; to top. At the beginning of each logical line, the line's
+;; indentation level is compared to the top of the stack. If it is
+;; equal, nothing happens. If it is larger, it is pushed on the stack,
+;; and one INDENT token is generated. If it is smaller, it must be one
+;; of the numbers occurring on the stack; all numbers on the stack
+;; that are larger are popped off, and for each number popped off a
+;; DEDENT token is generated. At the end of the file, a DEDENT token
+;; is generated for each number remaining on the stack that is larger
+;; than zero.
+(defvar wisent-python-indent-stack)
+
+(define-lex-analyzer wisent-python-lex-beginning-of-line
+  "Detect and create python indentation tokens at beginning of line."
+  (and
+   (bolp) (not (wisent-python-implicit-line-joining-p))
+   (let ((last-indent (car wisent-python-indent-stack))
+         (last-pos (point))
+         (curr-indent (current-indentation)))
+     (skip-syntax-forward "-")
+     (cond
+      ;; Skip comments and blank lines. No change in indentation.
+      ((or (eolp) (looking-at semantic-lex-comment-regex))
+       (forward-comment (point-max))
+       (or (eobp) (beginning-of-line))
+       (setq semantic-lex-end-point (point))
+       ;; Loop lexer to handle the next line.
+       t)
+      ;; No change in indentation.
+      ((= curr-indent last-indent)
+       (setq semantic-lex-end-point (point))
+       ;; Try next analyzers.
+       nil)
+      ;; Indentation increased
+      ((> curr-indent last-indent)
+       (if (or (not semantic-lex-maximum-depth)
+               (< semantic-lex-current-depth semantic-lex-maximum-depth))
+           (progn
+             ;; Return an INDENT lexical token
+             (setq semantic-lex-current-depth (1+ semantic-lex-current-depth))
+             (push curr-indent wisent-python-indent-stack)
+             (semantic-lex-push-token
+              (semantic-lex-token 'INDENT last-pos (point))))
+         ;; Add an INDENT_BLOCK token
+         (semantic-lex-push-token
+          (semantic-lex-token
+           'INDENT_BLOCK
+           (progn (beginning-of-line) (point))
+           (semantic-lex-unterminated-syntax-protection 'INDENT_BLOCK
+             (wisent-python-end-of-block)
+             (point)))))
+       ;; Loop lexer to handle tokens in current line.
+       t)
+      ;; Indentation decreased
+      (t
+       ;; Pop items from indentation stack
+       (while (< curr-indent last-indent)
+         (pop wisent-python-indent-stack)
+         (setq semantic-lex-current-depth (1- semantic-lex-current-depth)
+               last-indent (car wisent-python-indent-stack))
+         (semantic-lex-push-token
+          (semantic-lex-token 'DEDENT last-pos (point))))
+       ;; If pos did not change, then we must return nil so that
+       ;; other lexical analyzers can be run.
+       (/= last-pos (point))))))
+  ;; All the work was done in the above analyzer matching condition.
+  )
+
+(define-lex-regex-analyzer wisent-python-lex-end-of-line
+  "Detect and create python newline tokens.
+Just skip the newline character if the following line is an implicit
+continuation of current line."
+  "\\(\n\\|\\s>\\)"
+  (if (wisent-python-implicit-line-joining-p)
+      (setq semantic-lex-end-point (match-end 0))
+    (semantic-lex-push-token
+     (semantic-lex-token 'NEWLINE (point) (match-end 0)))))
+
+(define-lex-regex-analyzer wisent-python-lex-string
+  "Detect and create python string tokens."
+  wisent-python-string-re
+  (semantic-lex-push-token
+   (semantic-lex-token
+    'STRING_LITERAL
+    (point)
+    (semantic-lex-unterminated-syntax-protection 'STRING_LITERAL
+      (wisent-python-forward-string)
+      (point)))))
+
+(define-lex-regex-analyzer wisent-python-lex-ignore-backslash
+  "Detect and skip over backslash (explicit line joining) tokens.
+A backslash must be the last token of a physical line, it is illegal
+elsewhere on a line outside a string literal."
+  "\\s\\\\s-*$"
+  ;; Skip over the detected backslash and go to the first
+  ;; non-whitespace character in the next physical line.
+  (forward-line)
+  (skip-syntax-forward "-")
+  (setq semantic-lex-end-point (point)))
+
+(define-lex wisent-python-lexer
+  "Lexical Analyzer for Python code."
+  ;; Must analyze beginning of line first to handle indentation.
+  wisent-python-lex-beginning-of-line
+  wisent-python-lex-end-of-line
+  ;; Must analyze string before symbol to handle string prefix.
+  wisent-python-lex-string
+  ;; Analyzers auto-generated from grammar.
+  wisent-python-wy--<number>-regexp-analyzer
+  wisent-python-wy--<keyword>-keyword-analyzer
+  wisent-python-wy--<symbol>-regexp-analyzer
+  wisent-python-wy--<block>-block-analyzer
+  wisent-python-wy--<punctuation>-string-analyzer
+  ;; Ignored things.
+  wisent-python-lex-ignore-backslash
+  semantic-lex-ignore-whitespace
+  semantic-lex-ignore-comments
+  ;; Signal error on unhandled syntax.
+  semantic-lex-default-action)
+
+;;; Overridden Semantic API.
+;;
+(define-mode-local-override semantic-lex python-mode
+  (start end &optional depth length)
+  "Lexically analyze python code in current buffer.
+See the function `semantic-lex' for the meaning of the START, END,
+DEPTH and LENGTH arguments.
+This function calls `wisent-python-lexer' to actually perform the
+lexical analysis, then emits the necessary python DEDENT tokens from
+what remains in the `wisent-python-indent-stack'."
+  (let* ((wisent-python-indent-stack (list 0))
+         (stream (wisent-python-lexer start end depth length))
+         (semantic-lex-token-stream nil))
+    ;; Emit DEDENT tokens if something remains in the INDENT stack.
+    (while (> (pop wisent-python-indent-stack) 0)
+      (semantic-lex-push-token (semantic-lex-token 'DEDENT end end)))
+    (nconc stream (nreverse semantic-lex-token-stream))))
+
+(define-mode-local-override semantic-get-local-variables python-mode ()
+  "Get the local variables based on point's context.
+To be implemented for python!  For now just return nil."
+  nil)
+
+(defcustom-mode-local-semantic-dependency-system-include-path
+  python-mode semantic-python-dependency-system-include-path
+  nil
+  "The system include path used by Python langauge.")
+
+;;; Enable Semantic in `python-mode'.
+;;
+
+;;;###autoload
+(defun wisent-python-default-setup ()
+  "Setup buffer for parse."
+  (wisent-python-wy--install-parser)
+  (set (make-local-variable 'parse-sexp-ignore-comments) t)
+  (setq
+   ;; Character used to separation a parent/child relationship
+   semantic-type-relation-separator-character '(".")
+   semantic-command-separation-character ";"
+   ;; The following is no more necessary as semantic-lex is overriden
+   ;; in python-mode.
+   ;; semantic-lex-analyzer 'wisent-python-lexer
+
+   ;; Semantic to take over from the one provided by python.
+   ;; The python one, if it uses the senator advice, will hang
+   ;; Emacs unrecoverably.
+   imenu-create-index-function 'semantic-create-imenu-index
+
+   ;; I need a python guru to update this list:
+   semantic-symbol->name-assoc-list-for-type-parts '((variable . "Variables")
+						     (function . "Methods"))
+   semantic-symbol->name-assoc-list '((type . "Classes")
+				      (variable . "Variables")
+				      (function . "Functions")
+				      (include  . "Imports")
+				      (package  . "Package")
+				      (code . "Code")))
+   )
+
+;;;###autoload
+(add-hook 'python-mode-hook 'wisent-python-default-setup)
+
+;; Make sure the newer python modes pull in the same python
+;; mode overrides.
+(define-child-mode python-2-mode python-mode "Python 2 mode")
+(define-child-mode python-3-mode python-mode "Python 3 mode")
+
+
+;;; Test
+;;
+(defun wisent-python-lex-buffer ()
+  "Run `wisent-python-lexer' on current buffer."
+  (interactive)
+  (semantic-lex-init)
+  (let ((token-stream (semantic-lex (point-min) (point-max) 0)))
+    (with-current-buffer (get-buffer-create "*wisent-python-lexer*")
+      (erase-buffer)
+      (pp token-stream (current-buffer))
+      (goto-char (point-min))
+      (pop-to-buffer (current-buffer)))))
+
+(provide 'semantic/wisent/python)
+
+;; Local variables:
+;; generated-autoload-file: "../loaddefs.el"
+;; generated-autoload-load-name: "semantic/wisent/python"
+;; End:
+
+;;; semantic/wisent/python.el ends here
--- a/lisp/format.el	Sat Jan 09 09:37:44 2010 +0000
+++ b/lisp/format.el	Sun Jan 10 06:54:49 2010 +0000
@@ -222,9 +222,6 @@
 		  (multibyte enable-multibyte-characters)
 		  (coding-system buffer-file-coding-system))
 	      (with-current-buffer copy-buf
-		(set (make-local-variable
-		      'write-region-post-annotation-function)
-		     'kill-buffer)
 		(setq selective-display sel-disp)
 		(set-buffer-multibyte multibyte)
 		(setq buffer-file-coding-system coding-system))
@@ -232,6 +229,15 @@
 	      (set-buffer copy-buf)
 	      (format-insert-annotations write-region-annotations-so-far from)
 	      (format-encode-run-method to-fn (point-min) (point-max) orig-buf)
+              (when (buffer-live-p copy-buf)
+                (with-current-buffer copy-buf
+                  ;; Set write-region-post-annotation-function to
+                  ;; delete the buffer once the write is done, but do
+                  ;; it after running to-fn so it doesn't affect
+                  ;; write-region calls in to-fn.
+                  (set (make-local-variable
+                        'write-region-post-annotation-function)
+                       'kill-buffer)))
 	      nil)
 	  ;; Otherwise just call function, it will return annotations.
 	  (funcall to-fn from to orig-buf)))))
--- a/lisp/man.el	Sat Jan 09 09:37:44 2010 +0000
+++ b/lisp/man.el	Sun Jan 10 06:54:49 2010 +0000
@@ -1500,7 +1500,9 @@
 		  (string= chosen ""))
 	      default
 	    chosen)))
-  (Man-find-section (aheadsym Man-sections-alist)))
+  (unless (Man-find-section (aheadsym Man-sections-alist))
+    (error "Section not found")))
+
 
 (defun Man-goto-see-also-section ()
   "Move point to the \"SEE ALSO\" section.
--- a/lisp/progmodes/compile.el	Sat Jan 09 09:37:44 2010 +0000
+++ b/lisp/progmodes/compile.el	Sun Jan 10 06:54:49 2010 +0000
@@ -567,7 +567,12 @@
 
 (defcustom compilation-read-command t
   "Non-nil means \\[compile] reads the compilation command to use.
-Otherwise, \\[compile] just uses the value of `compile-command'."
+Otherwise, \\[compile] just uses the value of `compile-command'.
+
+Note that changing this to nil may be a security risk, because a
+file might define a malicious `compile-command' as a file local
+variable, and you might not notice.  Therefore, `compile-command'
+is considered unsafe if this variable is nil."
   :type 'boolean
   :group 'compilation)
 
@@ -603,7 +608,7 @@
 			(file-name-sans-extension buffer-file-name))))))"
   :type 'string
   :group 'compilation)
-;;;###autoload(put 'compile-command 'safe-local-variable 'stringp)
+;;;###autoload(put 'compile-command 'safe-local-variable (lambda (a) (and (stringp a) (or (not (boundp 'compilation-read-command)) compilation-read-command))))
 
 ;;;###autoload
 (defcustom compilation-disable-input nil
--- a/lisp/startup.el	Sat Jan 09 09:37:44 2010 +0000
+++ b/lisp/startup.el	Sun Jan 10 06:54:49 2010 +0000
@@ -2184,12 +2184,12 @@
 		   (setq cl1-line (string-to-number (match-string 1 argi))
 			 cl1-column (string-to-number (match-string 2 argi))))
 
-		  ((setq cl1-tem (assoc argi command-line-x-option-alist))
+		  ((setq cl1-tem (assoc orig-argi command-line-x-option-alist))
 		   ;; Ignore X-windows options and their args if not using X.
 		   (setq command-line-args-left
 			 (nthcdr (nth 1 cl1-tem) command-line-args-left)))
 
-		  ((setq cl1-tem (assoc argi command-line-ns-option-alist))
+		  ((setq cl1-tem (assoc orig-argi command-line-ns-option-alist))
 		   ;; Ignore NS-windows options and their args if not using NS.
 		   (setq command-line-args-left
 			 (nthcdr (nth 1 cl1-tem) command-line-args-left)))
--- a/lisp/vc-bzr.el	Sat Jan 09 09:37:44 2010 +0000
+++ b/lisp/vc-bzr.el	Sun Jan 10 06:54:49 2010 +0000
@@ -361,6 +361,11 @@
 		     ;; look there for the version information.
 		     (when (re-search-forward "file://\\(.+\\)" nil t)
 		       (let ((l-c-parent-dir (match-string 1)))
+			 (when (and (memq system-type '(ms-dos windows-nt))
+				    (string-match-p "^/[[:alpha:]]:" l-c-parent-dir))
+			   ;;; On Windows, file:// URLs often have three slashes,
+			   ;;; so we must remove the remaining one (bug#5345)
+			   (setq l-c-parent-dir (substring l-c-parent-dir 1)))
 			 (setq branch-format-file
 			       (expand-file-name vc-bzr-admin-branch-format-file
 						 l-c-parent-dir))
--- a/src/ChangeLog	Sat Jan 09 09:37:44 2010 +0000
+++ b/src/ChangeLog	Sun Jan 10 06:54:49 2010 +0000
@@ -1,3 +1,28 @@
+2010-01-09  Chong Yidong  <cyd@stupidchicken.com>
+
+	* intervals.h, textprop.c (extend_property_ranges): Return value
+	and args changed.  Discard properties that begin at or after the
+	new end (Bug#5306).
+
+	* editfns.c (Fformat): Caller changed.
+
+	* nsterm.m (ns_set_default_prefs): Delete function.
+	(syms_of_nsterm): Initialize ns_command_modifier,
+	ns_control_modifier, ns_function_modifier, ns_antialias_text, and
+	ns_antialias_threshold here, not in ns_term_init (Bug#4113).
+
+	* xdisp.c (pos_visible_p): Check for invisible text at the correct
+	position (Bug#4040).
+
+2010-01-09  Eli Zaretskii  <eliz@gnu.org>
+
+	* editfns.c (Ffloat_time): Doc fix.
+
+2010-01-09  Jan Djärv  <jan.h.d@swipnet.se>
+
+	* xfns.c (Fx_create_frame): Don't create frame larger than display
+	by default bug#3643.
+
 2010-01-09  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
 
 	* frame.h (FRAME_TOP_MARGIN_HEIGHT): New macro.
--- a/src/editfns.c	Sat Jan 09 09:37:44 2010 +0000
+++ b/src/editfns.c	Sun Jan 10 06:54:49 2010 +0000
@@ -1574,7 +1574,8 @@
 have the form (HIGH . LOW), but this is considered obsolete.
 
 WARNING: Since the result is floating point, it may not be exact.
-Do not use this function if precise time stamps are required.  */)
+If precise time stamps are required, use either `current-time',
+or (if you need time as a string) `format-time-string'.  */)
      (specified_time)
      Lisp_Object specified_time;
 {
@@ -4176,8 +4177,8 @@
 	      len = make_number (SCHARS (args[n]));
 	      new_len = make_number (info[n].end - info[n].start);
 	      props = text_property_list (args[n], make_number (0), len, Qnil);
-	      extend_property_ranges (props, len, new_len);
-	      /* If successive arguments have properites, be sure that
+	      props = extend_property_ranges (props, new_len);
+	      /* If successive arguments have properties, be sure that
 		 the value of `composition' property be the copy.  */
 	      if (n > 1 && info[n - 1].end)
 		make_composition_value_copy (props);
--- a/src/intervals.h	Sat Jan 09 09:37:44 2010 +0000
+++ b/src/intervals.h	Sun Jan 10 06:54:49 2010 +0000
@@ -335,7 +335,7 @@
 Lisp_Object text_property_list P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
 				    Lisp_Object));
 int add_text_properties_from_list P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
-void extend_property_ranges P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
+Lisp_Object extend_property_ranges P_ ((Lisp_Object, Lisp_Object));
 Lisp_Object get_char_property_and_overlay P_ ((Lisp_Object, Lisp_Object,
 					       Lisp_Object, Lisp_Object*));
 extern int text_property_stickiness P_ ((Lisp_Object prop, Lisp_Object pos,
--- a/src/nsterm.m	Sat Jan 09 09:37:44 2010 +0000
+++ b/src/nsterm.m	Sun Jan 10 06:54:49 2010 +0000
@@ -3479,22 +3479,6 @@
 
 
 static void
-ns_set_default_prefs ()
-/* --------------------------------------------------------------------------
-      Initialize preference variables to defaults
-   -------------------------------------------------------------------------- */
-{
-  ns_alternate_modifier = Qmeta;
-  ns_command_modifier = Qsuper;
-  ns_control_modifier = Qcontrol;
-  ns_function_modifier = Qnone;
-  ns_antialias_text = Qt;
-  ns_antialias_threshold = 10.0; /* not exposed to lisp side */
-  ns_confirm_quit = Qnil;
-}
-
-
-static void
 ns_default (const char *parameter, Lisp_Object *result,
            Lisp_Object yesval, Lisp_Object noval,
            BOOL is_float, BOOL is_modstring)
@@ -3756,8 +3740,6 @@
 
   UNBLOCK_INPUT; 
 
-  /* Read various user defaults. */
-  ns_set_default_prefs ();
   if (!inhibit_x_resources)
     {
       ns_default ("GSFontAntiAlias", &ns_antialias_text,
@@ -6159,6 +6141,9 @@
 syms_of_nsterm ()
 {
   NSTRACE (syms_of_nsterm);
+
+  ns_antialias_threshold = 10.0;
+
   DEFVAR_LISP ("ns-input-file", &ns_input_file,
               "The file specified in the last NS event.");
   ns_input_file =Qnil;
@@ -6200,26 +6185,32 @@
 Set to control, meta, alt, super, or hyper means it is taken to be that key.\n\
 Set to none means that the alternate / option key is not interpreted by Emacs\n\
 at all, allowing it to be used at a lower level for accented character entry.");
+  ns_alternate_modifier = Qmeta;
 
   DEFVAR_LISP ("ns-command-modifier", &ns_command_modifier,
                "This variable describes the behavior of the command key.\n\
 Set to control, meta, alt, super, or hyper means it is taken to be that key.");
+  ns_command_modifier = Qsuper;
 
   DEFVAR_LISP ("ns-control-modifier", &ns_control_modifier,
                "This variable describes the behavior of the control key.\n\
 Set to control, meta, alt, super, or hyper means it is taken to be that key.");
+  ns_control_modifier = Qcontrol;
 
   DEFVAR_LISP ("ns-function-modifier", &ns_function_modifier,
                "This variable describes the behavior of the function key (on laptops).\n\
 Set to control, meta, alt, super, or hyper means it is taken to be that key.\n\
 Set to none means that the function key is not interpreted by Emacs at all,\n\
 allowing it to be used at a lower level for accented character entry.");
+  ns_function_modifier = Qnone;
 
   DEFVAR_LISP ("ns-antialias-text", &ns_antialias_text,
                "Non-nil (the default) means to render text antialiased. Only has an effect on OS X Panther and above.");
+  ns_antialias_text = Qt;
 
   DEFVAR_LISP ("ns-confirm-quit", &ns_confirm_quit,
                "Whether to confirm application quit using dialog.");
+  ns_confirm_quit = Qnil;
 
   staticpro (&ns_display_name_list);
   ns_display_name_list = Qnil;
--- a/src/textprop.c	Sat Jan 09 09:37:44 2010 +0000
+++ b/src/textprop.c	Sun Jan 10 06:54:49 2010 +0000
@@ -2028,24 +2028,41 @@
 
 
 
-/* Modify end-points of ranges in LIST destructively.  LIST is a list
-   as returned from text_property_list.  Change end-points equal to
-   OLD_END to NEW_END.  */
+/* Modify end-points of ranges in LIST destructively, and return the
+   new list.  LIST is a list as returned from text_property_list.
+   Discard properties that begin at or after NEW_END, and limit
+   end-points to NEW_END.  */
 
-void
-extend_property_ranges (list, old_end, new_end)
-     Lisp_Object list, old_end, new_end;
+Lisp_Object
+extend_property_ranges (list, new_end)
+     Lisp_Object list, new_end;
 {
-  for (; CONSP (list); list = XCDR (list))
+  Lisp_Object prev = Qnil, head = list;
+  int max = XINT (new_end);
+
+  for (; CONSP (list); prev = list, list = XCDR (list))
     {
-      Lisp_Object item, end;
+      Lisp_Object item, beg, end;
 
       item = XCAR (list);
+      beg = XCAR (item);
       end = XCAR (XCDR (item));
 
-      if (EQ (end, old_end))
+      if (XINT (beg) >= max)
+	{
+	  /* The start-point is past the end of the new string.
+	     Discard this property.  */
+	  if (EQ (head, list))
+	    head = XCDR (list);
+	  else
+	    XSETCDR (prev, XCDR (list));
+	}
+      else if (XINT (end) > max)
+	/* The end-point is past the end of the new string.  */
 	XSETCAR (XCDR (item), new_end);
     }
+
+  return head;
 }
 
 
--- a/src/xdisp.c	Sat Jan 09 09:37:44 2010 +0000
+++ b/src/xdisp.c	Sun Jan 10 06:54:49 2010 +0000
@@ -1363,7 +1363,7 @@
       int top_x = it.current_x;
       int top_y = it.current_y;
       enum it_method it_method = it.method;
-      /* Calling line_bottom_y may change it.method.  */
+      /* Calling line_bottom_y may change it.method, it.position, etc.  */
       int bottom_y = (last_height = 0, line_bottom_y (&it));
       int window_top_y = WINDOW_HEADER_LINE_HEIGHT (w);
 
@@ -1378,7 +1378,7 @@
 	      Lisp_Object window, prop;
 
 	      XSETWINDOW (window, w);
-	      prop = Fget_char_property (make_number (it.position.charpos),
+	      prop = Fget_char_property (make_number (charpos),
 					 Qinvisible, window);
 
 	      /* If charpos coincides with invisible text covered with an
--- a/src/xfns.c	Sat Jan 09 09:37:44 2010 +0000
+++ b/src/xfns.c	Sun Jan 10 06:54:49 2010 +0000
@@ -3396,6 +3396,45 @@
   /* Compute the size of the X window.  */
   window_prompting = x_figure_window_size (f, parms, 1);
 
+  /* Don't make height higher than display height unless the user asked
+     for it.  */
+  height = FRAME_LINES (f);
+  tem = x_get_arg (dpyinfo, parms, Qheight, 0, 0, RES_TYPE_NUMBER);
+  if (EQ (tem, Qunbound))
+    {
+      int ph = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, FRAME_LINES (f));
+      int dph = DisplayHeight (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f));
+      if (ph > dph)
+        {
+          height = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, dph) -
+            FRAME_TOOL_BAR_LINES (f) - FRAME_MENU_BAR_LINES (f);
+          if (FRAME_EXTERNAL_TOOL_BAR (f))
+            height -= 2; /* We can't know how big it will be.  */
+          if (FRAME_EXTERNAL_MENU_BAR (f))
+            height -= 2; /* We can't know how big it will be.  */
+        }
+    }
+
+  /* Don't make width wider than display width unless the user asked
+     for it.  */
+  width = FRAME_COLS (f);
+  tem = x_get_arg (dpyinfo, parms, Qwidth, 0, 0, RES_TYPE_NUMBER);
+  if (EQ (tem, Qunbound))
+    {
+      int pw = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, FRAME_COLS (f));
+      int dpw = DisplayWidth (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f));
+      if (pw > dpw)
+        width = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, dpw);
+    }
+
+  if (height != FRAME_LINES (f) || width != FRAME_COLS (f))
+    {
+      check_frame_size (f, &height, &width);
+      FRAME_LINES (f) = height;
+      SET_FRAME_COLS (f, width);
+    }
+  
+
   tem = x_get_arg (dpyinfo, parms, Qunsplittable, 0, 0, RES_TYPE_BOOLEAN);
   f->no_split = minibuffer_only || EQ (tem, Qt);