#!/usr/bin/env python

#

# Copyright (c)  2012 Yannick Brosseau <yannick.brosseau@gmail.com>

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; only version 2

# of the License.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License along

# with this program; if not, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

from __future__ import print_function

import sys

import getopt

import re

import os

import subprocess

class Usage(Exception):

    def __init__(self, msg):

        self.msg = msg

class HeaderFile:

    HEADER_TPL="""

#undef TRACEPOINT_PROVIDER

#define TRACEPOINT_PROVIDER {providerName}

#undef TRACEPOINT_INCLUDE

#define TRACEPOINT_INCLUDE "./{headerFilename}"

#if !defined({includeGuard}) || defined(TRACEPOINT_HEADER_MULTI_READ)

#define {includeGuard}

#include <lttng/tracepoint.h>

"""

    FOOTER_TPL="""

#endif /* {includeGuard} */

#include <lttng/tracepoint-event.h>

"""

    def __init__(self, filename, template):

        self.outputFilename = filename

        self.template = template

    def write(self):

        outputFile = open(self.outputFilename,"w")

        # Include guard macro will be created by uppercasing the filename and

        # replacing all non alphanumeric characters with '_'

        includeGuard = re.sub('[^0-9a-zA-Z]', '_', self.outputFilename.upper())

        outputFile.write(HeaderFile.HEADER_TPL.format(providerName=self.template.domain,

                                           includeGuard = includeGuard,

                                           headerFilename = self.outputFilename))

        outputFile.write(self.template.text)

        outputFile.write(HeaderFile.FOOTER_TPL.format(includeGuard = includeGuard))

        outputFile.close()

class CFile:

    FILE_TPL="""

#define TRACEPOINT_CREATE_PROBES

/*

 * The header containing our TRACEPOINT_EVENTs.

 */

#define TRACEPOINT_DEFINE

#include "{headerFilename}"

"""

    def __init__(self, filename, template):

        self.outputFilename = filename

        self.template = template

    def write(self):

        outputFile = open(self.outputFilename,"w")

        headerFilename = self.outputFilename.replace(".c",".h")

        outputFile.write(CFile.FILE_TPL.format(

                                           headerFilename = headerFilename))

        outputFile.close()

class ObjFile:

    def __init__(self, filename, template):

        self.outputFilename = filename

        self.template = template

    def _detectCC(self):

        cc = ""

        if 'CC' in os.environ:

            cc = os.environ['CC']

            try:

                subprocess.call(cc.split(),

                                stdout=subprocess.PIPE,

                                stderr=subprocess.PIPE)

            except OSError as msg:

                print("Invalid CC environment variable")

                cc = ""

        else:

            # Try c first, if that fails try gcc

            try:

                useCC = True

                subprocess.call("cc",

                                stdout=subprocess.PIPE,

                                stderr=subprocess.PIPE)

            except OSError as msg:

                useCC = False

            if useCC:

                cc = "cc"

            else:

                try:

                    useGCC = True

                    subprocess.call("gcc",

                                    stdout=subprocess.PIPE,

                                    stderr=subprocess.PIPE)

                except OSError as msg:

                    useGCC = False

                if useGCC:

                    cc = "gcc"

        return cc

    def write(self):

        cFilename = self.outputFilename.replace(".o",".c")

        cc = self._detectCC()

        if cc == "":

            raise RuntimeError("No C Compiler detected")

        if 'CPPFLAGS' in os.environ:

            cppflags = " " + os.environ['CPPFLAGS']

        else:

            cppflags = ""

        if 'CFLAGS' in os.environ:

            cflags = " " + os.environ['CFLAGS']

        else:

            cflags = ""

        if 'LDFLAGS' in os.environ:

            ldflags = " " + os.environ['LDFLAGS']

        else:

            ldflags = ""

        command = cc + " -c" + cppflags + cflags + ldflags + " -I. -llttng-ust" + " -o " + self.outputFilename + " " + cFilename

        if verbose:

            print("Compile command: " + command)

        subprocess.call(command.split())

