/* parsermodule.c

*

* Copyright 1995-1996 by Fred L. Drake, Jr. and Virginia Polytechnic

* Institute and State University, Blacksburg, Virginia, USA.

* Portions copyright 1991-1995 by Stichting Mathematisch Centrum,

* Amsterdam, The Netherlands. Copying is permitted under the terms

* associated with the main Python distribution, with the additional

* restriction that this additional notice be included and maintained

* on all distributed copies.

*

* This module serves to replace the original parser module written

* by Guido. The functionality is not matched precisely, but the

* original may be implemented on top of this. This is desirable

* since the source of the text to be parsed is now divorced from

* this interface.

*

* Unlike the prior interface, the ability to give a parse tree

* produced by Python code as a tuple to the compiler is enabled by

* this module. See the documentation for more details.

*

* I've added some annotations that help with the lint code-checking

* program, but they're not complete by a long shot. The real errors

* that lint detects are gone, but there are still warnings with

* Py_[X]DECREF() and Py_[X]INCREF() macros. The lint annotations

* look like "NOTE(...)".

*/

#include "Python.h" /* general Python API */

#include "graminit.h" /* symbols defined in the grammar */

#include "node.h" /* internal parser structure */

#include "token.h" /* token definitions */

/* ISTERMINAL() / ISNONTERMINAL() */

#include "compile.h" /* PyNode_Compile() */

#ifdef lint

#include <note.h>

#else

#define NOTE(x)

#endif

#ifdef macintosh

char *strdup(char *);

#endif

/* String constants used to initialize module attributes.

*

*/

static char*

parser_copyright_string

= "Copyright 1995-1996 by Virginia Polytechnic Institute & State\n\

University, Blacksburg, Virginia, USA, and Fred L. Drake, Jr., Reston,\n\

Virginia, USA. Portions copyright 1991-1995 by Stichting Mathematisch\n\

Centrum, Amsterdam, The Netherlands.";

static char*

parser_doc_string

= "This is an interface to Python's internal parser.";

static char*

parser_version_string = "0.5";

typedef PyObject* (*SeqMaker) (int length);

typedef int (*SeqInserter) (PyObject* sequence,

int index,

PyObject* element);

/* The function below is copyrighted by Stichting Mathematisch Centrum. The

* original copyright statement is included below, and continues to apply

* in full to the function immediately following. All other material is

* original, copyrighted by Fred L. Drake, Jr. and Virginia Polytechnic

* Institute and State University. Changes were made to comply with the

* new naming conventions. Added arguments to provide support for creating

* lists as well as tuples, and optionally including the line numbers.

*/

static PyObject*

node2tuple(node *n, /* node to convert */

SeqMaker mkseq, /* create sequence */

SeqInserter addelem, /* func. to add elem. in seq. */

int lineno) /* include line numbers? */

{

if (n == NULL) {

Py_INCREF(Py_None);

return (Py_None);

}

if (ISNONTERMINAL(TYPE(n))) {

int i;

PyObject *v;

PyObject *w;

v = mkseq(1 + NCH(n));

if (v == NULL)

return (v);

w = PyInt_FromLong(TYPE(n));

if (w == NULL) {

Py_DECREF(v);

return ((PyObject*) NULL);

}

(void) addelem(v, 0, w);

for (i = 0; i < NCH(n); i++) {

w = node2tuple(CHILD(n, i), mkseq, addelem, lineno);

if (w == NULL) {

Py_DECREF(v);

return ((PyObject*) NULL);

}

(void) addelem(v, i+1, w);

}

return (v);

}

else if (ISTERMINAL(TYPE(n))) {

PyObject *result = mkseq(2 + lineno);

if (result != NULL) {

(void) addelem(result, 0, PyInt_FromLong(TYPE(n)));

(void) addelem(result, 1, PyString_FromString(STR(n)));

if (lineno == 1)

(void) addelem(result, 2, PyInt_FromLong(n->n_lineno));

}

return (result);

}

else {

PyErr_SetString(PyExc_SystemError,

"unrecognized parse tree node type");

return ((PyObject*) NULL);

}

}

