diff --git a/collects/scribble/base-render.ss b/collects/scribble/base-render.ss
index d69cd09f..a47126df 100644
--- a/collects/scribble/base-render.ss
+++ b/collects/scribble/base-render.ss
@@ -425,28 +425,29 @@
     (define/public (render-paragraph p part ri)
       (render-content (paragraph-content p) part ri))
 
-    (define/public (render-compound-paragraph p part ri)
+    (define/public (render-compound-paragraph p part ri starting-item?)
       (apply append (let loop ([l (compound-paragraph-blocks p)]
                                [first? #t])
                       (cond
                        [(null? l) null]
                        [else (cons
-                              (render-intrapara-block (car l) part ri first? (null? (cdr l)))
+                              (render-intrapara-block (car l) part ri first? (null? (cdr l))
+                                                      (and first? starting-item?))
                               (loop (cdr l) #f))]))))
 
-    (define/public (render-flow p part ri start-inline?)
+    (define/public (render-flow p part ri starting-item?)
       (if (null? (flow-paragraphs p))
           null
           (append
            (render-block (car (flow-paragraphs p))
-                         part ri start-inline?)
+                         part ri starting-item?)
            (apply append
                   (map (lambda (p)
                          (render-block p part ri #f))
                        (cdr (flow-paragraphs p)))))))
 
-    (define/public (render-intrapara-block p part ri first? last?)
-      (render-block p part ri first?))
+    (define/public (render-intrapara-block p part ri first? last? starting-item?)
+      (render-block p part ri starting-item?))
 
     (define/public (render-block p part ri inline?)
       (cond
@@ -455,7 +456,7 @@
                       (render-table p part ri inline?))]
         [(itemization? p) (render-itemization p part ri)]
         [(blockquote? p) (render-blockquote p part ri)]
-        [(compound-paragraph? p) (render-compound-paragraph p part ri)]
+        [(compound-paragraph? p) (render-compound-paragraph p part ri inline?)]
         [(delayed-block? p) 
          (render-block (delayed-block-blocks p ri) part ri inline?)]
         [else (render-paragraph p part ri)]))
diff --git a/collects/scribble/html-render.ss b/collects/scribble/html-render.ss
index ec079022..e8fed5c5 100644
--- a/collects/scribble/html-render.ss
+++ b/collects/scribble/html-render.ss
@@ -837,21 +837,21 @@
                 (append (render-part (car secs) ri)
                         (loop (add1 pos) (cdr secs))))))))
 
-    (define/private (render-flow* p part ri start-inline? special-last?)
+    (define/private (render-flow* p part ri starting-item? special-last?)
       ;; Wrap each table with <p>, except for a trailing table
       ;;  when `special-last?' is #t
-      (let loop ([f (flow-paragraphs p)] [inline? start-inline?])
+      (let loop ([f (flow-paragraphs p)] [starting-item? starting-item?])
         (cond
           [(null? f) null]
           [(and (table? (car f))
                 (or (not special-last?) (not (null? (cdr f)))))
-           (cons `(p ,@(render-block (car f) part ri inline?))
+           (cons `(p ,@(render-block (car f) part ri starting-item?))
                  (loop (cdr f) #f))]
-          [else (append (render-block (car f) part ri inline?)
+          [else (append (render-block (car f) part ri starting-item?)
                         (loop (cdr f) #f))])))
 
-    (define/override (render-flow p part ri start-inline?)
-      (render-flow* p part ri start-inline? #t))
+    (define/override (render-flow p part ri starting-item?)
+      (render-flow* p part ri starting-item? #t))
 
     (define/private (do-render-paragraph p part ri flatten-unstyled?)
       ;; HACK: for the search, we need to be able to render a `div'
@@ -877,11 +877,11 @@
     (define/override (render-paragraph p part ri)
       (do-render-paragraph p part ri #f))
 
-    (define/override (render-intrapara-block p part ri first? last?)
+    (define/override (render-intrapara-block p part ri first? last? starting-item?)
       `((div ([class "SIntrapara"])
              ,@(cond
                 [(paragraph? p) (do-render-paragraph p part ri #t)]
-                [else (render-block p part ri #t)]))))
+                [else (render-block p part ri starting-item?)]))))
 
     (define/override (render-element e part ri)
       (cond
@@ -1067,7 +1067,7 @@
                      ,@sz))))]
           [else (render*)])))
 
-    (define/override (render-table t part ri need-inline?)
+    (define/override (render-table t part ri starting-item?)
       (define raw-style (flatten-style (table-style t)))
       (define t-style (if (with-attributes? raw-style)
                           (with-attributes-style raw-style)
@@ -1124,7 +1124,7 @@
                                 (render-flow d part ri #f)))
                      (loop (cdr ds) (cdr as) (cdr vas) (cdr sts) #f)))]))))
       `((table ([cellspacing "0"]
-                ,@(if need-inline?
+                ,@(if starting-item?
                     '([style "display: inline-table; vertical-align: text-top;"])
                     null)
                 ,@(case t-style
diff --git a/collects/scribble/latex-render.ss b/collects/scribble/latex-render.ss
index 6ade4432..4783130b 100644
--- a/collects/scribble/latex-render.ss
+++ b/collects/scribble/latex-render.ss
@@ -130,11 +130,11 @@
           (when (string? style) (printf "}"))))
       null)
 
-    (define/override (render-intrapara-block p part ri first? last?)
+    (define/override (render-intrapara-block p part ri first? last? starting-item?)
       (unless first?
         (printf "\n\n\\noindent "))
       (begin0
-       (super render-intrapara-block p part ri first? last?)))
+       (super render-intrapara-block p part ri first? last? starting-item?)))
 
     (define/override (render-element e part ri)
       (when (render-element? e)
@@ -243,17 +243,17 @@
                 [else (format "x~x" (char->integer c))]))
             (string->list (format "~s" s)))))
 
-    (define/override (render-flow p part ri start-inline?)
+    (define/override (render-flow p part ri starting-item?)
       (if (null? (flow-paragraphs p))
           null
           (begin
-            (render-block (car (flow-paragraphs p)) part ri start-inline?)
+            (render-block (car (flow-paragraphs p)) part ri starting-item?)
             (for ([b (in-list (cdr (flow-paragraphs p)))])
               (printf "\n\n")
               (render-block b part ri #f))
             null)))
 
-    (define/override (render-table t part ri inline-table?)
+    (define/override (render-table t part ri starting-item?)
       (let* ([boxed? (eq? 'boxed (table-style t))]
              [index? (eq? 'index (table-style t))]
              [tableform
@@ -267,30 +267,36 @@
              [row-styles (cdr (or (and (list? (table-style t))
                                        (assoc 'row-styles (table-style t)))
                                   (cons #f (map (lambda (x) #f) flowss))))]
-             [inline?
-              (and (not boxed?) 
-                   (not index?)
-                   (ormap (lambda (rs) (equal? rs "inferencetop")) row-styles)
-                   (or (null? (table-flowss t))
-                       (= 1 (length (car (table-flowss t)))))
-                   (let ([m (current-table-mode)])
-                     (and m
-                          (equal? "bigtabular" (car m))
-                          (= 1 (length (car (table-flowss (cadr m))))))))]
-             [boxline "{\\setlength{\\unitlength}{\\linewidth}\\begin{picture}(1,0)\\put(0,0){\\line(1,0){1}}\\end{picture}}"]
              [twidth (if (null? (table-flowss t))
                          1
                          (length (car (table-flowss t))))]
              [single-column? (and (= 1 twidth)
-                                  (not (table-style t))
-                                  (not (current-table-mode)))])
+                                  (or (not (table-style t))
+                                      (string? (table-style t)))
+                                  (not (current-table-mode)))]
+             [inline?
+              (and (not single-column?)
+                   (not boxed?) 
+                   (not index?)
+                   (ormap (lambda (rs) (equal? rs "inferencetop")) row-styles)
+                   (= 1 twidth)
+                   (let ([m (current-table-mode)])
+                     (and m
+                          (equal? "bigtabular" (car m))
+                          (= 1 (length (car (table-flowss (cadr m))))))))]
+             [boxline "{\\setlength{\\unitlength}{\\linewidth}\\begin{picture}(1,0)\\put(0,0){\\line(1,0){1}}\\end{picture}}"])
         (if single-column?
-            (do-render-blockquote 
-             (make-blockquote "SingleColumn"
-                              (apply append (map flow-paragraphs (map car (table-flowss t)))))
-             part 
-             ri
-             #t)
+            (begin
+              (when (string? (table-style t))
+                (printf "\\begin{~a}" (table-style t)))
+              (do-render-blockquote 
+               (make-blockquote "SingleColumn"
+                                (apply append (map flow-paragraphs (map car (table-flowss t)))))
+               part 
+               ri
+               #t)
+              (when (string? (table-style t))
+                (printf "\\end{~a}" (table-style t))))
             (unless (or (null? flowss) (null? (car flowss)))
               (parameterize ([current-table-mode
                               (if inline? (current-table-mode) (list tableform t))]
@@ -302,7 +308,7 @@
                  [single-column? (printf "\\begin{tabbing}\n")]
                  [else
                   (printf "~a~a\\begin{~a}~a{@{~a}~a}\n~a"
-                          (if (and inline-table? (equal? tableform "bigtabular"))
+                          (if (and starting-item? (equal? tableform "bigtabular"))
                               "\\bigtableinlinecorrect"
                               "")
                           (if (string? (table-style t))
@@ -435,7 +441,8 @@
         (if (regexp-match #rx"^[\\]" kind)
             (printf "~a{" kind)
             (printf "\\begin{~a}" kind))
-        (parameterize ([current-table-mode (if single-column?
+        (parameterize ([current-table-mode (if (or single-column?
+                                                   (not (current-table-mode)))
                                                (current-table-mode)
                                                (list "blockquote" t))])
           (render-flow (make-flow (blockquote-paragraphs t)) part ri #f))
@@ -447,14 +454,13 @@
     (define/override (render-blockquote t part ri)
       (do-render-blockquote t part ri #f))
 
-    (define/override (render-compound-paragraph t part ri)
+    (define/override (render-compound-paragraph t part ri starting-item?)
       (let ([kind (compound-paragraph-style t)])
         (when kind
           (if (regexp-match #rx"^[\\]" kind)
               (printf "~a{" kind)
               (printf "\\begin{~a}" kind)))
-        (parameterize ([current-table-mode (list "blockquote" t)])
-          (super render-compound-paragraph t part ri))
+        (super render-compound-paragraph t part ri starting-item?)
         (when kind
           (if (regexp-match #rx"^[\\]" kind)
               (printf "}")
diff --git a/collects/scribble/text-render.ss b/collects/scribble/text-render.ss
index 9773f55f..8370264d 100644
--- a/collects/scribble/text-render.ss
+++ b/collects/scribble/text-render.ss
@@ -43,13 +43,13 @@
               (render-part (car secs) ht)
               (loop (add1 pos) (cdr secs))))))
 
-      (define/override (render-flow f part ht start-inline?)
+      (define/override (render-flow f part ht starting-item?)
         (let ([f (flow-paragraphs f)])
           (if (null? f)
               null
               (apply
                append
-               (render-block (car f) part ht start-inline?)
+               (render-block (car f) part ht starting-item?)
                (map (lambda (p)
                       (newline) (newline)
                       (render-block p part ht #f))