diff --git a/Modules/parsermodule.c b/Modules/parsermodule.c
index f4fb805..3ffe693 100644
--- a/Modules/parsermodule.c
+++ b/Modules/parsermodule.c
@@ -579,83 +579,41 @@
 {
     NOTE(ARGUNUSED(self))
     PyObject *ast = 0;
-    PyObject *tuple = 0;
-    PyObject *temp = 0;
-    int ok;
-    int start_sym = 0;
+    PyObject *tuple;
+    node *tree;
 
     static char *keywords[] = {"sequence", NULL};
 
-    if (!PyArg_ParseTupleAndKeywords(args, kw, "O:tuple2ast", keywords,
+    if (!PyArg_ParseTupleAndKeywords(args, kw, "O:sequence2ast", keywords,
                                      &tuple))
         return (0);
     if (!PySequence_Check(tuple)) {
         PyErr_SetString(PyExc_ValueError,
-                        "tuple2ast() requires a single sequence argument");
+                        "sequence2ast() requires a single sequence argument");
         return (0);
     }
     /*
-     *  This mess of tests is written this way so we can use the abstract
-     *  object interface (AOI).  Unfortunately, the AOI increments reference
-     *  counts, which requires that we store a pointer to retrieved object
-     *  so we can DECREF it after the check.  But we really should accept
-     *  lists as well as tuples at the very least.
+     *  Convert the tree to the internal form before checking it.
      */
-    ok = PyObject_Size(tuple) >= 2;
-    if (ok) {
-        temp = PySequence_GetItem(tuple, 0);
-        ok = (temp != NULL) && PyInt_Check(temp);
-        if (ok)
-            /* this is used after the initial checks: */
-            start_sym = PyInt_AS_LONG(temp);
-        Py_XDECREF(temp);
-    }
-    if (ok) {
-        temp = PySequence_GetItem(tuple, 1);
-        ok = (temp != NULL) && PySequence_Check(temp);
-        Py_XDECREF(temp);
-    }
-    if (ok) {
-        temp = PySequence_GetItem(tuple, 1);
-        ok = (temp != NULL) && PyObject_Size(temp) >= 2;
-        if (ok) {
-            PyObject *temp2 = PySequence_GetItem(temp, 0);
-            if (temp2 != NULL) {
-                ok = PyInt_Check(temp2);
-                Py_DECREF(temp2);
-            }
+    tree = build_node_tree(tuple);
+    if (tree != 0) {
+        int start_sym = TYPE(tree);
+        if (start_sym == eval_input) {
+            /*  Might be an eval form.  */
+            if (validate_expr_tree(tree))
+                ast = parser_newastobject(tree, PyAST_EXPR);
         }
-        Py_XDECREF(temp);
+        else if (start_sym == file_input) {
+            /*  This looks like an exec form so far.  */
+            if (validate_file_input(tree))
+                ast = parser_newastobject(tree, PyAST_SUITE);
+        }
+        else {
+            /*  This is a fragment, at best. */
+            PyNode_Free(tree);
+            err_string("Parse tree does not use a valid start symbol.");
+        }
     }
-    /* If we've failed at some point, get out of here. */
-    if (!ok) {
-        err_string("malformed sequence for tuple2ast()");
-        return (0);
-    }
-    /*
-     *  This might be a valid parse tree, but let's do a quick check
-     *  before we jump the gun.
-     */
-    if (start_sym == eval_input) {
-        /*  Might be an eval form.  */
-        node* expression = build_node_tree(tuple);
-
-        if ((expression != 0) && validate_expr_tree(expression))
-            ast = parser_newastobject(expression, PyAST_EXPR);
-    }
-    else if (start_sym == file_input) {
-        /*  This looks like an exec form so far.  */
-        node* suite_tree = build_node_tree(tuple);
-
-        if ((suite_tree != 0) && validate_file_input(suite_tree))
-            ast = parser_newastobject(suite_tree, PyAST_SUITE);
-    }
-    else
-        /*  This is a fragment, and is not yet supported.  Maybe they
-         *  will be if I find a use for them.
-         */
-        err_string("Fragmentary parse trees not supported.");
-
     /*  Make sure we throw an exception on all errors.  We should never
      *  get this, but we'd do well to be sure something is done.
      */
@@ -666,51 +624,6 @@
 }
 
 
-/*  int check_terminal_tuple()
- *
- *  Check a tuple to determine that it is indeed a valid terminal
- *  node.  The node is known to be required as a terminal, so we throw
- *  an exception if there is a failure.
- *
- *  The format of an acceptable terminal tuple is "(is[i])": the fact
- *  that elem is a tuple and the integer is a valid terminal symbol
- *  has been established before this function is called.  We must
- *  check the length of the tuple and the type of the second element
- *  and optional third element.  We do *NOT* check the actual text of
- *  the string element, which we could do in many cases.  This is done
- *  by the validate_*() functions which operate on the internal
- *  representation.
- */
-static int
-check_terminal_tuple(PyObject *elem)
-{
-    int   len = PyObject_Size(elem);
-    int   res = 1;
-    char* str = "Illegal terminal symbol; bad node length.";
-
-    if ((len == 2) || (len == 3)) {
-        PyObject *temp = PySequence_GetItem(elem, 1);
-        res = PyString_Check(temp);
-        str = "Illegal terminal symbol; expected a string.";
-        if (res && (len == 3)) {
-            PyObject* third = PySequence_GetItem(elem, 2);
-            res = PyInt_Check(third);
-            str = "Invalid third element of terminal node.";
-            Py_XDECREF(third);
-        }
-        Py_XDECREF(temp);
-    }
-    else {
-        res = 0;
-    }
-    if (!res) {
-        elem = Py_BuildValue("(os)", elem, str);
-        PyErr_SetObject(parser_error, elem);
-    }
-    return (res);
-}
-
-
 /*  node* build_node_children()
  *
  *  Iterate across the children of the current non-terminal node and build
@@ -726,7 +639,7 @@
     int i;
 
     for (i = 1; i < len; ++i) {
-        /* elem must always be a tuple, however simple */
+        /* elem must always be a sequence, however simple */
         PyObject* elem = PySequence_GetItem(tuple, i);
         int ok = elem != NULL;
         long  type = 0;
@@ -747,31 +660,52 @@
         }
         if (!ok) {
             PyErr_SetObject(parser_error,
-                            Py_BuildValue("(os)", elem,
+                            Py_BuildValue("os", elem,
                                           "Illegal node construct."));
             Py_XDECREF(elem);
             return (0);
         }
         if (ISTERMINAL(type)) {
-            if (check_terminal_tuple(elem)) {
-                PyObject *temp = PySequence_GetItem(elem, 1);
+            int len = PyObject_Size(elem);
+            PyObject *temp;
 
-                /* check_terminal_tuple() already verified it's a string */
-                strn = (char *)PyMem_MALLOC(PyString_GET_SIZE(temp) + 1);
-                if (strn != NULL)
-                    (void) strcpy(strn, PyString_AS_STRING(temp));
+            if ((len != 2) && (len != 3)) {
+                err_string("Terminal nodes must have 2 or 3 entries.");
+                return 0;
+            }
+            temp = PySequence_GetItem(elem, 1);
+            if (temp == NULL)
+                return 0;
+            if (!PyString_Check(temp)) {
+                PyErr_Format(parser_error,
+                             "Second item in terminal node must be a string,"
+                             " found %s.",
+                             ((PyTypeObject*)PyObject_Type(temp))->tp_name);
                 Py_DECREF(temp);
-
-                if (PyObject_Size(elem) == 3) {
-                    PyObject* temp = PySequence_GetItem(elem, 2);
-                    *line_num = PyInt_AsLong(temp);
-                    Py_DECREF(temp);
+                return 0;
+            }
+            if (len == 3) {
+                PyObject *o = PySequence_GetItem(elem, 2);
+                if (o != NULL) {
+                    if (PyInt_Check(o))
+                        *line_num = PyInt_AS_LONG(o);
+                    else {
+                        PyErr_Format(parser_error,
+                                     "Third item in terminal node must be an"
+                                     " integer, found %s.",
+                                ((PyTypeObject*)PyObject_Type(temp))->tp_name);
+                        Py_DECREF(o);
+                        Py_DECREF(temp);
+                        return 0;
+                    }
+                    Py_DECREF(o);
                 }
             }
-            else {
-                Py_XDECREF(elem);
-                return (0);
-            }
+            len = PyString_GET_SIZE(temp) + 1;
+            strn = (char *)PyMem_MALLOC(len);
+            if (strn != NULL)
+                (void) memcpy(strn, PyString_AS_STRING(temp), len);
+            Py_DECREF(temp);
         }
         else if (!ISNONTERMINAL(type)) {
             /*
@@ -779,8 +713,7 @@
              *  Throw an exception.
              */
             PyErr_SetObject(parser_error,
-                            Py_BuildValue("(os)", elem,
-                                          "Unknown node type."));
+                            Py_BuildValue("os", elem, "Unknown node type."));
             Py_XDECREF(elem);
             return (0);
         }
@@ -808,7 +741,7 @@
 {
     node* res = 0;
     PyObject *temp = PySequence_GetItem(tuple, 0);
-    long  num = -1;
+    long num = -1;
 
     if (temp != NULL)
         num = PyInt_AsLong(temp);
@@ -818,8 +751,8 @@
          *  The tuple is simple, but it doesn't start with a start symbol.
          *  Throw an exception now and be done with it.
          */
-        tuple = Py_BuildValue("(os)", tuple,
-                    "Illegal ast tuple; cannot start with terminal symbol.");
+        tuple = Py_BuildValue("os", tuple,
+                      "Illegal ast tuple; cannot start with terminal symbol.");
         PyErr_SetObject(parser_error, tuple);
     }
     else if (ISNONTERMINAL(num)) {
@@ -836,19 +769,17 @@
     }
     else
         /*  The tuple is illegal -- if the number is neither TERMINAL nor
-         *  NONTERMINAL, we can't use it.
+         *  NONTERMINAL, we can't use it.  Not sure the implementation
+         *  allows this condition, but the API doesn't preclude it.
          */
         PyErr_SetObject(parser_error,
-                        Py_BuildValue("(os)", tuple,
+                        Py_BuildValue("os", tuple,
                                       "Illegal component tuple."));
 
     return (res);
 }
 
 
-#define VALIDATER(n)    static int validate_##n(node *tree)
-
-
 /*
  *  Validation routines used within the validation section:
  */
@@ -871,6 +802,8 @@
 #define validate_dot(ch)        validate_terminal(ch,        DOT, ".")
 #define validate_name(ch, str)  validate_terminal(ch,       NAME, str)
 
+#define VALIDATER(n)    static int validate_##n(node *tree)
+
 VALIDATER(node);                VALIDATER(small_stmt);
 VALIDATER(class);               VALIDATER(node);
 VALIDATER(parameters);          VALIDATER(suite);
@@ -899,6 +832,7 @@
 VALIDATER(arglist);             VALIDATER(argument);
 VALIDATER(listmaker);
 
+#undef VALIDATER
 
 #define is_even(n)      (((n) & 1) == 0)
 #define is_odd(n)       (((n) & 1) == 1)
@@ -907,14 +841,12 @@
 static int
 validate_ntype(node *n, int t)
 {
-    int res = (TYPE(n) == t);
-
-    if (!res) {
-        char buffer[128];
-        (void) sprintf(buffer, "Expected node type %d, got %d.", t, TYPE(n));
-        err_string(buffer);
+    if (TYPE(n) != t) {
+        PyErr_Format(parser_error, "Expected node type %d, got %d.",
+                     t, TYPE(n));
+        return 0;
     }
-    return (res);
+    return 1;
 }
 
 
@@ -929,11 +861,11 @@
 validate_numnodes(node *n, int num, const char *const name)
 {
     if (NCH(n) != num) {
-        char buff[60];
-        (void) sprintf(buff, "Illegal number of children for %s node.", name);
-        err_string(buff);
+        PyErr_Format(parser_error,
+                     "Illegal number of children for %s node.", name);
+        return 0;
     }
-    return (NCH(n) == num);
+    return 1;
 }
 
 
@@ -944,9 +876,8 @@
                && ((string == 0) || (strcmp(string, STR(terminal)) == 0)));
 
     if (!res && !PyErr_Occurred()) {
-        char buffer[60];
-        (void) sprintf(buffer, "Illegal terminal: expected \"%s\"", string);
-        err_string(buffer);
+        PyErr_Format(parser_error,
+                     "Illegal terminal: expected \"%s\"", string);
     }
     return (res);
 }
@@ -1395,24 +1326,31 @@
 validate_small_stmt(node *tree)
 {
     int nch = NCH(tree);
-    int res = (validate_numnodes(tree, 1, "small_stmt")
-               && ((TYPE(CHILD(tree, 0)) == expr_stmt)
-                   || (TYPE(CHILD(tree, 0)) == print_stmt)
-                   || (TYPE(CHILD(tree, 0)) == del_stmt)
-                   || (TYPE(CHILD(tree, 0)) == pass_stmt)
-                   || (TYPE(CHILD(tree, 0)) == flow_stmt)
-                   || (TYPE(CHILD(tree, 0)) == import_stmt)
-                   || (TYPE(CHILD(tree, 0)) == global_stmt)
-                   || (TYPE(CHILD(tree, 0)) == assert_stmt)
-                   || (TYPE(CHILD(tree, 0)) == exec_stmt)));
+    int res = validate_numnodes(tree, 1, "small_stmt");
 
-    if (res)
-        res = validate_node(CHILD(tree, 0));
+    if (res) {
+        int ntype = TYPE(CHILD(tree, 0));
+
+        if (  (ntype == expr_stmt)
+              || (ntype == print_stmt)
+              || (ntype == del_stmt)
+              || (ntype == pass_stmt)
+              || (ntype == flow_stmt)
+              || (ntype == import_stmt)
+              || (ntype == global_stmt)
+              || (ntype == assert_stmt)
+              || (ntype == exec_stmt))
+            res = validate_node(CHILD(tree, 0));
+        else {
+            res = 0;
+            err_string("illegal small_stmt child type");
+        }
+    }
     else if (nch == 1) {
-        char buffer[60];
-        (void) sprintf(buffer, "Unrecognized child node of small_stmt: %d.",
-                       TYPE(CHILD(tree, 0)));
-        err_string(buffer);
+        res = 0;
+        PyErr_Format(parser_error,
+                     "Unrecognized child node of small_stmt: %d.",
+                     TYPE(CHILD(tree, 0)));
     }
     return (res);
 }
@@ -1426,24 +1364,24 @@
 {
     int res = (validate_ntype(tree, compound_stmt)
                && validate_numnodes(tree, 1, "compound_stmt"));
+    int ntype;
 
     if (!res)
         return (0);
 
     tree = CHILD(tree, 0);
-    res = ((TYPE(tree) == if_stmt)
-           || (TYPE(tree) == while_stmt)
-           || (TYPE(tree) == for_stmt)
-           || (TYPE(tree) == try_stmt)
-           || (TYPE(tree) == funcdef)
-           || (TYPE(tree) == classdef));
-    if (res)
+    ntype = TYPE(tree);
+    if (  (ntype == if_stmt)
+          || (ntype == while_stmt)
+          || (ntype == for_stmt)
+          || (ntype == try_stmt)
+          || (ntype == funcdef)
+          || (ntype == classdef))
         res = validate_node(tree);
     else {
-        char buffer[60];
-        (void) sprintf(buffer, "Illegal compound statement type: %d.",
-                       TYPE(tree));
-        err_string(buffer);
+        res = 0;
+        PyErr_Format(parser_error,
+                     "Illegal compound statement type: %d.", TYPE(tree));
     }
     return (res);
 }
@@ -1814,14 +1752,13 @@
                && validate_suite(CHILD(tree, 2))
                && validate_colon(CHILD(tree, nch - 2))
                && validate_suite(CHILD(tree, nch - 1)));
-    else {
+    else if (!PyErr_Occurred()) {
         const char* name = "except";
-        char buffer[60];
         if (TYPE(CHILD(tree, nch - 3)) != except_clause)
             name = STR(CHILD(tree, nch - 3));
-        (void) sprintf(buffer,
-                       "Illegal number of children for try/%s node.", name);
-        err_string(buffer);
+
+        PyErr_Format(parser_error,
+                     "Illegal number of children for try/%s node.", name);
     }
     /*  Skip past except_clause sections:  */
     while (res && (TYPE(CHILD(tree, pos)) == except_clause)) {
@@ -1974,9 +1911,8 @@
               res = ((strcmp(STR(tree), "in") == 0)
                      || (strcmp(STR(tree), "is") == 0));
               if (!res) {
-                  char buff[128];
-                  (void) sprintf(buff, "Illegal operator: '%s'.", STR(tree));
-                  err_string(buff);
+                  PyErr_Format(parser_error,
+                               "Illegal operator: '%s'.", STR(tree));
               }
               break;
           default:
@@ -2582,7 +2518,7 @@
             break;
           case small_stmt:
             /*
-             *  expr_stmt | print_stmt  | del_stmt | pass_stmt | flow_stmt
+             *  expr_stmt | print_stmt | del_stmt | pass_stmt | flow_stmt
              *  | import_stmt | global_stmt | exec_stmt | assert_stmt
              */
             res = validate_small_stmt(tree);