#! @PYTHON3@

import getopt
import os
import re
import sys

import ovs.json
import ovs.db.error
import ovs.db.schema
from ovs.db.types import StringType, IntegerType, RealType

argv0 = sys.argv[0]

def parseSchema(filename):
    return ovs.db.schema.IdlSchema.from_json(ovs.json.from_file(filename))

def annotateSchema(schemaFile, annotationFile):
    schemaJson = ovs.json.from_file(schemaFile)
    exec(compile(open(annotationFile, "rb").read(), annotationFile, 'exec'), globals(), {"s": schemaJson})
    ovs.json.to_stream(schemaJson, sys.stdout)
    sys.stdout.write('\n')

def constify(cType, const):
    if (const
        and cType.endswith('*') and
        (cType == 'char **' or not cType.endswith('**'))):
        return 'const %s' % cType
    else:
        return cType

def cMembers(prefix, tableName, columnName, column, const, refTable=True):
    comment = ""
    type = column.type

    if type.is_smap():
        comment = """
/* Sets the "%(c)s" column's value from the "%(t)s" table in 'row'
 * to '%(c)s'.
 *
 * The caller retains ownership of '%(c)s' and everything in it. */""" \
             % {'c': columnName,
                't': tableName}
        return (comment, [{'name': columnName,
                           'type': 'struct smap ',
                           'comment': ''}])

    comment = """\n/* Sets the "%s" column from the "%s" table in """\
              """'row' to\n""" % (columnName, tableName)

    if type.n_min == 1 and type.n_max == 1:
        singleton = True
        pointer = ''
    else:
        singleton = False
        if type.is_optional_pointer():
            pointer = ''
        else:
            pointer = '*'


    if type.value:
        keyName = "key_%s" % columnName
        valueName = "value_%s" % columnName

        key = {'name': keyName,
               'type': constify(type.key.toCType(prefix, refTable) + pointer, const),
               'comment': ''}
        value = {'name': valueName,
                 'type': constify(type.value.toCType(prefix, refTable) + pointer, const),
                 'comment': ''}

        if singleton:
            comment += " * the map with key '%s' and value '%s'\n *" \
                       % (keyName, valueName)
        else:
            comment += " * the map with keys '%s' and values '%s'\n *" \
                       % (keyName, valueName)
        members = [key, value]
    else:
        m = {'name': columnName,
             'type': constify(type.key.toCType(prefix, refTable) + pointer, const),
             'comment': type.cDeclComment()}

        if singleton:
            comment += " * '%s'" % columnName
        else:
            comment += " * the '%s' set" % columnName
        members = [m]

    if not singleton and not type.is_optional_pointer():
        sizeName = "n_%s" % columnName

        comment += " with '%s' entries" % sizeName
        members.append({'name': sizeName,
                        'type': 'size_t ',
                        'comment': ''})

    comment += ".\n"

    if type.is_optional() and not type.is_optional_pointer():
        comment += """ *
 * '%s' may be 0 or 1; if it is 0, then '%s'
 * may be NULL.\n""" \
        % ("n_%s" % columnName, columnName)

    if type.is_optional_pointer():
        comment += """ *
 * If "%s" is null, the column will be the empty set,
 * otherwise it will contain the specified value.\n""" % columnName

    if type.constraintsToEnglish():
        comment += """ *
 * Argument constraints: %s\n""" \
        % type.constraintsToEnglish(lambda s : '"%s"' % s)

    comment += " *\n * The caller retains ownership of the arguments. */"

    return (comment, members)

# This is equivalent to sorted(table.columns.items()), except that the
# sorting includes a topological component: if column B has a
# dependency on column A, then A will be sorted before B.
def sorted_columns(table):
    input = []
    for name, column in table.columns.items():
        dependencies = column.extensions.get('dependencies', [])
        for d in dependencies:
            if d not in table.columns:
                sys.stderr.write("Table %s column %s depends on column %s "
                                 "but there is no such column\n"
                                 % (table.name, name, d))
                sys.exit(1)
        input += [(name, column, set(dependencies))]

    output = []
    satisfied_dependencies = set()
    while input:
        done = []
        next = []
        for name, column, dependencies in input:
            if dependencies <= satisfied_dependencies:
                done += [(name, column)]
            else:
                next += [(name, column, dependencies)]

        if not done:
            sys.stderr.write("Table %s columns have circular dependencies\n"
                             % table.name)
            sys.exit(1)

        for name, column in done:
            satisfied_dependencies.add(name)
        output += sorted(done)
        input = next
    return output

# If a column name in the schema is a C or C++ keyword, append an underscore
# to the column name.
def replace_cplusplus_keyword(schema):
    keywords = {'alignas', 'alignof', 'and', 'and_eq', 'asm', 'auto', 'bitand',
                'bitor', 'bool', 'break', 'case', 'catch', 'char', 'char16_t',
                'char32_t', 'class', 'compl', 'concept', 'const', 'const_cast',
                'constexpr', 'continue', 'decltype', 'default', 'delete', 'do',
                'double', 'dynamic_cast', 'else', 'enum', 'explicit', 'export',
                'extern', 'false', 'float', 'for', 'friend', 'goto', 'if',
                'inline', 'int', 'long', 'mutable', 'namespace', 'new',
                'noexcept', 'not', 'not_eq', 'nullptr', 'operator', 'or',
                'or_eq', 'private', 'protected', 'public', 'register',
                'reinterpret_cast', 'requires', 'restrict', 'return', 'short',
                'signed', 'sizeof', 'static', 'static_assert', 'static_cast',
                'struct', 'switch', 'template', 'this', 'thread_local',
                'throw', 'true', 'try', 'typedef', 'typeid', 'typename',
                'union', 'unsigned', 'using', 'virtual', 'void', 'volatile',
                'wchar_t', 'while', 'xor', 'xor_eq'}

    for tableName, table in schema.tables.items():
        for columnName in list(table.columns):
            if columnName in keywords:
                table.columns[columnName + '_'] = table.columns.pop(columnName)

