# Bazaar merge directive format 2 (Bazaar 0.90)
# revision_id: lists@cheimes.de-20080325192634-4rs2uv0txvcej1bs
# target_branch: file:///home/heimes/dev/python/bzr/trunk/
# testament_sha1: 52033cb930a8aaa8afe26a210a097420f5ac4b95
# timestamp: 2008-03-25 20:41:14 +0100
# base_revision_id: svn-v3-trunk1:6015fed2-1504-0410-9fe1-\
#   9d1591cc4771:python%2Ftrunk:61892
# 
# Begin patch
=== modified file 'Include/code.h'
--- Include/code.h	2008-03-18 23:45:49 +0000
+++ Include/code.h	2008-03-25 12:30:54 +0000
@@ -49,6 +49,7 @@
 #define CO_FUTURE_ABSOLUTE_IMPORT 0x4000 /* do absolute imports by default */
 #define CO_FUTURE_WITH_STATEMENT  0x8000
 #define CO_FUTURE_PRINT_FUNCTION  0x10000
+#define CO_FUTURE_UNICODE_LITERALS 0x20000
 
 /* This should be defined if a future statement modifies the syntax.
    For example, when a keyword is added.

=== modified file 'Include/compile.h'
--- Include/compile.h	2008-03-18 23:45:49 +0000
+++ Include/compile.h	2008-03-25 12:30:54 +0000
@@ -25,6 +25,7 @@
 #define FUTURE_ABSOLUTE_IMPORT "absolute_import"
 #define FUTURE_WITH_STATEMENT "with_statement"
 #define FUTURE_PRINT_FUNCTION "print_function"
+#define FUTURE_UNICODE_LITERALS "unicode_literals"
 
 
 struct _mod; /* Declare the existence of this type */

=== modified file 'Include/parsetok.h'
--- Include/parsetok.h	2008-03-18 23:45:49 +0000
+++ Include/parsetok.h	2008-03-25 12:30:54 +0000
@@ -28,6 +28,7 @@
 #endif
 
 #define PyPARSE_PRINT_IS_FUNCTION       0x0004
+#define PyPARSE_UNICODE_LITERALS         0x0008
 
 
 
@@ -41,11 +42,18 @@
 PyAPI_FUNC(node *) PyParser_ParseFileFlags(FILE *, const char *, grammar *,
 						 int, char *, char *,
 						 perrdetail *, int);
+PyAPI_FUNC(node *) PyParser_ParseFileFlagsEx(FILE *, const char *, grammar *,
+						 int, char *, char *,
+						 perrdetail *, int *);
 
 PyAPI_FUNC(node *) PyParser_ParseStringFlagsFilename(const char *,
 					      const char *,
 					      grammar *, int,
                                               perrdetail *, int);
+PyAPI_FUNC(node *) PyParser_ParseStringFlagsFilenameEx(const char *,
+					      const char *,
+					      grammar *, int,
+                                              perrdetail *, int *);
 
 /* Note that he following function is defined in pythonrun.c not parsetok.c. */
 PyAPI_FUNC(void) PyParser_SetError(perrdetail *);

=== modified file 'Include/pythonrun.h'
--- Include/pythonrun.h	2008-03-18 23:45:49 +0000
+++ Include/pythonrun.h	2008-03-25 12:30:54 +0000
@@ -8,7 +8,8 @@
 #endif
 
 #define PyCF_MASK (CO_FUTURE_DIVISION | CO_FUTURE_ABSOLUTE_IMPORT | \
-                   CO_FUTURE_WITH_STATEMENT|CO_FUTURE_PRINT_FUNCTION)
+                   CO_FUTURE_WITH_STATEMENT | CO_FUTURE_PRINT_FUNCTION | \
+                   CO_FUTURE_UNICODE_LITERALS)
 #define PyCF_MASK_OBSOLETE (CO_NESTED)
 #define PyCF_SOURCE_IS_UTF8  0x0100
 #define PyCF_DONT_IMPLY_DEDENT 0x0200

=== modified file 'Lib/__future__.py'
--- Lib/__future__.py	2008-03-18 23:45:49 +0000
+++ Lib/__future__.py	2008-03-25 12:32:55 +0000
@@ -54,6 +54,7 @@
     "absolute_import",
     "with_statement",
     "print_function",
