#!/usr/bin/env python3

#
# //===----------------------------------------------------------------------===//
# //
# // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# // See https://llvm.org/LICENSE.txt for license information.
# // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
# //
# //===----------------------------------------------------------------------===//
#

import argparse
import os
import re
import sys
from libomputils import error, ScriptError, print_error_line


class DllExports(object):
    def __init__(self):
        self.filename = None
        self.exports = {}
        self.ordinals = set([])

    def add_uppercase_entries(self):
        # Ignored entries are C/C++ only functions
        ignores = [
            "omp_alloc",
            "omp_free",
            "omp_calloc",
            "omp_realloc",
            "omp_aligned_alloc",
            "omp_aligned_calloc",
        ]
        keys = list(self.exports.keys())
        for entry in keys:
            info = self.exports[entry]
            if info["obsolete"] or info["is_data"] or entry in ignores:
                continue
            if entry.startswith("omp_") or entry.startswith("kmp_"):
                newentry = entry.upper()
                if info["ordinal"]:
                    newordinal = info["ordinal"] + 1000
                else:
                    newordinal = None
                self.exports[newentry] = {
                    "obsolete": False,
                    "is_data": False,
                    "ordinal": newordinal,
                }

    @staticmethod
    def create(inputFile, defs=None):
        """Creates DllExports object from inputFile"""
        dllexports = DllExports()
        dllexports.filename = inputFile
        # Create a (possibly empty) list of definitions
        if defs:
            definitions = set(list(defs))
        else:
            definitions = set([])
        # Different kinds of lines to parse
        kw = r"[a-zA-Z_][a-zA-Z0-9_]*"
        ifndef = re.compile(r"%ifndef\s+({})".format(kw))
        ifdef = re.compile(r"%ifdef\s+({})".format(kw))
        endif = re.compile(r"%endif")
        export = re.compile(r"(-)?\s*({0})(=({0}))?(\s+([0-9]+|DATA))?".format(kw))

        def err(fil, num, msg):
            error("{}: {}: {}".format(fil, num, msg))

        defs_stack = []
        with open(inputFile) as f:
            for lineNumber, line in enumerate(f):
                line = line.strip()
                # Skip empty lines
                if not line:
                    continue
                # Skip comment lines
                if line.startswith("#"):
                    continue
                # Encountered %ifndef DEF
                m = ifndef.search(line)
                if m:
                    defs_stack.append(m.group(1) not in definitions)
                    continue
                # Encountered %ifdef DEF
                m = ifdef.search(line)
                if m:
                    defs_stack.append(m.group(1) in definitions)
                    continue
                # Encountered %endif
                m = endif.search(line)
                if m:
                    if not defs_stack:
                        err(inputFile, lineNumber, "orphan %endif directive")
                    defs_stack.pop()
                    continue
                # Skip lines when not all %ifdef or %ifndef are true
                if defs_stack and not all(defs_stack):
                    continue
                # Encountered an export line
                m = export.search(line)
                if m:
                    obsolete = m.group(1) is not None
                    entry = m.group(2)
                    rename = m.group(4)
                    ordinal = m.group(6)
                    if entry in dllexports.exports:
                        err(
                            inputFile,
                            lineNumber,
                            "already specified entry: {}".format(entry),
                        )
                    if rename:
                        entry += "={}".format(rename)
                    # No ordinal number nor DATA specified
                    if not ordinal:
                        ordinal = None
                        is_data = False
                    # DATA ordinal
                    elif ordinal == "DATA":
                        ordinal = None
                        is_data = True
                    # Regular ordinal number
                    else:
                        is_data = False
                        try:
                            ordinal = int(ordinal)
                        except:
                            err(
                                inputFile,
                                lineNumber,
                                "Bad ordinal value: {}".format(ordinal),
                            )
                        if ordinal >= 1000 and (
                            entry.startswith("omp_") or entry.startswith("kmp_")
                        ):
                            err(
                                inputFile,
                                lineNumber,
                                "Ordinal of user-callable entry must be < 1000",
                            )
                        if ordinal >= 1000 and ordinal < 2000:
                            err(
                                inputFile,
                                lineNumber,
                                "Ordinals between 1000 and 1999 are reserved.",
                            )
                        if ordinal in dllexports.ordinals:
                            err(
                                inputFile,
                                lineNumber,
                                "Ordinal {} has already been used.".format(ordinal),
                            )
                    dllexports.exports[entry] = {
                        "ordinal": ordinal,
                        "obsolete": obsolete,
                        "is_data": is_data,
                    }
                    continue
                err(
                    inputFile,
                    lineNumber,
                    'Cannot parse line:{}"{}"'.format(os.linesep, line),
                )
        if defs_stack:
            error("syntax error: Unterminated %if directive")
        return dllexports


def generate_def(dllexports, f, no_ordinals=False, name=None):
    """Using dllexports data, write the exports to file, f"""
    if name:
        f.write("LIBRARY {}\n".format(name))
    f.write("EXPORTS\n")
    for entry in sorted(list(dllexports.exports.keys())):
        info = dllexports.exports[entry]
        if info["obsolete"]:
            continue
        f.write("    {:<40} ".format(entry))
        if info["is_data"]:
            f.write("DATA\n")
        elif no_ordinals or not info["ordinal"]:
            f.write("\n")
        else:
            f.write("@{}\n".format(info["ordinal"]))


def main():
    parser = argparse.ArgumentParser(
        description="Reads input file of dllexports, processes conditional"
        " directives, checks content for consistency, and generates"
        " output file suitable for linker"
    )
    parser.add_argument(
        "-D",
        metavar="DEF",
        action="append",
        dest="defs",
        help="Define a variable. Can specify" " this more than once.",
    )
    parser.add_argument(
        "--no-ordinals",
        action="store_true",
        help="Specify that no ordinal numbers should be generated",
    )
    parser.add_argument(
        "-n",
        "--name",
        dest="name",
        help="Specify library name for def file LIBRARY statement",
    )
    parser.add_argument(
        "-o",
        "--output",
        metavar="FILE",
        dest="output",
        help="Specify output file name. If not specified," " output is sent to stdout",
    )
    parser.add_argument("dllexports", help="The input file describing dllexports")
    commandArgs = parser.parse_args()
    defs = set([])
    if commandArgs.defs:
        defs = set(commandArgs.defs)
    dllexports = DllExports.create(commandArgs.dllexports, defs)
    dllexports.add_uppercase_entries()
    try:
        output = open(commandArgs.output, "w") if commandArgs.output else sys.stdout
        generate_def(dllexports, output, commandArgs.no_ordinals, commandArgs.name)
    finally:
        if commandArgs.output:
            output.close()


if __name__ == "__main__":
    try:
        main()
    except ScriptError as e:
        print_error_line(str(e))
        sys.exit(1)

# end of file