def printCIDLHeader(schemaFile):
    schema = parseSchema(schemaFile)
    replace_cplusplus_keyword(schema)
    prefix = schema.idlPrefix
    print('''\
/* Generated automatically -- do not modify!    -*- buffer-read-only: t -*- */

#ifndef %(prefix)sIDL_HEADER
#define %(prefix)sIDL_HEADER 1

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "openvswitch/json.h"
#include "ovsdb-data.h"
#include "ovsdb-idl-provider.h"
#include "smap.h"
#include "uuid.h"

#ifdef  __cplusplus
extern "C" {
#endif
%(hDecls)s''' % {'prefix': prefix.upper(),
                'hDecls': schema.hDecls})

    print("struct ovsdb_type;")
    print("")

    for tableName, table in sorted(schema.tables.items()):
        structName = "%s%s" % (prefix, tableName.lower())

        print("")
        print("/* %s table. */" % tableName)
        print("struct %s {" % structName)
        print("\tstruct ovsdb_idl_row header_;")
        for columnName, column in sorted_columns(table):
            print("\n\t/* %s column. */" % columnName)
            if column.extensions.get("members"):
                print("\t%s" % column.extensions["members"])
                continue
            comment, members = cMembers(prefix, tableName,
                                        columnName, column, False)
            for member in members:
                print("\t%(type)s%(name)s;%(comment)s" % member)
        print("};")

        # Column indexes.
        printEnum("%s_column_id" % structName.lower(), ["%s_COL_%s" % (structName.upper(), columnName.upper())
                                                        for columnName, column in sorted_columns(table)]
                  + ["%s_N_COLUMNS" % structName.upper()])

        print("")
        for columnName in table.columns:
            print("#define %(s)s_col_%(c)s (%(s)s_columns[%(S)s_COL_%(C)s])" % {
                's': structName,
                'S': structName.upper(),
                'c': columnName,
                'C': columnName.upper()})

        print("\nextern struct ovsdb_idl_column %s_columns[%s_N_COLUMNS];" % (structName, structName.upper()))

        for columnName in table.columns:
            print("bool %(p)sserver_has_%(t)s_table_col_%(c)s(const struct ovsdb_idl *); " % {
                'p': prefix, 't': tableName.lower(),
                'c': columnName})
            print("const struct ovsdb_type *%(p)s%(t)s_%(c)s_server_type(const struct ovsdb_idl *); " % {
                'p': prefix, 't': tableName.lower(),
                'c': columnName})

        print('''
bool %(p)sserver_has_%(t)s_table(const struct ovsdb_idl *);
const struct %(s)s_table *%(s)s_table_get(const struct ovsdb_idl *);
const struct %(s)s *%(s)s_table_first(const struct %(s)s_table *);

#define %(S)s_TABLE_FOR_EACH(ROW, TABLE) \\
        for ((ROW) = %(s)s_table_first(TABLE); \\
             (ROW); \\
             (ROW) = %(s)s_next(ROW))
#define %(S)s_TABLE_FOR_EACH_SAFE_LONG(ROW, NEXT, TABLE) \\
        for ((ROW) = %(s)s_table_first(TABLE); \\
             (ROW) ? ((NEXT) = %(s)s_next(ROW), 1) : 0; \\
             (ROW) = (NEXT))
#define %(S)s_TABLE_FOR_EACH_SAFE_SHORT(ROW, TABLE) \\
        for (const struct %(s)s * ROW__next = ((ROW) = %(s)s_table_first(TABLE), NULL); \\
             (ROW) ? (ROW__next = %(s)s_next(ROW), 1) : (ROW__next = NULL, 0); \\
             (ROW) = ROW__next)
#define %(S)s_TABLE_FOR_EACH_SAFE(...)                                        \\
        OVERLOAD_SAFE_MACRO(%(S)s_TABLE_FOR_EACH_SAFE_LONG,                   \\
                            %(S)s_TABLE_FOR_EACH_SAFE_SHORT, 3, __VA_ARGS__)


const struct %(s)s *%(s)s_get_for_uuid(const struct ovsdb_idl *, const struct uuid *);
const struct %(s)s *%(s)s_table_get_for_uuid(const struct %(s)s_table *, const struct uuid *);
const struct %(s)s *%(s)s_first(const struct ovsdb_idl *);
const struct %(s)s *%(s)s_next(const struct %(s)s *);
#define %(S)s_FOR_EACH(ROW, IDL) \\
        for ((ROW) = %(s)s_first(IDL); \\
             (ROW); \\
             (ROW) = %(s)s_next(ROW))
#define %(S)s_FOR_EACH_SAFE_LONG(ROW, NEXT, IDL) \\
        for ((ROW) = %(s)s_first(IDL); \\
             (ROW) ? ((NEXT) = %(s)s_next(ROW), 1) : 0; \\
             (ROW) = (NEXT))
#define %(S)s_FOR_EACH_SAFE_SHORT(ROW, IDL) \\
        for (const struct %(s)s * ROW__next = ((ROW) = %(s)s_first(IDL), NULL); \\
             (ROW) ? (ROW__next = %(s)s_next(ROW), 1) : (ROW__next = NULL, 0); \\
             (ROW) = ROW__next)
#define %(S)s_FOR_EACH_SAFE(...)                                         \\
        OVERLOAD_SAFE_MACRO(%(S)s_FOR_EACH_SAFE_LONG,                    \\
                            %(S)s_FOR_EACH_SAFE_SHORT, 3, __VA_ARGS__)

unsigned int %(s)s_get_seqno(const struct ovsdb_idl *);
unsigned int %(s)s_row_get_seqno(const struct %(s)s *row, enum ovsdb_idl_change change);
const struct %(s)s *%(s)s_track_get_first(const struct ovsdb_idl *);
const struct %(s)s *%(s)s_track_get_next(const struct %(s)s *);
#define %(S)s_FOR_EACH_TRACKED(ROW, IDL) \\
        for ((ROW) = %(s)s_track_get_first(IDL); \\
             (ROW); \\
             (ROW) = %(s)s_track_get_next(ROW))

const struct %(s)s *%(s)s_table_track_get_first(const struct %(s)s_table *);
#define %(S)s_TABLE_FOR_EACH_TRACKED(ROW, TABLE) \\
        for ((ROW) = %(s)s_table_track_get_first(TABLE); \\
             (ROW); \\
             (ROW) = %(s)s_track_get_next(ROW))


/* Returns true if 'row' was inserted since the last change tracking reset.
 *
 * Note: This can only be used to test rows of tracked changes. This cannot be
 * used to test if an uncommitted row that has been added locally is new or it
 * may given unexpected results. */
static inline bool %(s)s_is_new(const struct %(s)s *row)
{
    return %(s)s_row_get_seqno(row, OVSDB_IDL_CHANGE_INSERT) > 0;
}

/* Returns true if 'row' was deleted since the last change tracking reset.
 *
 * Note: This can only be used to test rows of tracked changes. This cannot be
 * used to test if an uncommitted row that has been added locally has been
 * deleted or it may given unexpected results. */
static inline bool %(s)s_is_deleted(const struct %(s)s *row)
{
    return %(s)s_row_get_seqno(row, OVSDB_IDL_CHANGE_DELETE) > 0;
}

void %(s)s_index_destroy_row(const struct %(s)s *);

struct %(s)s *%(s)s_index_find(struct ovsdb_idl_index *, const struct %(s)s *);

int %(s)s_index_compare(
    struct ovsdb_idl_index *, 
    const struct %(s)s *, 
    const struct %(s)s *);
struct ovsdb_idl_cursor %(s)s_cursor_first(struct ovsdb_idl_index *);
struct ovsdb_idl_cursor %(s)s_cursor_first_eq(
    struct ovsdb_idl_index *, const struct %(s)s *);
struct ovsdb_idl_cursor %(s)s_cursor_first_ge(
    struct ovsdb_idl_index *, const struct %(s)s *);

struct %(s)s *%(s)s_cursor_data(struct ovsdb_idl_cursor *);

#define %(S)s_FOR_EACH_RANGE(ROW, FROM, TO, INDEX) \\
        for (struct ovsdb_idl_cursor cursor__ = %(s)s_cursor_first_ge(INDEX, FROM); \\
             (cursor__.position \\
              && ((ROW) = %(s)s_cursor_data(&cursor__), \\
                  !(TO) || %(s)s_index_compare(INDEX, ROW, TO) <= 0)); \\
             ovsdb_idl_cursor_next(&cursor__))
#define %(S)s_FOR_EACH_EQUAL(ROW, KEY, INDEX) \\
        for (struct ovsdb_idl_cursor cursor__ = %(s)s_cursor_first_eq(INDEX, KEY); \\
             (cursor__.position \\
              ? ((ROW) = %(s)s_cursor_data(&cursor__), \\
                 ovsdb_idl_cursor_next_eq(&cursor__), \\
                 true) \\
              : false); \\
            )
#define %(S)s_FOR_EACH_BYINDEX(ROW, INDEX) \\
        for (struct ovsdb_idl_cursor cursor__ = %(s)s_cursor_first(INDEX); \\
             (cursor__.position \\
              ? ((ROW) = %(s)s_cursor_data(&cursor__), \\
                 ovsdb_idl_cursor_next(&cursor__), \\
                 true) \\
              : false); \\
            )

void %(s)s_init(struct %(s)s *);
void %(s)s_delete(const struct %(s)s *);
struct %(s)s *%(s)s_insert(struct ovsdb_idl_txn *);
struct %(s)s *%(s)s_insert_persist_uuid(
    struct ovsdb_idl_txn *txn, const struct uuid *uuid);

/* Returns true if the tracked column referenced by 'enum %(s)s_column_id' of
 * the row referenced by 'struct %(s)s *' was updated since the last change
 * tracking reset.
 *
 * Note: This can only be used to test rows of tracked changes. This cannot be
 * used to test if an uncommitted row that has been added locally has been
 * updated or it may given unexpected results. */
bool %(s)s_is_updated(const struct %(s)s *, enum %(s)s_column_id);
''' % {'s': structName, 'S': structName.upper(), 't': tableName.lower(), 'p': prefix})

        for columnName, column in sorted_columns(table):
            if column.extensions.get('synthetic'):
                continue
            print('void %(s)s_verify_%(c)s(const struct %(s)s *);' % {'s': structName, 'c': columnName})

        print("")
        for columnName, column in sorted_columns(table):
            if column.extensions.get('synthetic'):
                continue
            if column.type.value:
                valueParam = ', enum ovsdb_atomic_type value_type'
            else:
                valueParam = ''
            print('const struct ovsdb_datum *%(s)s_get_%(c)s(const struct %(s)s *, enum ovsdb_atomic_type key_type%(v)s);' % {
                's': structName, 'c': columnName, 'v': valueParam})

        print("")
        for columnName, column in sorted_columns(table):
            if column.extensions.get('synthetic'):
                continue
            print('void %(s)s_set_%(c)s(const struct %(s)s *,' % {'s': structName, 'c': columnName}, end=' ')
            if column.type.is_smap():
                args = ['const struct smap *']
            else:
                comment, members = cMembers(prefix, tableName, columnName,
                                            column, True)
                args = ['%(type)s%(name)s' % member for member in members]
            print('%s);' % ', '.join(args))

        print("")
        for columnName, column in sorted_columns(table):
            if column.extensions.get('synthetic'):
                continue
            if column.type.is_map():
                print('void %(s)s_update_%(c)s_setkey(const struct %(s)s *, ' % {'s': structName, 'c': columnName}, end=' ')
                print('%(coltype)s, %(valtype)s);' % {'coltype':column.type.key.to_const_c_type(prefix), 'valtype':column.type.value.to_const_c_type(prefix)})
                print('void %(s)s_update_%(c)s_delkey(const struct %(s)s *, ' % {'s': structName, 'c': columnName}, end=' ')
                print('%(coltype)s);' % {'coltype':column.type.key.to_const_c_type(prefix)})
            if column.type.is_set():
                print('void %(s)s_update_%(c)s_addvalue(const struct %(s)s *, ' % {'s': structName, 'c': columnName}, end=' ')
                print('%(valtype)s);' % {'valtype':column.type.key.to_const_c_type(prefix)})
                print('void %(s)s_update_%(c)s_delvalue(const struct %(s)s *, ' % {'s': structName, 'c': columnName}, end=' ')
                print('%(valtype)s);' % {'valtype':column.type.key.to_const_c_type(prefix)})

            print('void %(s)s_add_clause_%(c)s(struct ovsdb_idl_condition *, enum ovsdb_function function,' % {'s': structName, 'c': columnName}, end=' ')
            if column.type.is_smap():
                args = ['const struct smap *']
            else:
                comment, members = cMembers(prefix, tableName, columnName,
                                            column, True, refTable=False)
                args = ['%(type)s%(name)s' % member for member in members]
            print('%s);' % ', '.join(args))

            print('unsigned int %(s)s_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);' % {'s': structName})

        print("")

    # Table indexes.
        print("struct %(s)s *%(s)s_index_init_row(struct ovsdb_idl_index *);" % {'s': structName})
        print
        for columnName, column in sorted(table.columns.items()):
            print('void %(s)s_index_set_%(c)s(const struct %(s)s *,' % {'s': structName, 'c': columnName})
            if column.type.is_smap():
                args = ['const struct smap *']
            else:
                comment, members = cMembers(prefix, tableName, columnName,
                                            column, True)
                args = ['%(type)s%(name)s' % member for member in members]
            print('%s);' % ', '.join(args))

        print
    printEnum("%stable_id" % prefix.lower(), ["%sTABLE_%s" % (prefix.upper(), tableName.upper()) for tableName in sorted(schema.tables)] + ["%sN_TABLES" % prefix.upper()])
    print("")
    for tableName in schema.tables:
        print("#define %(p)stable_%(t)s (%(p)stable_classes[%(P)sTABLE_%(T)s])" % {
            'p': prefix,
            'P': prefix.upper(),
            't': tableName.lower(),
            'T': tableName.upper()})
    print("\nextern struct ovsdb_idl_table_class %stable_classes[%sN_TABLES];" % (prefix, prefix.upper()))

    print("\nextern struct ovsdb_idl_class %sidl_class;" % prefix)

    print("\nconst char * %sget_db_version(void);" % prefix)
    print('''
#ifdef  __cplusplus
}
#endif''')
    print("\n#endif /* %(prefix)sIDL_HEADER */" % {'prefix': prefix.upper()})


