# Bazaar merge directive format 2 (Bazaar 0.90)
# revision_id: lists@cheimes.de-20080325123255-buomjk316l6y8rya
# target_branch: file:///home/heimes/dev/python/bzr/trunk/
# testament_sha1: 48d1983ccf172d6ddea14873d12da07f34fe3375
# timestamp: 2008-03-25 13:42:38 +0100
# base_revision_id: svn-v3-trunk1:6015fed2-1504-0410-9fe1-\
#   9d1591cc4771:python%2Ftrunk:61849
# 
# 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-24 13:31:16 +0000
+++ Misc/NEWS	2008-03-25 12:30:54 +0000
@@ -11,6 +11,8 @@
 
 Core and builtins
 -----------------
+
+- Added from __future__ import unicode_literals
  
 - Issue #1477: With narrow Unicode builds, the unicode escape sequence
   \Uxxxxxxxx did not accept values outside the Basic Multilingual Plane.  This

=== 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-19 04:39:13 +0000
+++ Python/ast.c	2008-03-25 12:30:54 +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(const char *s, const char *encoding, int future_unicode);
 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(const char *s, const char *encoding, int future_unicode)
 {
         size_t len;
         int quote = Py_CHARMASK(*s);
         int rawmode = 0;
         int need_encoding;
-        int unicode = 0;
+        int unicode = 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;
@@ -3333,11 +3336,13 @@
         PyObject *v;
         int i;
         REQ(CHILD(n, 0), STRING);
-        if ((v = parsestr(STR(CHILD(n, 0)), c->c_encoding)) != NULL) {
+        if ((v = parsestr(STR(CHILD(n, 0)), c->c_encoding,
+                          c->c_future_unicode)) != NULL) {
                 /* String literal concatenation */
                 for (i = 1; i < NCH(n); i++) {
                         PyObject *s;
-                        s = parsestr(STR(CHILD(n, i)), c->c_encoding);
+                        s = parsestr(STR(CHILD(n, i)), c->c_encoding,
+                                     c->c_future_unicode);
                         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;

=== modified file 'Python/sysmodule.c'
--- Python/sysmodule.c	2008-03-21 20:11:46 +0000
+++ Python/sysmodule.c	2008-03-24 20:09:49 +0000
@@ -1063,8 +1063,15 @@
 		return;
 
 	python = strstr(headurl, "/python/");
-	if (!python)
-		Py_FatalError("subversion keywords missing");
+	if (!python) {
+		/* XXX quick hack to get bzr working */
+		*patchlevel_revision = '\0';
+		svn_revision = "";
+		strcpy(branch, "r");
+		strcpy(shortbranch, "unknown");
+		return;
+		/* Py_FatalError("subversion keywords missing"); */
+	}
 
 	br_start = python + 8;
 	br_end = strchr(br_start, '/');

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