#!/usr/bin/env python3
# pylint: disable=too-many-locals,unused-argument,keyword-arg-before-vararg

# A script to generate enums in different languages from a CSV file.
# A CSV File contains
# enum1, 0
# enum2, ..
# ...
# enumn, n
# where 0,...,n are numbers.
#
# Written by Supakorn "Jamie" Rassameemasmuang <[email protected]>

import argparse
import io
import os
import re
import sys
import time
from datetime import datetime, timezone
from typing import List, Tuple, Union


def cleanComment(s):
   return re.sub(r" *#", " ", s)


def parse_args():
   parser = argparse.ArgumentParser()
   parser.add_argument("-language", "--language", type=str, required=True)
   parser.add_argument("-o", "--output", type=str, required=True)
   parser.add_argument("-i", "--input", type=str, required=True)
   parser.add_argument("-name", "--name", type=str, required=True)
   parser.add_argument("-xopt", "--xopt", type=str, nargs="*")
   return parser.parse_args()


def create_enums(filename: str) -> List[Union[Tuple[str, int, str], Tuple[str, int]]]:
   final_list = []
   with io.open(filename, newline="", encoding="utf-8") as rawfile:
       for line in rawfile.readlines():
           if line.startswith("#") or line.strip() == "":
               continue
           raw_line = line.strip().split(",")
           raw_str, raw_number = raw_line[0:2]
           comment = None
           if len(raw_line) >= 3:
               comment = raw_line[-1]
               final_list.append((raw_str.strip(), int(raw_number.strip()), comment))
           else:
               final_list.append((raw_str.strip(), int(raw_number.strip())))
   return final_list


def datetime_now():
   return datetime.fromtimestamp(
       int(os.environ.get("SOURCE_DATE_EPOCH", time.time())), tz=timezone.utc
   )


def generate_enum_cpp(outname, enums, name, comment=None, *args, **kwargs):
   with io.open(outname, "w", encoding="utf-8") as fil:
       fil.write(f"// Enum class for {name}\n")
       if comment is not None:
           fil.write(f"// {comment}\n")
       if "namespace" in kwargs:
           fil.write(f"namespace {kwargs['namespace']}\n")
           fil.write("{\n")

       fil.write(f"enum {name} : uint32_t\n")
       fil.write("{\n")

       for enumTxt, enumNum, *ar in enums:
           if len(ar) > 0:
               comment = cleanComment(ar[-1])
               if comment is not None:
                   fil.write(f"// {comment.strip()}\n")
           fil.write(f"{enumTxt}={enumNum},\n\n")

       fil.write("};\n\n")

       if "namespace" in kwargs:
           fil.write(f"}} // namespace {kwargs['namespace']}\n")
       fil.write("// End of File\n")


def generate_enum_java(outname, enums, name, comment=None, *args, **kwargs):
   with io.open(outname, "w", encoding="utf-8") as fil:
       fil.write(f"// Enum class for {name}\n")
       if comment is not None:
           fil.write(f"// {comment}\n")
       if "package" in kwargs:
           fil.write(f"package {kwargs['package']};\n")
       fil.write("\n")

       fil.write(f"public enum {name} {{\n")

       spaces = kwargs.get("spaces", 4)
       spaces_tab = " " * spaces

       for i, enum in enumerate(enums):
           enumTxt, enumNum, *ar = enum
           endsep = "," if i < len(enums) - 1 else ";"
           fil.write(f"{spaces_tab}{enumTxt}({enumNum}){endsep}\n")
           if len(ar) > 0:
               comment = cleanComment(ar[-1])
               if comment is not None:
                   fil.write(f"// {comment.strip()}\n\n")

       out_lines = [
           "",
           f"{name}(int value) {{",
           f"{spaces_tab}this.value=value;",
           "}",
           "public String toString() {",
           f"{spaces_tab}return Integer.toString(value);",
           "}",
           "private int value;",
       ]

       for line in out_lines:
           fil.write(spaces_tab)
           fil.write(line)
           fil.write("\n")
       fil.write("};\n\n")
       fil.write("// End of File\n")


def generate_enum_asy(outname, enums, name, comment=None, *args, **kwargs):
   with io.open(outname, "w", encoding="utf-8") as fil:
       fil.write(f"// Enum class for {name}\n")
       if comment is not None:
           fil.write(f"// {comment}\n")
       fil.write(f"struct {name}\n")
       fil.write("{\n")

       for enumTxt, enumNum, *ar in enums:
           fil.write(f"  int {enumTxt}={enumNum};\n")
           if len(ar) > 0:
               comment = cleanComment(ar[-1])
               if comment is not None:
                   fil.write(f"// {comment.strip()}\n\n")
       fil.write("};\n\n")
       fil.write(f"{name} {name};")

       fil.write("// End of File\n")


def generate_enum_py(outname, enums, name, comment=None, *args, **kwargs):
   with io.open(outname, "w", encoding="utf-8") as fil:
       fil.write("#!/usr/bin/env python3\n")
       fil.write(f"# Enum class for {name}\n")
       if comment is not None:
           fil.write(f'""" {comment} """\n')
       fil.write(f"class {name}:\n")
       for enumTxt, enumNum, *ar in enums:
           fil.write(f"    {name}_{enumTxt}={enumNum}\n")
           if len(ar) > 0:
               comment = cleanComment(ar[-1])
               if comment is not None:
                   fil.write(f"    # {comment.strip()}\n\n")
       fil.write("# End of File\n")


def main():
   arg = parse_args()
   if arg.language in {"python", "py"}:
       fn = generate_enum_py
   elif arg.language in {"cxx", "c++", "cpp"}:
       fn = generate_enum_cpp
   elif arg.language in {"asy", "asymptote"}:
       fn = generate_enum_asy
   elif arg.language in {"java"}:
       fn = generate_enum_java
   else:
       return 1

   custom_args = {}
   if arg.xopt is not None:
       for xopt in arg.xopt:
           key, val = xopt.split("=")
           custom_args[key] = val

   enums = create_enums(arg.input)
   fn(arg.output, enums, arg.name, "AUTO-GENERATED from " + arg.input, **custom_args)
   return 0


if __name__ == "__main__":
   sys.exit(main() or 0)

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.