def printEnum(type, members):
    if len(members) == 0:
        return

    print("\nenum %s {" % type)
    for member in members[:-1]:
        print("    %s," % member)
    print("    %s" % members[-1])
    print("};")

def printCIDLSource(schemaFile):
    schema = parseSchema(schemaFile)
    replace_cplusplus_keyword(schema)
    prefix = schema.idlPrefix
    print('''\
/* Generated automatically -- do not modify!    -*- buffer-read-only: t -*- */

#include <config.h>
#include %(header)s
#include <limits.h>
#include "ovs-thread.h"
#include "ovsdb-data.h"
#include "ovsdb-error.h"
#include "util.h"

%(cDecls)s

''' % {'header': schema.idlHeader,
       'cDecls': schema.cDecls})

    # Cast functions.
    for tableName, table in sorted(schema.tables.items()):
        structName = "%s%s" % (prefix, tableName.lower())
        print('''
static struct %(s)s *
%(s)s_cast(const struct ovsdb_idl_row *row)
{
    return row ? CONTAINER_OF(row, struct %(s)s, header_) : NULL;
}\
''' % {'s': structName})


    for tableName, table in sorted(schema.tables.items()):
        structName = "%s%s" % (prefix, tableName.lower())
        print("")
        print("/* %s table. */" % (tableName))

        for columnName in table.columns:
            print('''
bool
%(p)sserver_has_%(t)s_table_col_%(c)s(const struct ovsdb_idl *idl)
{
    return ovsdb_idl_server_has_column(idl, &%(s)s_col_%(c)s);
}

const struct ovsdb_type *
%(p)s%(t)s_%(c)s_server_type(const struct ovsdb_idl *idl)
{
    return ovsdb_idl_server_column_type(idl, &%(s)s_col_%(c)s);
}
''' % {'s': structName, 'p': prefix, 't': tableName.lower(),
       'P': prefix.upper(), 'T': tableName.upper(),
       'c': columnName})

        print('''
bool
%(p)sserver_has_%(t)s_table(const struct ovsdb_idl *idl)
{
    return ovsdb_idl_server_has_table(idl, &%(p)stable_classes[%(P)sTABLE_%(T)s]);
}
''' % {'s': structName, 'p': prefix, 't': tableName.lower(),
       'P': prefix.upper(), 'T': tableName.upper()})

        print('''
const struct %(s)s_table *
%(s)s_table_get(const struct ovsdb_idl *idl)
{
    return (const struct %(s)s_table *) idl;
}

const struct %(s)s *
%(s)s_table_first(const struct %(s)s_table *table)
{
    const struct ovsdb_idl *idl = (const struct ovsdb_idl *) table;
    return %(s)s_first(idl);
}


const struct %(s)s *
%(s)s_table_track_get_first(const struct %(s)s_table *table)
{
    const struct ovsdb_idl *idl =  (const struct ovsdb_idl *) table;
    return %(s)s_track_get_first(idl);
}
''' % {'s': structName})

        # Parse functions.
        for columnName, column in sorted_columns(table):
            if 'parse' in column.extensions:
                print('''
static void
%(s)s_parse_%(c)s(struct ovsdb_idl_row *row_, const struct ovsdb_datum *datum OVS_UNUSED)
{
    struct %(s)s *row = %(s)s_cast(row_);\
''' % {'s': structName, 'c': columnName})
                print(column.extensions["parse"])
                print("}")
                continue
            if column.extensions.get('synthetic'):
                # Synthetic columns aren't parsed from a datum.
                unused = " OVS_UNUSED"
            else:
                unused = ""
            print('''
static void
%(s)s_parse_%(c)s(struct ovsdb_idl_row *row_, const struct ovsdb_datum *datum)
{
    struct %(s)s *row = %(s)s_cast(row_);''' % {'s': structName,
                                                'c': columnName})
            type = column.type
            if 'parse' in column.extensions:
                print(column.extensions["parse"])
                print("}")
                continue
            if type.value:
                keyVar = "row->key_%s" % columnName
                valueVar = "row->value_%s" % columnName
            else:
                keyVar = "row->%s" % columnName
                valueVar = None

            if type.is_smap():
                print("    smap_init(&row->%s);" % columnName)
                print("    for (size_t i = 0; i < datum->n; i++) {")
                print("        smap_add(&row->%s," % columnName)
                print("                 json_string(datum->keys[i].s),")
                print("                 json_string(datum->values[i].s));")
                print("    }")
            elif (type.n_min == 1 and type.n_max == 1) or type.is_optional_pointer():
                print("")
                print("    if (datum->n >= 1) {")
                if type.key.type == ovs.db.types.StringType:
                    print("        %s = CONST_CAST(char *, json_string(datum->keys[0].s));" % keyVar)
                elif not type.key.ref_table:
                    print("        %s = datum->keys[0].%s;" % (keyVar, type.key.type.to_rvalue_string()))
                else:
                    print("        %s = %s%s_cast(ovsdb_idl_get_row_arc(row_, &%stable_%s, &datum->keys[0].uuid));" % (keyVar, prefix, type.key.ref_table.name.lower(), prefix, type.key.ref_table.name.lower()))

                if valueVar:
                    if type.value.type == ovs.db.types.StringType:
                        print("        %s = CONST_CAST(char *, json_string(datum->values[0].s));" % valueVar)
                    elif not type.value.ref_table:
                        print("        %s = datum->values[0].%s;" % (valueVar, type.value.type.to_rvalue_string()))
                    else:
                        print("        %s = %s%s_cast(ovsdb_idl_get_row_arc(row_, &%stable_%s, &datum->values[0].uuid));" % (valueVar, prefix, type.value.ref_table.name.lower(), prefix, type.value.ref_table.name.lower()))
                print("    } else {")
                print("        %s" % type.key.initCDefault(keyVar, type.n_min == 0))
                if valueVar:
                    print("        %s" % type.value.initCDefault(valueVar, type.n_min == 0))
                print("    }")
            else:
                if type.n_max != sys.maxsize:
                    print("    size_t n = MIN(%d, datum->n);" % type.n_max)
                    nMax = "n"
                else:
                    nMax = "datum->n"
                print("    %s = NULL;" % keyVar)
                if valueVar:
                    print("    %s = NULL;" % valueVar)
                print("    row->n_%s = 0;" % columnName)
                print("    for (size_t i = 0; i < %s; i++) {" % nMax)
                if type.key.ref_table:
                    print("""\
        struct %s%s *keyRow = %s%s_cast(ovsdb_idl_get_row_arc(row_, &%stable_%s, &datum->keys[i].uuid));
        if (!keyRow) {
            continue;
        }\
""" % (prefix, type.key.ref_table.name.lower(), prefix, type.key.ref_table.name.lower(), prefix, type.key.ref_table.name.lower()))
                    keySrc = "keyRow"
                elif type.key.type == ovs.db.types.StringType:
                    keySrc = "CONST_CAST(char *, json_string(datum->keys[i].s))"
                else:
                    keySrc = "datum->keys[i].%s" % type.key.type.to_rvalue_string()
                if type.value and type.value.ref_table:
                    print("""\
        struct %s%s *valueRow = %s%s_cast(ovsdb_idl_get_row_arc(row_, &%stable_%s, &datum->values[i].uuid));
        if (!valueRow) {
            continue;
        }\
""" % (prefix, type.value.ref_table.name.lower(), prefix, type.value.ref_table.name.lower(), prefix, type.value.ref_table.name.lower()))
                    valueSrc = "valueRow"
                elif valueVar and type.value.type == ovs.db.types.StringType:
                    valueSrc = "CONST_CAST(char *, json_string(datum->values[i].s))"
                elif valueVar:
                    valueSrc = "datum->values[i].%s" % type.value.type.to_rvalue_string()
                print("        if (!row->n_%s) {" % (columnName))

                print("            %s = xmalloc(%s * sizeof *%s);" % (
                    keyVar, nMax, keyVar))
                if valueVar:
                    print("            %s = xmalloc(%s * sizeof *%s);" % (
                        valueVar, nMax, valueVar))
                print("        }")
                print("        %s[row->n_%s] = %s;" % (keyVar, columnName, keySrc))
                if valueVar:
                    print("        %s[row->n_%s] = %s;" % (valueVar, columnName, valueSrc))
                print("        row->n_%s++;" % columnName)
                print("    }")
            print("}")

        # Unparse functions.
        for columnName, column in sorted_columns(table):
            type = column.type
            if (type.is_smap() or (type.n_min != 1 or type.n_max != 1) and not type.is_optional_pointer()) or 'unparse' in column.extensions:
                print('''
static void
%(s)s_unparse_%(c)s(struct ovsdb_idl_row *row_)
{
    struct %(s)s *row = %(s)s_cast(row_);''' % {'s': structName,
                                                'c': columnName})
                if 'unparse' in column.extensions:
                    print(column.extensions["unparse"])
                elif type.is_smap():
                    print("    smap_destroy(&row->%s);" % columnName)
                else:
                    if type.value:
                        keyVar = "row->key_%s" % columnName
                        valueVar = "row->value_%s" % columnName
                    else:
                        keyVar = "row->%s" % columnName
                        valueVar = None
                    print("    free(%s);" % keyVar)
                    if valueVar:
                        print("    free(%s);" % valueVar)
                print('}')
            else:
                print('''
static void
%(s)s_unparse_%(c)s(struct ovsdb_idl_row *row OVS_UNUSED)
{
    /* Nothing to do. */
}''' % {'s': structName, 'c': columnName})

        # Generic Row Initialization function.
        print("""
static void
%(s)s_init__(struct ovsdb_idl_row *row)
{
    %(s)s_init(%(s)s_cast(row));
}""" % {'s': structName})

        # Row Initialization function.
        print("""
/* Clears the contents of 'row' in table "%(t)s". */
void
%(s)s_init(struct %(s)s *row)
{
    memset(row, 0, sizeof *row); """ % {'s': structName, 't': tableName})
        for columnName, column in sorted_columns(table):
            if column.type.is_smap():
                print("    smap_init(&row->%s);" % columnName)
            elif (column.type.n_min == 1 and
                  column.type.n_max == 1 and
                  column.type.key.type == ovs.db.types.StringType and
                  not column.type.value):
                print("    row->%s = \"\";" % columnName)
        print("}")

        # First, next functions.
        print('''
/* Searches table "%(t)s" in 'idl' for a row with UUID 'uuid'.  Returns
 * a pointer to the row if there is one, otherwise a null pointer.  */
const struct %(s)s *
%(s)s_get_for_uuid(const struct ovsdb_idl *idl, const struct uuid *uuid)
{
    return %(s)s_cast(ovsdb_idl_get_row_for_uuid(idl, &%(p)stable_%(tl)s, uuid));
}

/* Searches table "%(t)s" for a row with UUID 'uuid'.  Returns
 * a pointer to the row if there is one, otherwise a null pointer.  */
const struct %(s)s *
%(s)s_table_get_for_uuid(const struct %(s)s_table *table, const struct uuid *uuid)
{
    const struct ovsdb_idl *idl = (const struct ovsdb_idl *) table;
    return %(s)s_get_for_uuid(idl, uuid);
}

/* Returns a row in table "%(t)s" in 'idl', or a null pointer if that
 * table is empty.
 *
 * Database tables are internally maintained as hash tables, so adding or
 * removing rows while traversing the same table can cause some rows to be
 * visited twice or not at apply. */
const struct %(s)s *
%(s)s_first(const struct ovsdb_idl *idl)
{
    return %(s)s_cast(ovsdb_idl_first_row(idl, &%(p)stable_%(tl)s));
}

/* Returns a row following 'row' within its table, or a null pointer if 'row'
 * is the last row in its table. */
const struct %(s)s *
%(s)s_next(const struct %(s)s *row)
{
    return %(s)s_cast(ovsdb_idl_next_row(&row->header_));
}

unsigned int %(s)s_get_seqno(const struct ovsdb_idl *idl)
{
    return ovsdb_idl_table_get_seqno(idl, &%(p)stable_%(tl)s);
}

unsigned int %(s)s_row_get_seqno(const struct %(s)s *row, enum ovsdb_idl_change change)
{
    return ovsdb_idl_row_get_seqno(&row->header_, change);
}

const struct %(s)s *
%(s)s_track_get_first(const struct ovsdb_idl *idl)
{
    return %(s)s_cast(ovsdb_idl_track_get_first(idl, &%(p)stable_%(tl)s));
}

const struct %(s)s
*%(s)s_track_get_next(const struct %(s)s *row)
{
    return %(s)s_cast(ovsdb_idl_track_get_next(&row->header_));
}''' % {'s': structName,
        'p': prefix,
        'P': prefix.upper(),
        't': tableName,
        'tl': tableName.lower(),
        'T': tableName.upper()})

        print('''

/* Deletes 'row' from table "%(t)s".  'row' may be freed, so it must not be
 * accessed afterward.
 *
 * The caller must have started a transaction with ovsdb_idl_txn_create(). */
void
%(s)s_delete(const struct %(s)s *row)
{
    ovsdb_idl_txn_delete(&row->header_);
}

/* Inserts and returns a new row in the table "%(t)s" in the database
 * with open transaction 'txn'.
 *
 * The new row is assigned a randomly generated provisional UUID.
 * ovsdb-server will assign a different UUID when 'txn' is committed,
 * but the IDL will replace any uses of the provisional UUID in the
 * data to be to be committed by the UUID assigned by ovsdb-server. */
struct %(s)s *
%(s)s_insert(struct ovsdb_idl_txn *txn)
{
    return %(s)s_cast(ovsdb_idl_txn_insert(txn, &%(p)stable_%(tl)s, NULL));
}

/* Inserts and returns a new row in the table "%(t)s" in the database
 * with open transaction 'txn'.
 *
 * The new row is assigned the UUID specified in the 'uuid' parameter
 * (which cannot be null).  ovsdb-server will try to assign the same
 * UUID when 'txn' is committed. */
struct %(s)s *
%(s)s_insert_persist_uuid(struct ovsdb_idl_txn *txn, const struct uuid *uuid)
{
    return %(s)s_cast(ovsdb_idl_txn_insert_persist_uuid(
        txn, &%(p)stable_%(tl)s, uuid));
}

bool
%(s)s_is_updated(const struct %(s)s *row, enum %(s)s_column_id column)
{
    return ovsdb_idl_track_is_updated(&row->header_, &%(s)s_columns[column]);
}''' % {'s': structName,
        'p': prefix,
        'P': prefix.upper(),
        't': tableName,
        'tl': tableName.lower(),
        'T': tableName.upper()})

        # Verify functions.
        for columnName, column in sorted_columns(table):
            if column.extensions.get('synthetic'):
                continue
            print('''
/* Causes the original contents of column "%(c)s" in 'row' to be
 * verified as a prerequisite to completing the transaction.  That is, if
 * "%(c)s" in 'row' changed (or if 'row' was deleted) between the
 * time that the IDL originally read its contents and the time that the
 * transaction aborts and ovsdb_idl_txn_commit() returns TXN_TRY_AGAIN.
 *
 * The intention is that, to ensure that no transaction commits based on dirty
 * reads, an application should call this function any time "%(c)s" is
 * read as part of a read-modify-write operation.
 *
 * In some cases this function reduces to a no-op, because the current value
 * of "%(c)s" is already known:
 *
 *   - If 'row' is a row created by the current transaction (returned by
 *     %(s)s_insert()).
 *
 *   - If "%(c)s" has already been modified (with
 *     %(s)s_set_%(c)s()) within the current transaction.
 *
 * Because of the latter property, always call this function *before*
 * %(s)s_set_%(c)s() for a given read-modify-write.
 *
 * The caller must have started a transaction with ovsdb_idl_txn_create(). */
void
%(s)s_verify_%(c)s(const struct %(s)s *row)
{
    ovsdb_idl_txn_verify(&row->header_, &%(s)s_col_%(c)s);
}''' % {'s': structName,
        'S': structName.upper(),
        'c': columnName,
        'C': columnName.upper()})

        # Get functions.
        for columnName, column in sorted_columns(table):
            if column.extensions.get('synthetic'):
                continue
            if column.type.value:
                valueParam = ',\n\tenum ovsdb_atomic_type value_type OVS_UNUSED'
                valueType = '\n    ovs_assert(value_type == %s);' % column.type.value.toAtomicType()
                valueComment = "\n * 'value_type' must be %s." % column.type.value.toAtomicType()
            else:
                valueParam = ''
                valueType = ''
                valueComment = ''
            print("""
/* Returns the "%(c)s" column's value from the "%(t)s" table in 'row'
 * as a struct ovsdb_datum.  This is useful occasionally: for example,
 * ovsdb_datum_find_key() is an easier and more efficient way to search
 * for a given key than implementing the same operation on the "cooked"
 * form in 'row'.
 *
 * 'key_type' must be %(kt)s.%(vc)s
 * (This helps to avoid silent bugs if someone changes %(c)s's
 * type without updating the caller.)
 *
 * The caller must not modify or free the returned value.
 *
 * Various kinds of changes can invalidate the returned value: modifying
 * 'column' within 'row', deleting 'row', or completing an ongoing transaction.
 * If the returned value is needed for a long time, it is best to make a copy
 * of it with ovsdb_datum_clone().
 *
 * This function is rarely useful, since it is easier to access the value
 * directly through the "%(c)s" member in %(s)s. */
const struct ovsdb_datum *
%(s)s_get_%(c)s(const struct %(s)s *row,
\tenum ovsdb_atomic_type key_type OVS_UNUSED%(v)s)
{
    ovs_assert(key_type == %(kt)s);%(vt)s
    return ovsdb_idl_read(&row->header_, &%(s)s_col_%(c)s);
}""" % {'t': tableName, 's': structName, 'c': columnName,
       'kt': column.type.key.toAtomicType(),
       'v': valueParam, 'vt': valueType, 'vc': valueComment})

        # Set functions.
        for columnName, column in sorted_columns(table):
            if column.extensions.get('synthetic'):
                continue
            type = column.type

            comment, members = cMembers(prefix, tableName, columnName,
                                        column, True)

            if type.is_smap():
                print(comment)
                print("""void
%(s)s_set_%(c)s(const struct %(s)s *row, const struct smap *%(c)s)
{
    struct ovsdb_datum datum;

    if (%(c)s) {
        ovsdb_datum_from_smap(&datum, %(c)s);
    } else {
        ovsdb_datum_init_empty(&datum);
    }
    ovsdb_idl_txn_write(&row->header_,
                        &%(s)s_col_%(c)s,
                        &datum);
}
""" % {'t': tableName,
       's': structName,
       'S': structName.upper(),
       'c': columnName,
       'C': columnName.upper()})
                continue

            keyVar = members[0]['name']
            nVar = None
            valueVar = None
            if type.value:
                valueVar = members[1]['name']
                if len(members) > 2:
                    nVar = members[2]['name']
            else:
                if len(members) > 1:
                    nVar = members[1]['name']

            print(comment)
            print("""\
void
%(s)s_set_%(c)s(const struct %(s)s *row, %(args)s)
{
    struct ovsdb_datum datum;""" % {'s': structName,
        'c': columnName,
        'args': ', '.join(['%(type)s%(name)s'
                           % m for m in members])})
            print()
            print("    datum.refcnt = NULL;")
            if type.n_min == 1 and type.n_max == 1:
                print()
                print("    union ovsdb_atom *key = xmalloc(sizeof *key);")
                if type.value:
                    print("    union ovsdb_atom *value = xmalloc(sizeof *value);")
                print("")
                print("    datum.n = 1;")
                print("    datum.keys = key;")
                print("    " + type.key.copyCValue("key->%s" % type.key.type.to_lvalue_string(), keyVar))
                if type.value:
                    print("    datum.values = value;")
                    print("    " + type.value.copyCValue("value->%s" % type.value.type.to_lvalue_string(), valueVar))
                else:
                    print("    datum.values = NULL;")
                txn_write_func = "ovsdb_idl_txn_write"
            elif type.is_optional_pointer():
                print("")
                print("    if (%s) {" % keyVar)
                print("        union ovsdb_atom *key = xmalloc(sizeof *key);")
                print("        datum.n = 1;")
                print("        datum.keys = key;")
                print("        " + type.key.copyCValue("key->%s" % type.key.type.to_lvalue_string(), keyVar))
                print("    } else {")
                print("        datum.n = 0;")
                print("        datum.keys = NULL;")
                print("    }")
                print("    datum.values = NULL;")
                txn_write_func = "ovsdb_idl_txn_write"
            elif type.n_max == 1:
                print("")
                print("    if (%s) {" % nVar)
                print("        union ovsdb_atom *key = xmalloc(sizeof *key);")
                print("        datum.n = 1;")
                print("        datum.keys = key;")
                print("        " + type.key.copyCValue("key->%s" % type.key.type.to_lvalue_string(), "*" + keyVar))
                print("    } else {")
                print("        datum.n = 0;")
                print("        datum.keys = NULL;")
                print("    }")
                print("    datum.values = NULL;")
                txn_write_func = "ovsdb_idl_txn_write"
            else:
                print("")
                print("    datum.n = %s;" % nVar)
                print("    datum.keys = %s ? xmalloc(%s * sizeof *datum.keys) : NULL;" % (nVar, nVar))
                if type.value:
                    print("    datum.values = xmalloc(%s * sizeof *datum.values);" % nVar)
                else:
                    print("    datum.values = NULL;")
                print("    for (size_t i = 0; i < %s; i++) {" % nVar)
                print("        " + type.key.copyCValue("datum.keys[i].%s" % type.key.type.to_lvalue_string(), "%s[i]" % keyVar))
                if type.value:
                    print("        " + type.value.copyCValue("datum.values[i].%s" % type.value.type.to_lvalue_string(), "%s[i]" % valueVar))
                print("    }")
                txn_write_func = "ovsdb_idl_txn_write"
            print("    %(f)s(&row->header_, &%(s)s_col_%(c)s, &datum);" \
                % {'f': txn_write_func,
                   's': structName,
                   'S': structName.upper(),
                   'c': columnName})
            print("}")
        # Update/Delete of partial map column functions
        for columnName, column in sorted_columns(table):
            if column.extensions.get('synthetic'):
                continue
            type = column.type
            if type.is_map():
                print('''
/* Sets an element of the "%(c)s" map column from the "%(t)s" table in 'row'
 * to 'new_value' given the key value 'new_key'.
 *
 */
void
%(s)s_update_%(c)s_setkey(const struct %(s)s *row, %(coltype)snew_key, %(valtype)snew_value)
{
    struct ovsdb_datum *datum;

    datum = xmalloc(sizeof *datum);
    datum->n = 1;
    datum->keys = xmalloc(datum->n * sizeof *datum->keys);
    datum->values = xmalloc(datum->n * sizeof *datum->values);
    datum->refcnt = NULL;
''' % {'s': structName, 'c': columnName,'coltype':column.type.key.to_const_c_type(prefix),
        'valtype':column.type.value.to_const_c_type(prefix), 'S': structName.upper(),
        'C': columnName.upper(), 't': tableName})
                print("    " + type.key.copyCValue("datum->keys[0].%s" % type.key.type.to_lvalue_string(), "new_key"))
                print("    " + type.value.copyCValue("datum->values[0].%s" % type.value.type.to_lvalue_string(), "new_value"))
                print('''
    ovsdb_idl_txn_write_partial_map(&row->header_,
                                    &%(s)s_col_%(c)s,
                                    datum);
}''' % {'s': structName, 'c': columnName,'coltype':column.type.key.toCType(prefix),
        'valtype':column.type.value.to_const_c_type(prefix), 'S': structName.upper()})
                print('''
/* Deletes an element of the "%(c)s" map column from the "%(t)s" table in 'row'
 * given the key value 'delete_key'.
 *
 */
void
%(s)s_update_%(c)s_delkey(const struct %(s)s *row, %(coltype)sdelete_key)
{
    struct ovsdb_datum *datum;

    datum = xmalloc(sizeof *datum);
    datum->n = 1;
    datum->keys = xmalloc(datum->n * sizeof *datum->keys);
    datum->values = NULL;
    datum->refcnt = NULL;
''' % {'s': structName, 'c': columnName,'coltype':column.type.key.to_const_c_type(prefix),
        'valtype':column.type.value.to_const_c_type(prefix), 'S': structName.upper(),
        'C': columnName.upper(), 't': tableName})
                print("    " + type.key.copyCValue("datum->keys[0].%s" % type.key.type.to_lvalue_string(), "delete_key"))
                print('''
    ovsdb_idl_txn_delete_partial_map(&row->header_,
                                    &%(s)s_col_%(c)s,
                                    datum);
}''' % {'s': structName, 'c': columnName,'coltype':column.type.key.toCType(prefix),
        'valtype':column.type.value.to_const_c_type(prefix), 'S': structName.upper()})
        # End Update/Delete of partial maps
        # Update/Delete of partial set column functions
            if type.is_set():
                print('''
/* Adds the value 'new_value' to the "%(c)s" set column from the "%(t)s" table
 * in 'row'.
 *
 */
void
%(s)s_update_%(c)s_addvalue(const struct %(s)s *row, %(valtype)snew_value)
{
    struct ovsdb_datum *datum;

    datum = xmalloc(sizeof *datum);
    datum->n = 1;
    datum->keys = xmalloc(datum->n * sizeof *datum->values);
    datum->values = NULL;
    datum->refcnt = NULL;
''' % {'s': structName, 'c': columnName,
        'valtype':column.type.key.to_const_c_type(prefix), 't': tableName})
                print("    " + type.key.copyCValue("datum->keys[0].%s" % type.key.type.to_lvalue_string(), "new_value"))
                print('''
    ovsdb_idl_txn_write_partial_set(&row->header_,
                                    &%(s)s_col_%(c)s,
                                    datum);
}''' % {'s': structName, 'c': columnName,'coltype':column.type.key.toCType(prefix),
        'valtype':column.type.key.to_const_c_type(prefix), 'S': structName.upper()})
                print('''
/* Deletes the value 'delete_value' from the "%(c)s" set column from the
 * "%(t)s" table in 'row'.
 *
 */
void
%(s)s_update_%(c)s_delvalue(const struct %(s)s *row, %(valtype)sdelete_value)
{
    struct ovsdb_datum *datum;

    datum = xmalloc(sizeof *datum);
    datum->n = 1;
    datum->keys = xmalloc(datum->n * sizeof *datum->values);
    datum->values = NULL;
    datum->refcnt = NULL;
''' % {'s': structName, 'c': columnName,'coltype':column.type.key.to_const_c_type(prefix),
        'valtype':column.type.key.to_const_c_type(prefix), 'S': structName.upper(),
        'C': columnName.upper(), 't': tableName})
                print("    " + type.key.copyCValue("datum->keys[0].%s" % type.key.type.to_lvalue_string(), "delete_value"))
                print('''
    ovsdb_idl_txn_delete_partial_set(&row->header_,
                                    &%(s)s_col_%(c)s,
                                    datum);
}''' % {'s': structName, 'c': columnName,'coltype':column.type.key.toCType(prefix),
        'valtype':column.type.key.to_const_c_type(prefix), 'S': structName.upper()})
        # End Update/Delete of partial set

        # Add clause functions.
        for columnName, column in sorted_columns(table):
            if column.extensions.get('synthetic'):
                continue
            type = column.type

            comment, members = cMembers(prefix, tableName, columnName,
                                        column, True, refTable=False)

            if type.is_smap():
                print(comment)
                print("""void
%(s)s_add_clause_%(c)s(struct ovsdb_idl_condition *cond, enum ovsdb_function function, const struct smap *%(c)s)
{
    struct ovsdb_datum datum;

    if (%(c)s) {
        ovsdb_datum_from_smap(&datum, %(c)s);
    } else {
        ovsdb_datum_init_empty(&datum);
    }

    ovsdb_idl_condition_add_clause(cond,
                                   function,
                                   &%(s)s_col_%(c)s,
                                   &datum);

    ovsdb_datum_destroy(&datum, &%(s)s_col_%(c)s.type);
}
""" % {'t': tableName,
       'tl': tableName.lower(),
       'T': tableName.upper(),
       'p': prefix,
       'P': prefix.upper(),
       's': structName,
       'S': structName.upper(),
       'c': columnName})
                continue

            keyVar = members[0]['name']
            nVar = None
            valueVar = None
            if type.value:
                valueVar = members[1]['name']
                if len(members) > 2:
                    nVar = members[2]['name']
            else:
                if len(members) > 1:
                    nVar = members[1]['name']

            print(comment)
            print('void')
            print('%(s)s_add_clause_%(c)s(struct ovsdb_idl_condition *cond, enum ovsdb_function function, %(args)s)' % \
                {'s': structName, 'c': columnName,
                 'args': ', '.join(['%(type)s%(name)s' % m for m in members])})
            print("{")
            print("    struct ovsdb_datum datum;")
            print("")
            print("    datum.refcnt = NULL;")
            free = []
            if type.n_min == 1 and type.n_max == 1:
                print()
                print("    union ovsdb_atom *key = xmalloc(sizeof *key);")
                if type.value:
                    print("    union ovsdb_atom *value = xmalloc(sizeof *value);")
                print("")
                print("    datum.n = 1;")
                print("    datum.keys = key;")
                print("    " + type.key.copyCValue("key->%s" % type.key.type.to_lvalue_string(), keyVar, refTable=False))
                if type.value:
                    print("    " + type.value.copyCValue("value.%s" % type.value.type.to_lvalue_string(), valueVar, refTable=False))
                else:
                    print("    datum.values = NULL;")
            elif type.is_optional_pointer():
                print("")
                print("    if (%s) {" % keyVar)
                print("        union ovsdb_atom *key = xmalloc(sizeof *key);")
                print("        datum.n = 1;")
                print("        datum.keys = key;")
                print("        " + type.key.copyCValue("key->%s" % type.key.type.to_lvalue_string(), keyVar, refTable=False))
                print("    } else {")
                print("        datum.n = 0;")
                print("        datum.keys = NULL;")
                print("    }")
                print("    datum.values = NULL;")
            elif type.n_max == 1:
                print("")
                print("    if (%s) {" % nVar)
                print("        union ovsdb_atom *key = xmalloc(sizeof *key);")
                print("        datum.n = 1;")
                print("        datum.keys = key;")
                print("        " + type.key.copyCValue("key->%s" % type.key.type.to_lvalue_string(), "*" + keyVar, refTable=False))
                print("    } else {")
                print("        datum.n = 0;")
                print("        datum.keys = NULL;")
                print("    }")
                print("    datum.values = NULL;")
            else:
                print("    datum.n = %s;" % nVar)
                print("    datum.keys = %s ? xmalloc(%s * sizeof *datum.keys) : NULL;" % (nVar, nVar))
                if type.value:
                    print("    datum.values = xmalloc(%s * sizeof *datum.values);" % nVar)
                else:
                    print("    datum.values = NULL;")
                print("    for (size_t i = 0; i < %s; i++) {" % nVar)
                print("        " + type.key.copyCValue("datum.keys[i].%s" % type.key.type.to_lvalue_string(), "%s[i]" % keyVar, refTable=False))
                if type.value:
                    print("        " + type.value.copyCValue("datum.values[i].%s" % type.value.type.to_lvalue_string(), "%s[i]" % valueVar, refTable=False))
                print("    }")
                print("    ovsdb_datum_sort_unique(&datum, &%(s)s_col_%(c)s.type);" \
                      % {'s': structName, 'c': columnName})

            print("""    ovsdb_idl_condition_add_clause(cond,
                          function,
                          &%(s)s_col_%(c)s,
                          &datum);\
""" % {'tl': tableName.lower(),
       'T': tableName.upper(),
       'p': prefix,
       'P': prefix.upper(),
       's': structName,
       'S': structName.upper(),
       'c': columnName})
            print("    ovsdb_datum_destroy(&datum, &%(s)s_col_%(c)s.type);" \
                  % {'s': structName, 'c': columnName})
            print("}")

