diff --git a/django/template/context.py b/django/template/context.py
index 8f70d70..383e184 100644
--- a/django/template/context.py
+++ b/django/template/context.py
@@ -1,4 +1,5 @@
 from copy import copy
+from inspect import getargspec
 from django.core.exceptions import ImproperlyConfigured
 from django.utils.importlib import import_module
 
@@ -169,4 +170,10 @@ class RequestContext(Context):
         else:
             processors = tuple(processors)
         for processor in get_standard_processors() + processors:
-            self.update(processor(request))
+            if not hasattr(processor, 'pass_context'):
+                arginfo = getargspec(processor)
+                processor.pass_context = len(arginfo[0]) > 1
+            if processor.pass_context:
+                self.update(processor(request, context=self))
+            else:
+                self.update(processor(request))
diff --git a/docs/ref/templates/api.txt b/docs/ref/templates/api.txt
index c8100fc..db19756 100644
--- a/docs/ref/templates/api.txt
+++ b/docs/ref/templates/api.txt
@@ -526,9 +526,14 @@ Writing your own context processors
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 A context processor has a very simple interface: It's just a Python function
-that takes one argument, an :class:`~django.http.HttpRequest` object, and
-returns a dictionary that gets added to the template context. Each context
-processor *must* return a dictionary.
+that takes at least one argument, an :class:`~django.http.HttpRequest` object.
+
+.. versionadded:: 1.2
+   The optional keyword argument ``context`` is now supported, which allows 
+   access to the current :class:`~django.template.Context` object.
+
+The function returns a dictionary that gets added to the template context. 
+Each context processor *must* return a dictionary.
 
 Custom context processors can live anywhere in your code base. All Django cares
 about is that your custom context processors are pointed-to by your
diff --git a/tests/regressiontests/context_processors/tests.py b/tests/regressiontests/context_processors/tests.py
index 1f2209e..53eefca 100644
--- a/tests/regressiontests/context_processors/tests.py
+++ b/tests/regressiontests/context_processors/tests.py
@@ -2,6 +2,8 @@
 Tests for Django's bundled context processors.
 """
 from django.test import TestCase
+from django.template import RequestContext, Template
+from django.test.client import RequestFactory
 
 
 class RequestContextProcessorTests(TestCase):
@@ -11,6 +13,16 @@ class RequestContextProcessorTests(TestCase):
 
     urls = 'regressiontests.context_processors.urls'
 
+    def _render(self, template, context, processors=None):
+        """
+        Helper function to ease testing of context processors without
+        needing templates on the file system
+        """
+        factory = RequestFactory()
+        request = factory.get('/request_attrs/')
+        context = RequestContext(request, context, processors=processors)
+        return Template(template).render(context)
+
     def test_request_attributes(self):
         """
         Test that the request object is available in the template and that its
@@ -35,3 +47,33 @@ class RequestContextProcessorTests(TestCase):
         response = self.client.post(url, {'path': '/blah/'})
         self.assertContains(response, url)
 
+    def test_no_passed_context(self):
+        """
+        Context processors not expecting the "context" argument should
+        continue to work as usual (refs #13841)
+        """
+        def add_vegetable(request):
+            return {'vegetable': 'broccoli'}
+        # vegetable shuldn't exist yet in the context
+        content =  self._render('{{ fruit }} {{ vegetable }}',
+                                {'fruit': 'apple'})
+        self.assertEqual(content, 'apple ')
+        # add_vegetable context processor should add "broccoli" to context
+        content =  self._render('{{ fruit }} {{ vegetable }}',
+                                {'fruit': 'apple'}, [add_vegetable])
+        self.assertEqual(content, 'apple broccoli')
+
+    def test_can_access_context(self):
+        """
+        Test context processor expecting the "context" argument can access
+        and modify the context (refs #13841)
+        """
+        def pluralize_fruit(request, context):
+            return {'fruit': context['fruit'] + 's'}
+        # should just print apple (default behavior)
+        content =  self._render('{{ fruit }}', {'fruit': 'apple'})
+        self.assertEqual(content, 'apple')
+        # the pluralize_fruit context processor should add an 's' to apple
+        content =  self._render('{{ fruit }}', {'fruit': 'apple'},
+                                [pluralize_fruit])
+        self.assertEqual(content, 'apples')