/*

* End of material copyrighted by Stichting Mathematisch Centrum.

*/

/* There are two types of intermediate objects we're interested in:

* 'eval' and 'exec' types. These constants can be used in the ast_type

* field of the object type to identify which any given object represents.

* These should probably go in an external header to allow other extensions

* to use them, but then, we really should be using C++ too. ;-)

*

* The PyAST_FRAGMENT type is not currently supported. Maybe not useful?

* Haven't decided yet.

*/

#define PyAST_EXPR 1

#define PyAST_SUITE 2

#define PyAST_FRAGMENT 3

/* These are the internal objects and definitions required to implement the

* AST type. Most of the internal names are more reminiscent of the 'old'

* naming style, but the code uses the new naming convention.

*/

static PyObject*

parser_error = 0;

typedef struct _PyAST_Object {

PyObject_HEAD /* standard object header */

node* ast_node; /* the node* returned by the parser */

int ast_type; /* EXPR or SUITE ? */

} PyAST_Object;

staticforward void

parser_free(PyAST_Object *ast);

staticforward int

parser_compare(PyAST_Object *left, PyAST_Object *right);

staticforward PyObject *

parser_getattr(PyObject *self, char *name);

static

PyTypeObject PyAST_Type = {

PyObject_HEAD_INIT(NULL)

0,

"ast", /* tp_name */

(int) sizeof(PyAST_Object), /* tp_basicsize */

0, /* tp_itemsize */

(destructor)parser_free, /* tp_dealloc */

0, /* tp_print */

parser_getattr, /* tp_getattr */

0, /* tp_setattr */

(cmpfunc)parser_compare, /* tp_compare */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

0, /* tp_getattro */

0, /* tp_setattro */

/* Functions to access object as input/output buffer */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT, /* tp_flags */

/* __doc__ */

"Intermediate representation of a Python parse tree."

}; /* PyAST_Type */

static int

parser_compare_nodes(node *left, node *right)

{

int j;

if (TYPE(left) < TYPE(right))

return (-1);

if (TYPE(right) < TYPE(left))

return (1);

if (ISTERMINAL(TYPE(left)))

return (strcmp(STR(left), STR(right)));

if (NCH(left) < NCH(right))

return (-1);

if (NCH(right) < NCH(left))

return (1);

for (j = 0; j < NCH(left); ++j) {

int v = parser_compare_nodes(CHILD(left, j), CHILD(right, j));

if (v != 0)

return (v);

}

return (0);

}

/* int parser_compare(PyAST_Object* left, PyAST_Object* right)

*

* Comparison function used by the Python operators ==, !=, <, >, <=, >=

* This really just wraps a call to parser_compare_nodes() with some easy

* checks and protection code.

*

*/

static int

parser_compare(PyAST_Object *left, PyAST_Object *right)

{

if (left == right)

return (0);

if ((left == 0) || (right == 0))

return (-1);

return (parser_compare_nodes(left->ast_node, right->ast_node));

}

/* parser_newastobject(node* ast)

*

* Allocates a new Python object representing an AST. This is simply the

* 'wrapper' object that holds a node* and allows it to be passed around in

* Python code.

*

*/

static PyObject*

parser_newastobject(node *ast, int type)

{

PyAST_Object* o = PyObject_New(PyAST_Object, &PyAST_Type);

if (o != 0) {

o->ast_node = ast;

o->ast_type = type;

}

else {

PyNode_Free(ast);

}

return ((PyObject*)o);

}

/* void parser_free(PyAST_Object* ast)

*

* This is called by a del statement that reduces the reference count to 0.

*

*/

static void

parser_free(PyAST_Object *ast)

{

PyNode_Free(ast->ast_node);

PyObject_Del(ast);

}