# Index table related functions
        print("""
/* Destroy 'row' of kind "%(t)s". The row must have been
 * created with ovsdb_idl_index_init_row.
 */
void
%(s)s_index_destroy_row(const struct %(s)s *row)
{
    ovsdb_idl_index_destroy_row(&row->header_);
}
        """ % { 's' : structName, 't': tableName })
        print("""
/* Creates a new row of kind "%(t)s". */
struct %(s)s *
%(s)s_index_init_row(struct ovsdb_idl_index *index)
{
    ovs_assert(index->table->class_ == &%(p)stable_%(tl)s);
    return ALIGNED_CAST(struct %(s)s *, ovsdb_idl_index_init_row(index));
}

struct %(s)s *
%(s)s_index_find(struct ovsdb_idl_index *index, const struct %(s)s *target)
{
    ovs_assert(index->table->class_ == &%(p)stable_%(tl)s);
    return %(s)s_cast(ovsdb_idl_index_find(index, &target->header_));
}

/* Compares 'a' to 'b' and returns a strcmp()-type result. */
int
%(s)s_index_compare(
    struct ovsdb_idl_index *index, 
    const struct %(s)s *a, 
    const struct %(s)s *b)
{
    return ovsdb_idl_index_compare(index, &a->header_, &b->header_);
}

struct ovsdb_idl_cursor
%(s)s_cursor_first(struct ovsdb_idl_index *index)
{
    ovs_assert(index->table->class_ == &%(p)stable_%(tl)s);
    return ovsdb_idl_cursor_first(index);
}

struct ovsdb_idl_cursor
%(s)s_cursor_first_eq(
    struct ovsdb_idl_index *index, const struct %(s)s *target)
{
    ovs_assert(index->table->class_ == &%(p)stable_%(tl)s);
    return ovsdb_idl_cursor_first_eq(index, &target->header_);
}

struct ovsdb_idl_cursor
%(s)s_cursor_first_ge(
    struct ovsdb_idl_index *index, const struct %(s)s *target)
{
    ovs_assert(index->table->class_ == &%(p)stable_%(tl)s);
    return ovsdb_idl_cursor_first_ge(index, target ? &target->header_ : NULL);
}

struct %(s)s *
%(s)s_cursor_data(struct ovsdb_idl_cursor *cursor)
{
    return %(s)s_cast(ovsdb_idl_cursor_data(cursor));
}
""" % {'s': structName,
        'c': columnName,
        't': tableName,
        'tl': tableName.lower(),
        'p': prefix})
        # Indexes Set functions
        for columnName, column in sorted(table.columns.items()):
            type = column.type

            comment, members = cMembers(prefix, tableName, columnName,
                                        column, True)

            if type.is_smap():
                print(comment)
                print("""void
%(s)s_index_set_%(c)s(const struct %(s)s *row, const struct smap *%(c)s)
{
    struct ovsdb_datum *datum = xmalloc(sizeof(struct ovsdb_datum));

    if (%(c)s) {
        struct smap_node *node;
        size_t i;

        datum->n = smap_count(%(c)s);
        datum->keys = xmalloc(datum->n * sizeof *datum->keys);
        datum->values = xmalloc(datum->n * sizeof *datum->values);
        datum->refcnt = NULL;

        i = 0;
        SMAP_FOR_EACH (node, %(c)s) {
            datum->keys[i].s = ovsdb_atom_string_create(node->key);
            datum->values[i].s = ovsdb_atom_string_create(node->value);
            i++;
        }
        ovsdb_datum_sort_unique(datum, &%(s)s_col_%(c)s.type);
    } else {
        ovsdb_datum_init_empty(datum);
    }
    ovsdb_idl_index_write(CONST_CAST(struct ovsdb_idl_row *, &row->header_),
                          &%(s)s_columns[%(S)s_COL_%(C)s],
                          datum,
                          &%(p)stable_classes[%(P)sTABLE_%(T)s]);
    free(datum);
}
""" % {'t': tableName,
       'p': prefix,
       'P': prefix.upper(),
       's': structName,
       'S': structName.upper(),
       'c': columnName,
       'C': columnName.upper(),
       't': tableName,
       'T': tableName.upper()})
                continue

            keyVar = members[0]['name']
            nVar = None
            valueVar = None
            if type.value:
                valueVar = members[1]['name']
                if len(members) > 2:
                    nVar = members[2]['name']
            else:
                if len(members) > 1:
                    nVar = members[1]['name']

            print(comment)
            print('void')
            print('%(s)s_index_set_%(c)s(const struct %(s)s *row, %(args)s)' % \
                {'s': structName, 'c': columnName,
                 'args': ', '.join(['%(type)s%(name)s' % m for m in members])})
            print("{")
            print("    struct ovsdb_datum datum;")
            print()
            print("    datum.refcnt = NULL;")
            if type.n_min == 1 and type.n_max == 1:
                print("    union ovsdb_atom *key = xmalloc(sizeof(union ovsdb_atom));")
                if type.value:
                    print("    union ovsdb_atom *value = xmalloc(sizeof(union ovsdb_atom));")
                print()
                print("    datum.n = 1;")
                print("    datum.keys = key;")
                print("    " + type.key.copyCValue("key->%s" % type.key.type.to_lvalue_string(), keyVar))
                if type.value:
                    print("    datum.values = value;")
                    print("    " + type.value.copyCValue("value->%s" % type.value.type.to_lvalue_string(), valueVar))
                else:
                    print("    datum.values = NULL;")
                txn_write_func = "ovsdb_idl_index_write"
            elif type.is_optional_pointer():
                print("    union ovsdb_atom *key;")
                print()
                print("    if (%s) {" % keyVar)
                print("        key = xmalloc(sizeof (union ovsdb_atom));")
                print("        datum.n = 1;")
                print("        datum.keys = key;")
                print("        " + type.key.copyCValue("key->%s" % type.key.type.to_lvalue_string(), keyVar))
                print("    } else {")
                print("        datum.n = 0;")
                print("        datum.keys = NULL;")
                print("    }")
                print("    datum.values = NULL;")
                txn_write_func = "ovsdb_idl_index_write"
            elif type.n_max == 1:
                print("    union ovsdb_atom *key;")
                print()
                print("    if (%s) {" % nVar)
                print("        key = xmalloc(sizeof(union ovsdb_atom));")
                print("        datum.n = 1;")
                print("        datum.keys = key;")
                print("        " + type.key.copyCValue("key->%s" % type.key.type.to_lvalue_string(), "*" + keyVar))
                print("    } else {")
                print("        datum.n = 0;")
                print("        datum.keys = NULL;")
                print("    }")
                print("    datum.values = NULL;")
                txn_write_func = "ovsdb_idl_index_write"
            else:
                print("    size_t i;")
                print()
                print("    datum.n = %s;" % nVar)
                print("    datum.keys = %s ? xmalloc(%s * sizeof *datum.keys) : NULL;" % (nVar, nVar))
                if type.value:
                    print("    datum.values = xmalloc(%s * sizeof *datum.values);" % nVar)
                else:
                    print("    datum.values = NULL;")
                print("    for (i = 0; i < %s; i++) {" % nVar)
                print("        " + type.key.copyCValue("datum.keys[i].%s" % type.key.type.to_lvalue_string(), "%s[i]" % keyVar))
                if type.value:
                    print("        " + type.value.copyCValue("datum.values[i].%s" % type.value.type.to_lvalue_string(), "%s[i]" % valueVar))
                print("    }")
                print("    ovsdb_datum_sort_unique(&datum, &%(s)s_col_%(c)s.type);"
                      % {'s': structName, 'c': columnName})
                txn_write_func = "ovsdb_idl_index_write"
            print("    %(f)s(CONST_CAST(struct ovsdb_idl_row *, &row->header_), &%(s)s_columns[ %(S)s_COL_%(C)s ], &datum, &%(p)stable_classes[%(P)sTABLE_%(T)s]);" \
                % {'f': txn_write_func,
                   's': structName,
                   'S': structName.upper(),
                   'C': columnName.upper(),
                   'p': prefix,
                   'P': prefix.upper(),
                   't': tableName,
                   'T': tableName.upper()})
            print("}")