class TemplateFile:

    def __init__(self, filename):

        self.domain = ""

        self.inputFilename = filename

        self.parseTemplate()

    def parseTemplate(self):

        f = open(self.inputFilename,"r")

        self.text = f.read()

        #Remove # comments (from input and output file) but keep 

        # #include in the output file

        removeComments = re.compile("#[^include].*$",flags=re.MULTILINE)

        self.text = removeComments.sub("",self.text)

        # Remove #include directive from the parsed text

        removePreprocess = re.compile("#.*$",flags=re.MULTILINE)

        noPreprocess = removePreprocess.sub("", self.text)

        #Remove // comments

        removeLineComment = re.compile("\/\/.*$",flags=re.MULTILINE)

        nolinecomment = removeLineComment.sub("", noPreprocess)

        #Remove all spaces and lines

        cleantext = re.sub("\s*","",nolinecomment)

        #Remove multine C style comments

        nocomment = re.sub("/\*.*?\*/","",cleantext)

        entries = re.split("TRACEPOINT_.*?",nocomment)

        for entry in entries:

            if entry != '':

                decomp = re.findall("(\w*?)\((\w*?),(\w*?),", entry)

                typea = decomp[0][0]

                domain = decomp[0][1]

                name = decomp[0][2]

                if self.domain == "":

                    self.domain = domain

                else:

                    if self.domain != domain:

                        print("Warning: different domain provided (%s,%s)" % (self.domain, domain))

verbose=False

usage="""

 lttng-gen-tp - Generate the LTTng-UST header and source based on a simple template

 usage: lttng-gen-tp TEMPLATE_FILE [-o OUTPUT_FILE][-o OUTPUT_FILE]

 If no OUTPUT_FILE is given, the .h and .c file will be generated.

 (The basename of the template file with be used for the generated file.

  for example sample.tp will generate sample.h, sample.c and sample.o)

 When using the -o option, the OUTPUT_FILE must end with either .h, .c or .o

 The -o option can be repeated multiple times.

 The template file must contains TRACEPOINT_EVENT and TRACEPOINT_LOGLEVEL

 as per defined in the lttng/tracepoint.h file.

 See the lttng-ust(3) man page for more details on the format.

"""

def main(argv=None):

    if argv is None:

        argv = sys.argv

    try:

        try:

            opts, args = getopt.gnu_getopt(argv[1:], "ho:av", ["help","verbose"])

        except getopt.error as msg:

             raise Usage(msg)

    except Usage as err:

        print(err.msg, file=sys.stderr)

        print("for help use --help", file=sys.stderr)

        return 2

    outputNames = []

    for o, a in opts:

        if o in ("-h", "--help"):

            print(usage)

            return(0)

        if o in ("-o",""):

            outputNames.append(a)

        if o in ("-a",""):

            all = True

        if o in ("-v", "--verbose"):

            global verbose

            verbose = True

    try:

        if len(args) == 0:

            raise Usage("No template file given")

    except Usage as err:

        print(err.msg, file=sys.stderr)

        print("for help use --help", file=sys.stderr)

        return 2

    doCFile = None

    doHeader = None

    doObj = None

    headerFilename = None

    cFilename = None

    objFilename = None

    if len(outputNames) > 0:

        if len(args) > 1:

            print("Cannot process more than one input if you specify an output")

            return(3)

        for outputName in outputNames:

            if outputName[-2:] == ".h":

                doHeader = True

                headerFilename = outputName

            elif outputName[-2:] == ".c":

                doCFile = True

                cFilename = outputName

            elif outputName[-2:] == ".o":

                doObj = True

                objFilename = outputName

            else:

                print("output file type unsupported")

                return(4)

    else:

        doHeader = True

        doCFile = True

        doObj = True

    # process arguments

    for arg in args:

        if arg[-3:] != ".tp":

                print(arg + " does not end in .tp. Skipping.")

                continue

        tpl = None

        try:

            tpl = TemplateFile(arg)

        except IOError as args:

            print("Cannot read input file " + args.filename + " " + args.strerror)

            return -1

        try:

            if doHeader:

                if headerFilename:

                    curFilename = headerFilename

                else:

                    curFilename = re.sub("\.tp$",".h",arg)

                doth = HeaderFile(curFilename, tpl)

                doth.write()

            if doCFile:

                if cFilename:

                    curFilename = cFilename

                else:

                    curFilename = re.sub("\.tp$",".c",arg)

                dotc = CFile(curFilename, tpl)

                dotc.write()

            if doObj:

                if objFilename:

                    curFilename = objFilename

                else:

                    curFilename = re.sub("\.tp$",".o",arg)

                dotobj = ObjFile(curFilename, tpl)

                dotobj.write()

        except IOError as args:

            print("Cannot write output file " + args.filename + " " + args.strerror)

            return -1

if __name__ == "__main__":

    sys.exit(main())