/* parser_ast2tuple(PyObject* self, PyObject* args, PyObject* kw)

*

* This provides conversion from a node* to a tuple object that can be

* returned to the Python-level caller. The AST object is not modified.

*

*/

static PyObject*

parser_ast2tuple(PyAST_Object *self, PyObject *args, PyObject *kw)

{

PyObject *line_option = 0;

PyObject *res = 0;

int ok;

static char *keywords[] = {"ast", "line_info", NULL};

if (self == NULL) {

ok = PyArg_ParseTupleAndKeywords(args, kw, "O!|O:ast2tuple", keywords,

&PyAST_Type, &self, &line_option);

}

else

ok = PyArg_ParseTupleAndKeywords(args, kw, "|O:totuple", &keywords[1],

&line_option);

if (ok != 0) {

int lineno = 0;

if (line_option != NULL) {

lineno = (PyObject_IsTrue(line_option) != 0) ? 1 : 0;

}

/*

* Convert AST into a tuple representation. Use Guido's function,

* since it's known to work already.

*/

res = node2tuple(((PyAST_Object*)self)->ast_node,

PyTuple_New, PyTuple_SetItem, lineno);

}

return (res);

}

/* parser_ast2list(PyObject* self, PyObject* args, PyObject* kw)

*

* This provides conversion from a node* to a list object that can be

* returned to the Python-level caller. The AST object is not modified.

*

*/

static PyObject*

parser_ast2list(PyAST_Object *self, PyObject *args, PyObject *kw)

{

PyObject *line_option = 0;

PyObject *res = 0;

int ok;

static char *keywords[] = {"ast", "line_info", NULL};

if (self == NULL)

ok = PyArg_ParseTupleAndKeywords(args, kw, "O!|O:ast2list", keywords,

&PyAST_Type, &self, &line_option);

else

ok = PyArg_ParseTupleAndKeywords(args, kw, "|O:tolist", &keywords[1],

&line_option);

if (ok) {

int lineno = 0;

if (line_option != 0) {

lineno = PyObject_IsTrue(line_option) ? 1 : 0;

}

/*

* Convert AST into a tuple representation. Use Guido's function,

* since it's known to work already.

*/

res = node2tuple(self->ast_node,

PyList_New, PyList_SetItem, lineno);

}

return (res);

}

/* parser_compileast(PyObject* self, PyObject* args)

*

* This function creates code objects from the parse tree represented by

* the passed-in data object. An optional file name is passed in as well.

*

*/

static PyObject*

parser_compileast(PyAST_Object *self, PyObject *args, PyObject *kw)

{

PyObject* res = 0;

char* str = "<ast>";

int ok;

static char *keywords[] = {"ast", "filename", NULL};

if (self == NULL)

ok = PyArg_ParseTupleAndKeywords(args, kw, "O!|s:compileast", keywords,

&PyAST_Type, &self, &str);

else

ok = PyArg_ParseTupleAndKeywords(args, kw, "|s:compile", &keywords[1],

&str);

if (ok)

res = (PyObject *)PyNode_Compile(self->ast_node, str);

return (res);

}

/* PyObject* parser_isexpr(PyObject* self, PyObject* args)

* PyObject* parser_issuite(PyObject* self, PyObject* args)

*

* Checks the passed-in AST object to determine if it is an expression or

* a statement suite, respectively. The return is a Python truth value.

*

*/

static PyObject*

parser_isexpr(PyAST_Object *self, PyObject *args, PyObject *kw)

{

PyObject* res = 0;

int ok;

static char *keywords[] = {"ast", NULL};

if (self == NULL)

ok = PyArg_ParseTupleAndKeywords(args, kw, "O!:isexpr", keywords,

&PyAST_Type, &self);

else

ok = PyArg_ParseTupleAndKeywords(args, kw, ":isexpr", &keywords[1]);

if (ok) {

/* Check to see if the AST represents an expression or not. */

res = (self->ast_type == PyAST_EXPR) ? Py_True : Py_False;

Py_INCREF(res);

}

return (res);

}