# End Index table related functions

        # Table columns.
        print("\nstruct ovsdb_idl_column %s_columns[%s_N_COLUMNS];" % (
            structName, structName.upper()))
        print("""
unsigned int
%(s)s_set_condition(struct ovsdb_idl *idl, struct ovsdb_idl_condition *condition)
{
    return ovsdb_idl_set_condition(idl, &%(p)stable_%(tl)s, condition);
}""" % {'p': prefix,
        's': structName,
        'tl': tableName.lower()})

        # Table columns.
        for columnName, column in sorted_columns(table):
            prereqs = []
            x = column.type.cInitType("%s_col_%s" % (tableName, columnName), prereqs)
            if prereqs:
                print('\n'.join(prereqs))
        print("\nstruct ovsdb_idl_column %s_columns[%s_N_COLUMNS] = {" % (
            structName, structName.upper()))
        for columnName, column in sorted_columns(table):
            if column.mutable:
                mutable = "true"
            else:
                mutable = "false"
            if column.extensions.get("synthetic"):
                synthetic = "true"
            else:
                synthetic = "false"
            type_init = '\n'.join("            " + x
                                  for x in column.type.cInitType("%s_col_%s" % (tableName, columnName), prereqs))
            print("""\
    [%(P)s%(T)s_COL_%(C)s] = {
         .name = "%(column_name_in_schema)s",
         .type = {
%(type)s
         },
         .is_mutable = %(mutable)s,
         .is_synthetic = %(synthetic)s,
         .parse = %(s)s_parse_%(c)s,
         .unparse = %(s)s_unparse_%(c)s,
    },\n""" % {'P': prefix.upper(),
               'T': tableName.upper(),
               'c': columnName,
               'C': columnName.upper(),
               's': structName,
               'mutable': mutable,
               'synthetic': synthetic,
               'type': type_init,
               'column_name_in_schema': column.name})
        print("};")

    # Table classes.
    print("")
    print("struct ovsdb_idl_table_class %stable_classes[%sN_TABLES] = {" % (prefix, prefix.upper()))
    for tableName, table in sorted(schema.tables.items()):
        structName = "%s%s" % (prefix, tableName.lower())
        if table.is_root:
            is_root = "true"
        else:
            is_root = "false"
        if table.max_rows == 1:
            is_singleton = "true"
        else:
            is_singleton = "false"
        print("    {\"%s\", %s, %s," % (tableName, is_root, is_singleton))
        print("     %s_columns, ARRAY_SIZE(%s_columns)," % (
              structName, structName))
        print("     sizeof(struct %s), %s_init__}," % (structName, structName))
    print("};")

    # IDL class.
    print("\nstruct ovsdb_idl_class %sidl_class = {" % prefix)
    print("    \"%s\", %stable_classes, ARRAY_SIZE(%stable_classes)" % (
        schema.name, prefix, prefix))
    print("};")

    print("""
/* Return the schema version.  The caller must not free the returned value. */
const char *
%sget_db_version(void)
{
    return "%s";
}
""" % (prefix, schema.version))



