#!/usr/bin/python

# Copyright 2013, Big Switch Networks, Inc.

#

# LoxiGen is licensed under the Eclipse Public License, version 1.0 (EPL), with

# the following special exception:

#

# LOXI Exception

#

# As a special exception to the terms of the EPL, you may distribute libraries

# generated by LoxiGen (LoxiGen Libraries) under the terms of your choice, provided

# that copyright and licensing notices generated by LoxiGen are not altered or removed

# from the LoxiGen Libraries and the notice provided below is (i) included in

# the LoxiGen Libraries, if distributed in source code form and (ii) included in any

# documentation for the LoxiGen Libraries, if distributed in binary form.

#

# Notice: "Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler."

#

# You may not use this file except in compliance with the EPL or LOXI Exception. You may obtain

# a copy of the EPL at:

#

# http://www.eclipse.org/legal/epl-v10.html

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

# EPL for the specific language governing permissions and limitations

# under the EPL.

"""

@brief

Process openflow header files to create language specific LOXI interfaces

First cut at simple python script for processing input files

Internal notes

An input file for each supported OpenFlow version is passed in

on the command line.

Expected input file format:

These will probably be collapsed into a python dict or something

The first line has the ofC version identifier and nothing else

The second line has the openflow wire protocol value and nothing else

The main content is struct elements for each OF recognized class.

These are taken from current versions of openflow.h but are modified

a bit. See Overview for more information.

Class canonical form: A list of entries, each of which is a

pair "type, name;". The exception is when type is the keyword

'list' in which the syntax is "list(type) name;".

From this, internal representations are generated: For each

version, a dict indexed by class name. One element (members) is

an array giving the member name and type. From this, wire offsets

can be calculated.

@fixme Clean up the lang module architecture. It should provide a

list of files that it wants to generate and maps to the filenames,

subdirectory names and generation functions. It should also be

defined as a class, probably with the constructor taking the

language target.

@fixme Clean up global data structures such as versions and of_g

structures. They should probably be a class or classes as well.

"""

import sys

import re

import string

import os

import glob

import copy

import collections

import of_g

import loxi_front_end.type_maps as type_maps

import loxi_utils.loxi_utils as loxi_utils

import loxi_front_end.c_parse_utils as c_parse_utils

import loxi_front_end.identifiers as identifiers

import pyparsing

import loxi_front_end.parser as parser

import loxi_front_end.translation as translation

import loxi_front_end.frontend as frontend

from loxi_ir import *

from generic_utils import *

root_dir = os.path.dirname(os.path.realpath(__file__))

# TODO: Put these in a class so they get documented

## Dict indexed by version giving all info related to version

#

# This is local; after processing, the information is stored in

# of_g variables.

versions = {}

def config_sanity_check():

return rv

def add_class(wire_version, cls, members):

of_g.ordered_members[cls].append(m_name)

def update_offset(cls, wire_version, name, offset, m_type):

return offset + (count * bytes), len_update

def calculate_offsets_and_lengths(ordered_classes, classes, wire_version):

of_g.base_length[(list_type, wire_version)] = 0

def process_input_file(filename):

return ofinput

def order_and_assign_object_ids():

of_g.object_id += 1

def initialize_versions():

of_g.ordered_classes[wire_version] = []

def read_input():

of_g.ir[wire_version] = ofprotocol

def populate_type_maps():

type_maps.generate_maps()

def analyze_input():

wire_version)

def unify_input():

add_class(wire_version, cls, classes[cls])

def log_all_class_info():

member["offset"]))

def generate_all_files():

print("Wrote contents for " + name)

if __name__ == '__main__':

of_g.loxigen_log_file = open("loxigen.log", "w")

of_g.loxigen_dbg_file = sys.stdout

of_g.process_commandline()

# @fixme Use command line params to select log

if not config_sanity_check():

debug("Config sanity check failed\n")

sys.exit(1)

# Import the language file

lang_file = "lang_%s" % of_g.options.lang

lang_module = __import__(lang_file)

# If list files, just list auto-gen files to stdout and exit

if of_g.options.list_files:

for name in lang_module.targets:

print of_g.options.install_dir + '/' + name

sys.exit(0)

log("\nGenerating files for target language %s\n" % of_g.options.lang)

initialize_versions()

read_input()

populate_type_maps()

analyze_input()

unify_input()

order_and_assign_object_ids()

log_all_class_info()

generate_all_files()