static PyObject*

parser_issuite(PyAST_Object *self, PyObject *args, PyObject *kw)

{

PyObject* res = 0;

int ok;

static char *keywords[] = {"ast", NULL};

if (self == NULL)

ok = PyArg_ParseTupleAndKeywords(args, kw, "O!:issuite", keywords,

&PyAST_Type, &self);

else

ok = PyArg_ParseTupleAndKeywords(args, kw, ":issuite", &keywords[1]);

if (ok) {

/* Check to see if the AST represents an expression or not. */

res = (self->ast_type == PyAST_EXPR) ? Py_False : Py_True;

Py_INCREF(res);

}

return (res);

}

#define PUBLIC_METHOD_TYPE (METH_VARARGS|METH_KEYWORDS)

static PyMethodDef

parser_methods[] = {

{"compile", (PyCFunction)parser_compileast, PUBLIC_METHOD_TYPE,

"Compile this AST object into a code object."},

{"isexpr", (PyCFunction)parser_isexpr, PUBLIC_METHOD_TYPE,

"Determines if this AST object was created from an expression."},

{"issuite", (PyCFunction)parser_issuite, PUBLIC_METHOD_TYPE,

"Determines if this AST object was created from a suite."},

{"tolist", (PyCFunction)parser_ast2list, PUBLIC_METHOD_TYPE,

"Creates a list-tree representation of this AST."},

{"totuple", (PyCFunction)parser_ast2tuple, PUBLIC_METHOD_TYPE,

"Creates a tuple-tree representation of this AST."},

{NULL, NULL, 0, NULL}

};

static PyObject*

parser_getattr(PyObject *self, char *name)

{

return (Py_FindMethod(parser_methods, self, name));

}

/* err_string(char* message)

*

* Sets the error string for an exception of type ParserError.

*

*/

static void

err_string(char *message)

{

PyErr_SetString(parser_error, message);

}

/* PyObject* parser_do_parse(PyObject* args, int type)

*

* Internal function to actually execute the parse and return the result if

* successful, or set an exception if not.

*

*/

static PyObject*

parser_do_parse(PyObject *args, PyObject *kw, char *argspec, int type)

{

char* string = 0;

PyObject* res = 0;

static char *keywords[] = {"source", NULL};

if (PyArg_ParseTupleAndKeywords(args, kw, argspec, keywords, &string)) {

node* n = PyParser_SimpleParseString(string,

(type == PyAST_EXPR)

? eval_input : file_input);

if (n != 0)

res = parser_newastobject(n, type);

else

err_string("Could not parse string.");

}

return (res);

}

/* PyObject* parser_expr(PyObject* self, PyObject* args)

* PyObject* parser_suite(PyObject* self, PyObject* args)

*

* External interfaces to the parser itself. Which is called determines if

* the parser attempts to recognize an expression ('eval' form) or statement

* suite ('exec' form). The real work is done by parser_do_parse() above.

*

*/

static PyObject*

parser_expr(PyAST_Object *self, PyObject *args, PyObject *kw)

{

NOTE(ARGUNUSED(self))

return (parser_do_parse(args, kw, "s:expr", PyAST_EXPR));

}

static PyObject*

parser_suite(PyAST_Object *self, PyObject *args, PyObject *kw)

{

NOTE(ARGUNUSED(self))

return (parser_do_parse(args, kw, "s:suite", PyAST_SUITE));

}

/* This is the messy part of the code. Conversion from a tuple to an AST

* object requires that the input tuple be valid without having to rely on

* catching an exception from the compiler. This is done to allow the

* compiler itself to remain fast, since most of its input will come from

* the parser directly, and therefore be known to be syntactically correct.

* This validation is done to ensure that we don't core dump the compile

* phase, returning an exception instead.

*

* Two aspects can be broken out in this code: creating a node tree from

* the tuple passed in, and verifying that it is indeed valid. It may be

* advantageous to expand the number of AST types to include funcdefs and

* lambdadefs to take advantage of the optimizer, recognizing those ASTs

* here. They are not necessary, and not quite as useful in a raw form.

* For now, let's get expressions and suites working reliably.

*/