def ovsdb_escape(string):
    def escape(match):
        c = match.group(0)
        if c == '\0':
            raise ovs.db.error.Error("strings may not contain null bytes")
        elif c == '\\':
            return '\\\\'
        elif c == '\n':
            return '\\n'
        elif c == '\r':
            return '\\r'
        elif c == '\t':
            return '\\t'
        elif c == '\b':
            return '\\b'
        elif c == '\a':
            return '\\a'
        else:
            return '\\x%02x' % ord(c)
    return re.sub(r'["\\\000-\037]', escape, string)

def usage():
    print("""\
%(argv0)s: ovsdb schema compiler
usage: %(argv0)s [OPTIONS] COMMAND ARG...

The following commands are supported:
  annotate SCHEMA ANNOTATIONS print SCHEMA combined with ANNOTATIONS
  c-idl-header IDL            print C header file for IDL
  c-idl-source IDL            print C source file for IDL implementation

The following options are also available:
  -h, --help                  display this help message
  -V, --version               display version information\
""" % {'argv0': argv0})
    sys.exit(0)

if __name__ == "__main__":
    try:
        try:
            options, args = getopt.gnu_getopt(sys.argv[1:], 'C:hV',
                                              ['directory',
                                               'help',
                                               'version'])
        except getopt.GetoptError as geo:
            sys.stderr.write("%s: %s\n" % (argv0, geo.msg))
            sys.exit(1)

        for key, value in options:
            if key in ['-h', '--help']:
                usage()
            elif key in ['-V', '--version']:
                print("ovsdb-idlc (Open vSwitch) @VERSION@")
            elif key in ['-C', '--directory']:
                os.chdir(value)
            else:
                sys.exit(0)

        optKeys = [key for key, value in options]

        if not args:
            sys.stderr.write("%s: missing command argument "
                             "(use --help for help)\n" % argv0)
            sys.exit(1)

        commands = {"annotate": (annotateSchema, 2),
                    "c-idl-header": (printCIDLHeader, 1),
                    "c-idl-source": (printCIDLSource, 1)}

        if not args[0] in commands:
            sys.stderr.write("%s: unknown command \"%s\" "
                             "(use --help for help)\n" % (argv0, args[0]))
            sys.exit(1)

        func, n_args = commands[args[0]]
        if len(args) - 1 != n_args:
            sys.stderr.write("%s: \"%s\" requires %d arguments but %d "
                             "provided\n"
                             % (argv0, args[0], n_args, len(args) - 1))
            sys.exit(1)

        func(*args[1:])
    except ovs.db.error.Error as e:
        sys.stderr.write("%s: %s\n" % (argv0, e))
        sys.exit(1)

# Local variables:
# mode: python
# End:
