@@ -23,17 +23,15 @@ \section{\module{dis} ---
 
 \begin{verbatim}
 >>> dis.dis(myfunc)
-          0 SET_LINENO          1
-
-          3 SET_LINENO          2
-          6 LOAD_GLOBAL         0 (len)
-          9 LOAD_FAST           0 (alist)
-         12 CALL_FUNCTION       1
-         15 RETURN_VALUE   
-         16 LOAD_CONST          0 (None)
-         19 RETURN_VALUE   
+  2           0 LOAD_GLOBAL              0 (len)
+              3 LOAD_FAST                0 (alist)
+              6 CALL_FUNCTION            1
+              9 RETURN_VALUE        
+             10 RETURN_NONE
 \end{verbatim}
 
+(The ``2'' is a line number).
+
 The \module{dis} module defines the following functions and constants:
 
 \begin{funcdesc}{dis}{\optional{bytesource}}
@@ -56,6 +54,7 @@ \section{\module{dis} ---
 was provided.  The output is divided in the following columns:
 
 \begin{enumerate}
+\item the line number, for the first instruction of each line
 \item the current instruction, indicated as \samp{-->},
 \item a labelled instruction, indicated with \samp{>\code{>}},
 \item the address of the instruction,
@@ -402,6 +401,14 @@ \subsection{Python Byte Code Instructions}
 Returns with TOS to the caller of the function.
 \end{opcodedesc}
 
+\begin{opcodedesc}{RETURN_NONE}{}
+Returns \constant{None} to the caller of the function.  This opcode is
+generated as the last opcode of every function and only then, for
+reasons to do with tracing support.  See the comments in the function
+\cfunction{maybe_call_line_trace} in \file{Python/ceval.c} for the
+gory details.  \versionadded{2.3}.
+\end{opcodedesc}
+
 \begin{opcodedesc}{YIELD_VALUE}{}
 Pops \code{TOS} and yields it from a generator.
 \end{opcodedesc}
@@ -621,7 +628,7 @@ \subsection{Python Byte Code Instructions}
 \end{opcodedesc}
 
 \begin{opcodedesc}{SET_LINENO}{lineno}
-Sets the current line number to \var{lineno}.
+This opcode is obsolete.
 \end{opcodedesc}
 
 \begin{opcodedesc}{RAISE_VARARGS}{argc}
 
@@ -118,10 +118,10 @@ \section{\module{traceback} ---
 
 \begin{funcdesc}{tb_lineno}{tb}
 This function returns the current line number set in the traceback
-object.  This is normally the same as the \code{\var{tb}.tb_lineno}
-field of the object, but when optimization is used (the -O flag) this
-field is not updated correctly; this function calculates the correct
-value.
+object.  This function was necessary because in versions of Python
+prior to 2.3 when the \programopt{O} flag was passed to Python the
+\code{\var{tb}.tb_lineno} was not updated correctly.  This function
+has no use in versions past 2.3.
 \end{funcdesc}
 
 
 
@@ -2340,12 +2340,11 @@ \subsection{``Compiled'' Python files}
 
 \item
 When the Python interpreter is invoked with the \programopt{-O} flag,
-optimized code is generated and stored in \file{.pyo} files.
-The optimizer currently doesn't help much; it only removes
-\keyword{assert} statements and \code{SET_LINENO} instructions.
-When \programopt{-O} is used, \emph{all} bytecode is optimized;
-\code{.pyc} files are ignored and \code{.py} files are compiled to
-optimized bytecode.
+optimized code is generated and stored in \file{.pyo} files.  The
+optimizer currently doesn't help much; it only removes
+\keyword{assert} statements.  When \programopt{-O} is used, \emph{all}
+bytecode is optimized; \code{.pyc} files are ignored and \code{.py}
+files are compiled to optimized bytecode.
 
 \item
 Passing two \programopt{-O} flags to the Python interpreter
 
@@ -658,7 +658,6 @@ \section{Other Language Changes}
 
 \end{itemize}
 
-
 %======================================================================
 \section{New and Improved Modules}
 
@@ -987,9 +986,9 @@ \section{Build and C API Changes}
 when running Python's \file{configure} script.  (Contributed by Ondrej
 Palkovsky.)
 
-\item The  \csimplemacro{DL_EXPORT} and \csimplemacro{DL_IMPORT} macros are now
-deprecated.  Initialization functions for Python extension modules
-should now be declared using the new macro
+\item The \csimplemacro{DL_EXPORT} and \csimplemacro{DL_IMPORT} macros
+are now deprecated.  Initialization functions for Python extension
+modules should now be declared using the new macro
 \csimplemacro{PyMODINIT_FUNC}, while the Python core will generally
 use the \csimplemacro{PyAPI_FUNC} and \csimplemacro{PyAPI_DATA}
 macros.
@@ -1076,6 +1075,29 @@ \section{Other Changes and Fixes}
 \item The tools used to build the documentation now work under Cygwin
 as well as \UNIX.
 
+\item The \code{SET_LINENO} opcode has been removed.  Back in the
+mists of time, this opcode was needed to produce line numbers in
+tracebacks and support trace functions (for, e.g., \module{pdb}).
+Since Python 1.5, the line numbers in tracebacks have been computed
+using a different mechanism that works with ``python -O''.  For Python
+2.3 Michael Hudson implemented a similar scheme to determine when to
+call the trace function, removing the need for \code{SET_LINENO}
+entirely.
+
+Python code will be hard pushed to notice a difference from this
+change, apart from a slight speed up when python is run without
+\programopt{-O}.
+
+C extensions that access the \member{f_lineno} field of frame objects
+should instead call \code{PyCode_Addr2Line(f->f_code, f->f_lasti)}.
+This will have the added effect of making the code work as desired
+under ``python -O'' in earlier versions of Python.
+
+To make tracing work as expected, it was found necessary to add a new
+opcode, \cdata{RETURN_NONE}, to the VM.  If you want to know why, read
+the comments in the function \cfunction{maybe_call_line_trace} in
+\file{Python/ceval.c}.
+
 \end{itemize}
 
 
 
@@ -71,6 +71,9 @@ extern "C" {
 #define INPLACE_OR	79
 #define BREAK_LOOP	80
 
+#define RETURN_NONE	81 /* *only* for function epilogues 
+			      -- see comments in 
+			      ceval.c:maybe_call_line_trace for why */
 #define LOAD_LOCALS	82
 #define RETURN_VALUE	83
 #define IMPORT_STAR	84
@@ -119,8 +122,6 @@ extern "C" {
 #define STORE_FAST	125	/* Local variable number */
 #define DELETE_FAST	126	/* Local variable number */
 
-#define SET_LINENO	127	/* Current line number */
-
 #define RAISE_VARARGS	130	/* Number of raise arguments (1, 2 or 3) */
 /* CALL_FUNCTION_XXX opcodes defined below depend on this definition */
 #define CALL_FUNCTION	131	/* #args + (#kwargs<<8) */
 
@@ -55,6 +55,20 @@ def distb(tb=None):
 def disassemble(co, lasti=-1):
     """Disassemble a code object."""
     code = co.co_code
+
+    byte_increments = [ord(c) for c in co.co_lnotab[0::2]]
+    line_increments = [ord(c) for c in co.co_lnotab[1::2]]
+    table_length = len(byte_increments) # == len(line_increments)
+
+    lineno = co.co_firstlineno
+    table_index = 0
+    while (table_index < table_length
+           and byte_increments[table_index] == 0):
+        lineno += line_increments[table_index]
+        table_index += 1
+    addr = 0
+    line_incr = 0
+    
     labels = findlabels(code)
     n = len(code)
     i = 0
@@ -63,7 +77,23 @@ def disassemble(co, lasti=-1):
     while i < n:
         c = code[i]
         op = ord(c)
-        if op == SET_LINENO and i > 0: print # Extra blank line
+
+        if i >= addr:
+            lineno += line_incr
+            while table_index < table_length:
+                addr += byte_increments[table_index]
+                line_incr = line_increments[table_index]
+                table_index += 1
+                if line_incr:
+                    break
+            else:
+                addr = sys.maxint
+            if i > 0:
+                print
+            print "%3d"%lineno,
+        else:
+            print '   ',
+
         if i == lasti: print '-->',
         else: print '   ',
         if i in labels: print '>>',
@@ -224,6 +254,7 @@ def jabs_op(name, op):
 def_op('INPLACE_OR', 79)
 def_op('BREAK_LOOP', 80)
 
+def_op('RETURN_NONE', 81)
 def_op('LOAD_LOCALS', 82)
 def_op('RETURN_VALUE', 83)
 def_op('IMPORT_STAR', 84)
@@ -277,9 +308,6 @@ def jabs_op(name, op):
 def_op('DELETE_FAST', 126)      # Local variable number
 haslocal.append(126)
 
-def_op('SET_LINENO', 127)       # Current line number
-SET_LINENO = 127
-
 def_op('RAISE_VARARGS', 130)    # Number of raise arguments (1, 2, or 3)
 def_op('CALL_FUNCTION', 131)    # #args + (#kwargs << 8)
 def_op('MAKE_FUNCTION', 132)    # Number of args with default values
 
@@ -711,7 +711,7 @@ def getframeinfo(frame, context=1):
         raise TypeError, 'arg is not a frame or traceback object'
 
     filename = getsourcefile(frame) or getfile(frame)
-    lineno = getlineno(frame)
+    lineno = frame.f_lineno
     if context > 0:
         start = lineno - 1 - context//2
         try:
@@ -730,18 +730,8 @@ def getframeinfo(frame, context=1):
 
 def getlineno(frame):
     """Get the line number from a frame object, allowing for optimization."""
-    # Written by Marc-André Lemburg; revised by Jim Hugunin and Fredrik Lundh.
-    lineno = frame.f_lineno
-    code = frame.f_code
-    if hasattr(code, 'co_lnotab'):
-        table = code.co_lnotab
-        lineno = code.co_firstlineno
-        addr = 0
-        for i in range(0, len(table), 2):
-            addr = addr + ord(table[i])
-            if addr > frame.f_lasti: break
-            lineno = lineno + ord(table[i+1])
-    return lineno
+    # FrameType.f_lineno is now a descriptor that grovels co_lnotab
+    return frame.f_lineno
 
 def getouterframes(frame, context=1):
     """Get a list of records for a frame and all higher (calling) frames.
 
@@ -105,7 +105,13 @@ def execRcLines(self):
                 if len(line) > 0 and line[0] != '#':
                     self.onecmd(line)
 
-    # Override Bdb methods (except user_call, for now)
+    # Override Bdb methods 
+
+    def user_call(self, frame, argument_list):
+        """This method is called when there is the remote possibility
+        that we ever need to stop in this function."""
+        print '--Call--'
+        self.interaction(frame, None)
 
     def user_line(self, frame):
         """This function is called when we stop or break at this line."""
 
@@ -91,10 +91,8 @@ def g():
         f_lineno = f.func_code.co_firstlineno
         g_lineno = g.func_code.co_firstlineno
         events = [(ENTER, ("test_hotshot", g_lineno, "g")),
-                  (LINE,  ("test_hotshot", g_lineno, "g")),
                   (LINE,  ("test_hotshot", g_lineno+1, "g")),
                   (ENTER, ("test_hotshot", f_lineno, "f")),
-                  (LINE,  ("test_hotshot", f_lineno, "f")),
                   (LINE,  ("test_hotshot", f_lineno+1, "f")),
                   (LINE,  ("test_hotshot", f_lineno+2, "f")),
                   (EXIT,  ("test_hotshot", f_lineno, "f")),
 
@@ -59,7 +59,7 @@ def print_tb(tb, limit=None, file=None):
     n = 0
     while tb is not None and (limit is None or n < limit):
         f = tb.tb_frame
-        lineno = tb_lineno(tb)
+        lineno = tb.tb_lineno
         co = f.f_code
         filename = co.co_filename
         name = co.co_name
@@ -92,7 +92,7 @@ def extract_tb(tb, limit = None):
     n = 0
     while tb is not None and (limit is None or n < limit):
         f = tb.tb_frame
-        lineno = tb_lineno(tb)
+        lineno = tb.tb_lineno
         co = f.f_code
         filename = co.co_filename
         name = co.co_name
@@ -263,7 +263,7 @@ def extract_stack(f=None, limit = None):
     list = []
     n = 0
     while f is not None and (limit is None or n < limit):
-        lineno = f.f_lineno     # XXX Too bad if -O is used
+        lineno = f.f_lineno
         co = f.f_code
         filename = co.co_filename
         name = co.co_name
@@ -279,23 +279,6 @@ def extract_stack(f=None, limit = None):
 def tb_lineno(tb):
     """Calculate correct line number of traceback given in tb.
 
-    Even works with -O on.
+    Obsolete in 2.3.
     """
-    # Coded by Marc-Andre Lemburg from the example of PyCode_Addr2Line()
-    # in compile.c.
-    # Revised version by Jim Hugunin to work with JPython too.
-
-    c = tb.tb_frame.f_code
-    if not hasattr(c, 'co_lnotab'):
-        return tb.tb_lineno
-
-    tab = c.co_lnotab
-    line = c.co_firstlineno
-    stopat = tb.tb_lasti
-    addr = 0
-    for i in range(0, len(tab), 2):
-        addr = addr + ord(tab[i])
-        if addr > stopat:
-            break
-        line = line + ord(tab[i+1])
-    return line
+    return tb.tb_lineno