staticforward node* build_node_tree(PyObject *tuple);

staticforward int validate_expr_tree(node *tree);

staticforward int validate_file_input(node *tree);

/* PyObject* parser_tuple2ast(PyObject* self, PyObject* args)

*

* This is the public function, called from the Python code. It receives a

* single tuple object from the caller, and creates an AST object if the

* tuple can be validated. It does this by checking the first code of the

* tuple, and, if acceptable, builds the internal representation. If this

* step succeeds, the internal representation is validated as fully as

* possible with the various validate_*() routines defined below.

*

* This function must be changed if support is to be added for PyAST_FRAGMENT

* AST objects.

*

*/

static PyObject*

parser_tuple2ast(PyAST_Object *self, PyObject *args, PyObject *kw)

{

NOTE(ARGUNUSED(self))

PyObject *ast = 0;

PyObject *tuple;

node *tree;

static char *keywords[] = {"sequence", NULL};

if (!PyArg_ParseTupleAndKeywords(args, kw, "O:sequence2ast", keywords,

&tuple))

return (0);

if (!PySequence_Check(tuple)) {

PyErr_SetString(PyExc_ValueError,

"sequence2ast() requires a single sequence argument");

return (0);

}

/*

* Convert the tree to the internal form before checking it.

*/

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);

}

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.");

}

}

/* 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.

*/

if ((ast == 0) && !PyErr_Occurred())

err_string("Unspecified ast error occurred.");

return (ast);

}

/* node* build_node_children()

*

* Iterate across the children of the current non-terminal node and build

* their structures. If successful, return the root of this portion of

* the tree, otherwise, 0. Any required exception will be specified already,

* and no memory will have been deallocated.

*

*/

static node*

build_node_children(PyObject *tuple, node *root, int *line_num)

{

int len = PyObject_Size(tuple);

int i;

for (i = 1; i < len; ++i) {

/* elem must always be a sequence, however simple */

PyObject* elem = PySequence_GetItem(tuple, i);

int ok = elem != NULL;

long type = 0;

char *strn = 0;

if (ok)

ok = PySequence_Check(elem);

if (ok) {

PyObject *temp = PySequence_GetItem(elem, 0);

if (temp == NULL)

ok = 0;

else {

ok = PyInt_Check(temp);

if (ok)

type = PyInt_AS_LONG(temp);

Py_DECREF(temp);

}

}

if (!ok) {

PyErr_SetObject(parser_error,

Py_BuildValue("os", elem,

"Illegal node construct."));

Py_XDECREF(elem);

return (0);

}

if (ISTERMINAL(type)) {

int len = PyObject_Size(elem);

PyObject *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);

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);

}

}

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)) {

/*

* It has to be one or the other; this is an error.

* Throw an exception.

*/

PyErr_SetObject(parser_error,

Py_BuildValue("os", elem, "Unknown node type."));

Py_XDECREF(elem);

return (0);

}

PyNode_AddChild(root, type, strn, *line_num);

if (ISNONTERMINAL(type)) {

node* new_child = CHILD(root, i - 1);

if (new_child != build_node_children(elem, new_child, line_num)) {

Py_XDECREF(elem);

return (0);

}

}

else if (type == NEWLINE) { /* It's true: we increment the */

++(*line_num); /* line number *after* the newline! */

}

Py_XDECREF(elem);

}

return (root);

}

static node*

build_node_tree(PyObject *tuple)