+    "unicode_literals",
 ]
 
 __all__ = ["all_feature_names"] + all_feature_names
@@ -68,6 +69,7 @@
 CO_FUTURE_ABSOLUTE_IMPORT = 0x4000 # perform absolute imports by default
 CO_FUTURE_WITH_STATEMENT  = 0x8000   # with statement
 CO_FUTURE_PRINT_FUNCTION  = 0x10000   # print function
+CO_FUTURE_UNICODE_LITERALS = 0x20000 # unicode string literals
 
 class _Feature:
     def __init__(self, optionalRelease, mandatoryRelease, compiler_flag):
@@ -120,3 +122,7 @@
 print_function = _Feature((2, 6, 0, "alpha", 2),
                           (3, 0, 0, "alpha", 0),
                           CO_FUTURE_PRINT_FUNCTION)
+
+unicode_literals = _Feature((2, 6, 0, "alpha", 2),
+                            (3, 0, 0, "alpha", 0),
+                            CO_FUTURE_UNICODE_LITERALS)

=== added file 'Lib/test/test_future4.py'
--- Lib/test/test_future4.py	1970-01-01 00:00:00 +0000
+++ Lib/test/test_future4.py	2008-03-25 12:30:54 +0000
@@ -0,0 +1,24 @@
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import unittest
+from test import test_support
+
+class TestFuture(unittest.TestCase):
+    def assertType(self, obj, typ):
+        self.assert_(type(obj) is typ, 
+            "type(%r) is %r, not %r" % (obj, type(obj), typ))
+
+    def test_unicode_strings(self):
+        self.assertType("", unicode)
+        self.assertType(r"", unicode)
+        self.assertType(u"", unicode)
+        self.assertType(ur"", unicode)
+        self.assertType(b"", str)
+        self.assertType(br"", str)
+
+def test_main():
+    test_support.run_unittest(TestFuture)
+
+if __name__ == "__main__":
+    test_main()

=== modified file 'Misc/NEWS'
--- Misc/NEWS	2008-03-25 14:33:23 +0000
+++ Misc/NEWS	2008-03-25 17:04:13 +0000
@@ -12,6 +12,8 @@
 Core and builtins
 -----------------
 
+- Patch #2477: Added from __future__ import unicode_literals
+ 
 - Issue #2355: add Py3k warning for buffer().
 
 - Issue #1477: With narrow Unicode builds, the unicode escape sequence
@@ -178,6 +180,12 @@
 
 - Patch #2284: Add -x64 option to rt.bat.
 
+C API
+-----
+
+- Patch #2477: Added PyParser_ParseFileFlagsEx() and 
+  PyParser_ParseStringFlagsFilenameEx()
+
 What's New in Python 2.6 alpha 1?
 =================================
 

=== modified file 'Parser/parser.c'
--- Parser/parser.c	2008-03-18 23:45:49 +0000
+++ Parser/parser.c	2008-03-25 12:30:54 +0000
@@ -202,14 +202,18 @@
 	
 	for (i = 0; i < NCH(ch); i += 2) {
 		cch = CHILD(ch, i);
-		if (NCH(cch) >= 1 && TYPE(CHILD(cch, 0)) == NAME &&
-		    strcmp(STR(CHILD(cch, 0)), "with_statement") == 0) {
-			ps->p_flags |= CO_FUTURE_WITH_STATEMENT;
-			break;
-		} else if (NCH(cch) >= 1 && TYPE(CHILD(cch, 0)) == NAME &&
-		    strcmp(STR(CHILD(cch, 0)), "print_function") == 0) {
-			ps->p_flags |= CO_FUTURE_PRINT_FUNCTION;
-			break;
+		if (NCH(cch) >= 1 && TYPE(CHILD(cch, 0)) == NAME) {
+			char *str_ch = STR(CHILD(cch, 0));
+			if (strcmp(str_ch, FUTURE_WITH_STATEMENT) == 0) {
+				ps->p_flags |= CO_FUTURE_WITH_STATEMENT;
+				break;
+			} else if (strcmp(str_ch, FUTURE_PRINT_FUNCTION) == 0) {
+				ps->p_flags |= CO_FUTURE_PRINT_FUNCTION;
+				break;
+			} else if (strcmp(str_ch, FUTURE_UNICODE_LITERALS) == 0) {
+				ps->p_flags |= CO_FUTURE_UNICODE_LITERALS;
+				break;
+			}
 		}
 	}
 }