{

node* res = 0;

PyObject *temp = PySequence_GetItem(tuple, 0);

long num = -1;

if (temp != NULL)

num = PyInt_AsLong(temp);

Py_XDECREF(temp);

if (ISTERMINAL(num)) {

/*

* 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.");

PyErr_SetObject(parser_error, tuple);

}

else if (ISNONTERMINAL(num)) {

/*

* Not efficient, but that can be handled later.

*/

int line_num = 0;

res = PyNode_New(num);

if (res != build_node_children(tuple, res, &line_num)) {

PyNode_Free(res);

res = 0;

}

}

else

/* The tuple is illegal -- if the number is neither TERMINAL nor

* 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,

"Illegal component tuple."));

return (res);

}

/*

* Validation routines used within the validation section:

*/

staticforward int validate_terminal(node *terminal, int type, char *string);

#define validate_ampersand(ch) validate_terminal(ch, AMPER, "&")

#define validate_circumflex(ch) validate_terminal(ch, CIRCUMFLEX, "^")

#define validate_colon(ch) validate_terminal(ch, COLON, ":")

#define validate_comma(ch) validate_terminal(ch, COMMA, ",")

#define validate_dedent(ch) validate_terminal(ch, DEDENT, "")

#define validate_equal(ch) validate_terminal(ch, EQUAL, "=")

#define validate_indent(ch) validate_terminal(ch, INDENT, (char*)NULL)

#define validate_lparen(ch) validate_terminal(ch, LPAR, "(")

#define validate_newline(ch) validate_terminal(ch, NEWLINE, (char*)NULL)

#define validate_rparen(ch) validate_terminal(ch, RPAR, ")")

#define validate_semi(ch) validate_terminal(ch, SEMI, ";")

#define validate_star(ch) validate_terminal(ch, STAR, "*")

#define validate_vbar(ch) validate_terminal(ch, VBAR, "|")

#define validate_doublestar(ch) validate_terminal(ch, DOUBLESTAR, "**")

#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);

VALIDATER(testlist); VALIDATER(varargslist);

VALIDATER(fpdef); VALIDATER(fplist);

VALIDATER(stmt); VALIDATER(simple_stmt);

VALIDATER(expr_stmt); VALIDATER(power);

VALIDATER(print_stmt); VALIDATER(del_stmt);

VALIDATER(return_stmt); VALIDATER(list_iter);

VALIDATER(raise_stmt); VALIDATER(import_stmt);

VALIDATER(global_stmt); VALIDATER(list_if);

VALIDATER(assert_stmt); VALIDATER(list_for);

VALIDATER(exec_stmt); VALIDATER(compound_stmt);

VALIDATER(while); VALIDATER(for);

VALIDATER(try); VALIDATER(except_clause);

VALIDATER(test); VALIDATER(and_test);

VALIDATER(not_test); VALIDATER(comparison);

VALIDATER(comp_op); VALIDATER(expr);

VALIDATER(xor_expr); VALIDATER(and_expr);

VALIDATER(shift_expr); VALIDATER(arith_expr);

VALIDATER(term); VALIDATER(factor);

VALIDATER(atom); VALIDATER(lambdef);

VALIDATER(trailer); VALIDATER(subscript);

VALIDATER(subscriptlist); VALIDATER(sliceop);

VALIDATER(exprlist); VALIDATER(dictmaker);

VALIDATER(arglist); VALIDATER(argument);

VALIDATER(listmaker);

#undef VALIDATER

#define is_even(n) (((n) & 1) == 0)

#define is_odd(n) (((n) & 1) == 1)

static int

validate_ntype(node *n, int t)

{

if (TYPE(n) != t) {

PyErr_Format(parser_error, "Expected node type %d, got %d.",

t, TYPE(n));

return 0;

}

return 1;

}

/* Verifies that the number of child nodes is exactly 'num', raising

* an exception if it isn't. The exception message does not indicate

* the exact number of nodes, allowing this to be used to raise the

* "right" exception when the wrong number of nodes is present in a

* specific variant of a statement's syntax. This is commonly used

* in that fashion.

*/

static int

validate_numnodes(node *n, int num, const char *const name)

{

if (NCH(n) != num) {

PyErr_Format(parser_error,

"Illegal number of children for %s node.", name);

return 0;

}

return 1;

}

static int

validate_terminal(node *terminal, int type, char *string)

{

int res = (validate_ntype(terminal, type)

&& ((string == 0) || (strcmp(string, STR(terminal)) == 0)));

if (!res && !PyErr_Occurred()) {

PyErr_Format(parser_error,

"Illegal terminal: expected \"%s\"", string);

}

return (res);

}

/* X (',' X) [',']

*/

static int

validate_repeating_list(node *tree, int ntype, int (*vfunc)(node *),

const char *const name)

{

int nch = NCH(tree);

int res = (nch && validate_ntype(tree, ntype)

&& vfunc(CHILD(tree, 0)));

if (!res && !PyErr_Occurred())

(void) validate_numnodes(tree, 1, name);

else {

if (is_even(nch))

res = validate_comma(CHILD(tree, --nch));

if (res && nch > 1) {

int pos = 1;

for ( ; res && pos < nch; pos += 2)

res = (validate_comma(CHILD(tree, pos))

&& vfunc(CHILD(tree, pos + 1)));

}

}

return (res);

}

/* validate_class()

*

* classdef:

* 'class' NAME ['(' testlist ')'] ':' suite

*/

static int

validate_class(node *tree)

{

int nch = NCH(tree);

int res = validate_ntype(tree, classdef) && ((nch == 4) || (nch == 7));

if (res) {

res = (validate_name(CHILD(tree, 0), "class")

&& validate_ntype(CHILD(tree, 1), NAME)

&& validate_colon(CHILD(tree, nch - 2))

&& validate_suite(CHILD(tree, nch - 1)));

}

else

(void) validate_numnodes(tree, 4, "class");

if (res && (nch == 7)) {

res = (validate_lparen(CHILD(tree, 2))

&& validate_testlist(CHILD(tree, 3))

&& validate_rparen(CHILD(tree, 4)));

}

return (res);

}

/* if_stmt:

* 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]

*/

static int

validate_if(node *tree)

{

int nch = NCH(tree);

int res = (validate_ntype(tree, if_stmt)

&& (nch >= 4)

&& validate_name(CHILD(tree, 0), "if")

&& validate_test(CHILD(tree, 1))

&& validate_colon(CHILD(tree, 2))

&& validate_suite(CHILD(tree, 3)));

if (res && ((nch % 4) == 3)) {

/* ... 'else' ':' suite */

res = (validate_name(CHILD(tree, nch - 3), "else")

&& validate_colon(CHILD(tree, nch - 2))

&& validate_suite(CHILD(tree, nch - 1)));

nch -= 3;

}

else if (!res && !PyErr_Occurred())

(void) validate_numnodes(tree, 4, "if");

if ((nch % 4) != 0)

/* Will catch the case for nch < 4 */

res = validate_numnodes(tree, 0, "if");

else if (res && (nch > 4)) {

/* ... ('elif' test ':' suite)+ ... */

int j = 4;

while ((j < nch) && res) {

res = (validate_name(CHILD(tree, j), "elif")

&& validate_colon(CHILD(tree, j + 2))

&& validate_test(CHILD(tree, j + 1))

&& validate_suite(CHILD(tree, j + 3)));

j += 4;

}

}

return (res);

}

/* parameters:

* '(' [varargslist] ')'

*

*/

static int

validate_parameters(node *tree)

{

int nch = NCH(tree);

int res = validate_ntype(tree, parameters) && ((nch == 2) || (nch == 3));

if (res) {

res = (validate_lparen(CHILD(tree, 0))

&& validate_rparen(CHILD(tree, nch - 1)));

if (res && (nch == 3))

res = validate_varargslist(CHILD(tree, 1));

}

else {

(void) validate_numnodes(tree, 2, "parameters");

}

return (res);