=== modified file 'Parser/parsetok.c'
--- Parser/parsetok.c	2008-03-18 23:45:49 +0000
+++ Parser/parsetok.c	2008-03-25 12:30:54 +0000
@@ -14,7 +14,7 @@
 
 
 /* Forward */
-static node *parsetok(struct tok_state *, grammar *, int, perrdetail *, int);
+static node *parsetok(struct tok_state *, grammar *, int, perrdetail *, int *);
 static void initerr(perrdetail *err_ret, const char* filename);
 
 /* Parse input coming from a string.  Return error code, print some errors. */
@@ -37,6 +37,16 @@
 			  grammar *g, int start,
 		          perrdetail *err_ret, int flags)
 {
+	int iflags = flags;
+	return PyParser_ParseStringFlagsFilenameEx(s, filename, g, start,
+						   err_ret, &iflags);
+}
+
+node *
+PyParser_ParseStringFlagsFilenameEx(const char *s, const char *filename,
+			  grammar *g, int start,
+		          perrdetail *err_ret, int *flags)
+{
 	struct tok_state *tok;
 
 	initerr(err_ret, filename);
@@ -70,6 +80,14 @@
 PyParser_ParseFileFlags(FILE *fp, const char *filename, grammar *g, int start,
 			char *ps1, char *ps2, perrdetail *err_ret, int flags)
 {
+	int iflags = flags;
+	return PyParser_ParseFileFlagsEx(fp, filename, g, start, ps1, ps2, err_ret, &iflags);
+}
+
+node *
+PyParser_ParseFileFlagsEx(FILE *fp, const char *filename, grammar *g, int start,
+			  char *ps1, char *ps2, perrdetail *err_ret, int *flags)
+{
 	struct tok_state *tok;
 
 	initerr(err_ret, filename);
@@ -85,7 +103,6 @@
 			tok->alterror++;
 	}
 
-
 	return parsetok(tok, g, start, err_ret, flags);
 }
 
@@ -110,7 +127,7 @@
 
 static node *
 parsetok(struct tok_state *tok, grammar *g, int start, perrdetail *err_ret,
-	 int flags)
+	 int *flags)
 {
 	parser_state *ps;
 	node *n;
@@ -123,8 +140,13 @@
 		return NULL;
 	}
 #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD
-	if (flags & PyPARSE_PRINT_IS_FUNCTION)
+	if (*flags & PyPARSE_PRINT_IS_FUNCTION) {
 		ps->p_flags |= CO_FUTURE_PRINT_FUNCTION;
+	}
+	if (*flags & PyPARSE_UNICODE_LITERALS) {
+		ps->p_flags |= CO_FUTURE_UNICODE_LITERALS;
+	}
+
 #endif
 
 	for (;;) {
@@ -147,7 +169,7 @@
 			   except if a certain flag is given --
 			   codeop.py uses this. */
 			if (tok->indent &&
-			    !(flags & PyPARSE_DONT_IMPLY_DEDENT))
+			    !(*flags & PyPARSE_DONT_IMPLY_DEDENT))
 			{
 				tok->pendin = -tok->indent;
 				tok->indent = 0;
@@ -191,6 +213,7 @@
 	else
 		n = NULL;
 
+	*flags = ps->p_flags;
 	PyParser_Delete(ps);
 
 	if (n == NULL) {

=== modified file 'Python/ast.c'
--- Python/ast.c	2008-03-25 08:29:14 +0000
+++ Python/ast.c	2008-03-25 19:26:34 +0000
@@ -18,6 +18,7 @@
 /* Data structure used internally */
 struct compiling {
     char *c_encoding; /* source encoding */
+    int c_future_unicode; /* __future__ unicode literals flag */
     PyArena *c_arena; /* arena for allocating memeory */
     const char *c_filename; /* filename */
 };
@@ -36,7 +37,7 @@
 static expr_ty ast_for_call(struct compiling *, const node *, expr_ty);
 
 static PyObject *parsenumber(const char *);
-static PyObject *parsestr(const char *s, const char *encoding);
+static PyObject *parsestr(struct compiling *, const char *);
 static PyObject *parsestrplus(struct compiling *, const node *n);
 
 #ifndef LINENO
@@ -198,6 +199,7 @@
     } else {
         c.c_encoding = NULL;
     }
+    c.c_future_unicode = flags && flags->cf_flags & CO_FUTURE_UNICODE_LITERALS;
     c.c_arena = arena;
     c.c_filename = filename;
 
@@ -3247,13 +3249,13 @@
  * parsestr parses it, and returns the decoded Python string object.
  */
 static PyObject *
-parsestr(const char *s, const char *encoding)
+parsestr(struct compiling *c, const char *s)
 {
         size_t len;
         int quote = Py_CHARMASK(*s);
         int rawmode = 0;
         int need_encoding;
-        int unicode = 0;
+        int unicode = c->c_future_unicode;
 
         if (isalpha(quote) || quote == '_') {
                 if (quote == 'u' || quote == 'U') {
@@ -3262,6 +3264,7 @@
                 }
                 if (quote == 'b' || quote == 'B') {
                         quote = *++s;
+                        unicode = 0;
                 }
                 if (quote == 'r' || quote == 'R') {
                         quote = *++s;
@@ -3293,12 +3296,12 @@
         }
 #ifdef Py_USING_UNICODE
         if (unicode || Py_UnicodeFlag) {
-                return decode_unicode(s, len, rawmode, encoding);
+                return decode_unicode(s, len, rawmode, c->c_encoding);
         }
 #endif
-        need_encoding = (encoding != NULL &&
-                         strcmp(encoding, "utf-8") != 0 &&
-                         strcmp(encoding, "iso-8859-1") != 0);
+        need_encoding = (c->c_encoding != NULL &&
+                         strcmp(c->c_encoding, "utf-8") != 0 &&
+                         strcmp(c->c_encoding, "iso-8859-1") != 0);
         if (rawmode || strchr(s, '\\') == NULL) {
                 if (need_encoding) {
 #ifndef Py_USING_UNICODE
@@ -3310,7 +3313,7 @@
                         PyObject *v, *u = PyUnicode_DecodeUTF8(s, len, NULL);
                         if (u == NULL)
                                 return NULL;
-                        v = PyUnicode_AsEncodedString(u, encoding, NULL);
+                        v = PyUnicode_AsEncodedString(u, c->c_encoding, NULL);
                         Py_DECREF(u);
                         return v;
 #endif
@@ -3320,7 +3323,7 @@
         }
 
         return PyString_DecodeEscape(s, len, NULL, unicode,
-                                     need_encoding ? encoding : NULL);
+                                     need_encoding ? c->c_encoding : NULL);
 }
 
 /* Build a Python string object out of a STRING atom.  This takes care of
@@ -3333,11 +3336,11 @@
         PyObject *v;
         int i;
         REQ(CHILD(n, 0), STRING);
-        if ((v = parsestr(STR(CHILD(n, 0)), c->c_encoding)) != NULL) {
+        if ((v = parsestr(c, STR(CHILD(n, 0)))) != NULL) {
                 /* String literal concatenation */
                 for (i = 1; i < NCH(n); i++) {
                         PyObject *s;
-                        s = parsestr(STR(CHILD(n, i)), c->c_encoding);
+                        s = parsestr(c, STR(CHILD(n, i)));
                         if (s == NULL)
                                 goto onError;
                         if (PyString_Check(v) && PyString_Check(s)) {

=== modified file 'Python/compile.c'
--- Python/compile.c	2008-03-15 22:03:18 +0000
+++ Python/compile.c	2008-03-25 10:52:33 +0000
@@ -294,6 +294,7 @@
 {
 	PyCodeObject *co = NULL;
 	mod_ty mod;
+
 	PyArena *arena = PyArena_New();
 	if (!arena)
 		return NULL;

=== modified file 'Python/future.c'
--- Python/future.c	2008-03-18 23:45:49 +0000
+++ Python/future.c	2008-03-25 12:30:54 +0000
@@ -35,6 +35,8 @@
 			ff->ff_features |= CO_FUTURE_WITH_STATEMENT;
 		} else if (strcmp(feature, FUTURE_PRINT_FUNCTION) == 0) {
 			ff->ff_features |= CO_FUTURE_PRINT_FUNCTION;
+		} else if (strcmp(feature, FUTURE_UNICODE_LITERALS) == 0) {
+			ff->ff_features |= CO_FUTURE_UNICODE_LITERALS;
 		} else if (strcmp(feature, "braces") == 0) {
 			PyErr_SetString(PyExc_SyntaxError,
 					"not a chance");

=== modified file 'Python/import.c'
--- Python/import.c	2008-03-07 14:13:28 +0000
+++ Python/import.c	2008-03-25 11:58:38 +0000
@@ -818,11 +818,12 @@
 {
 	PyCodeObject *co = NULL;
 	mod_ty mod;
+	PyCompilerFlags flags;
 	PyArena *arena = PyArena_New();
 	if (arena == NULL)
 		return NULL;
 
-	mod = PyParser_ASTFromFile(fp, pathname, Py_file_input, 0, 0, 0, 
+	mod = PyParser_ASTFromFile(fp, pathname, Py_file_input, 0, 0, &flags, 
 				   NULL, arena);
 	if (mod) {
 		co = PyAST_Compile(mod, pathname, NULL, arena);

=== modified file 'Python/pythonrun.c'
--- Python/pythonrun.c	2008-03-18 23:45:49 +0000
+++ Python/pythonrun.c	2008-03-25 12:30:54 +0000
@@ -749,8 +749,11 @@
 #define PARSER_FLAGS(flags) \
 	((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \
 		      PyPARSE_DONT_IMPLY_DEDENT : 0) \
-		    | ((flags)->cf_flags & CO_FUTURE_PRINT_FUNCTION ? \
-		       PyPARSE_PRINT_IS_FUNCTION : 0)) : 0)
+		    | (((flags)->cf_flags & CO_FUTURE_PRINT_FUNCTION) ? \
+		       PyPARSE_PRINT_IS_FUNCTION : 0) \
+		    | (((flags)->cf_flags & CO_FUTURE_UNICODE_LITERALS) ? \
+		       PyPARSE_UNICODE_LITERALS : 0) \
+		    ) : 0)
 #endif
 
 int
@@ -1365,11 +1368,12 @@
 {
 	struct symtable *st;
 	mod_ty mod;
+	PyCompilerFlags flags;
 	PyArena *arena = PyArena_New();
 	if (arena == NULL)
 		return NULL;
 
-	mod = PyParser_ASTFromString(str, filename, start, NULL, arena);
+	mod = PyParser_ASTFromString(str, filename, start, &flags, arena);
 	if (mod == NULL) {
 		PyArena_Free(arena);
 		return NULL;
@@ -1386,10 +1390,16 @@
 {
 	mod_ty mod;
 	perrdetail err;
-	node *n = PyParser_ParseStringFlagsFilename(s, filename,
+	int iflags;
+	iflags = PARSER_FLAGS(flags);
+
+	node *n = PyParser_ParseStringFlagsFilenameEx(s, filename,
 					&_PyParser_Grammar, start, &err,
-					PARSER_FLAGS(flags));
+					&iflags);
 	if (n) {
+		if (flags) {
+			flags->cf_flags |= iflags & PyCF_MASK;
+		}
 		mod = PyAST_FromNode(n, flags, filename, arena);
 		PyNode_Free(n);
 		return mod;
@@ -1407,9 +1417,15 @@
 {
 	mod_ty mod;
 	perrdetail err;
-	node *n = PyParser_ParseFileFlags(fp, filename, &_PyParser_Grammar,
-				start, ps1, ps2, &err, PARSER_FLAGS(flags));
+	int iflags;
+
+	iflags = PARSER_FLAGS(flags);
+	node *n = PyParser_ParseFileFlagsEx(fp, filename, &_PyParser_Grammar,
+				start, ps1, ps2, &err, &iflags);
 	if (n) {
+		if (flags) {
+			flags->cf_flags |= iflags & PyCF_MASK;
+		}
 		mod = PyAST_FromNode(n, flags, filename, arena);
 		PyNode_Free(n);
 		return mod;

# Begin bundle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