research-portable-memory/tr-Python-C++/CPP.py

from Function import *

def translateParameter(s):
    # name: type -> type name
    parts = s.split(": ")
    indent = len(s) - len(s.lstrip())
    name = parts[0].lstrip()
    t = translateType(parts[1])
    indentation = "".join(" " * indent)
    return f"{indentation}{t} {name}"

def translateStatement(s):
    indent = len(s) - len(s.lstrip())
    indentation = "".join(" " * indent)
    ss = s.lstrip()
    posColon = ss.find(": ")
    posComma = ss.find(", ")
    posEqual = ss.find(" = ")
    posFor = ss.find("for ")
    posIn = ss.find(" in ")
    posRange = ss.find("range(")
    posRangeEnd = ss.find("):")
    posClosingScope = ss.find("#}")
    posOpenSquareBracket = ss.find("[")

    # #} -> }
    if posClosingScope != -1:
      return f"{indentation}}}"

    # for name in range(x, y): -> for (auto name = x; name < y; ++name) {
    if (
        posFor >= 0 and
        posIn >= 0 and
        posRange >= 0
    ):
      name = ss[posFor + len("for "):posIn]
      x = ss[posRange + len("range("):posComma]
      y = ss[posComma + len(", "):posRangeEnd]
      return f"{indentation}for (auto {name} = {x}; {name} < {y}; ++{name}) {{"

    # name: type = value -> type name = value
    if (
        posColon >= 0 and
        posEqual >= 0
    ):
      name = ss[:posColon]
      type = ss[posColon + len(": "):posEqual]
      t = translateType(type)
      value = ss[posEqual + len(" = "):]
      return f"{indentation}{t} {name} = {value};"

    # name = value -> auto name = value
    if (
        posColon == -1 and
        posOpenSquareBracket == -1 and
        posEqual >= 0
    ):
      name = ss[:posEqual]
      value = ss[posEqual + len(" = "):]
      return f"{indentation}auto {name} = {value};"

    # Unknown. Return with semicolon at the end.
    return f"{s};"

def translateType(s):
    # dict[X, Y] -> std::map<X, Y>
    if s.startswith("dict["):
        kv = s[len("dict["):-len("]")]
        parts = kv.split(", ")
        return f"std::map<{parts[0]}, {parts[1]}>"

    # Unknown. Return as is.
    return s

class CPP:
    def __init__(self, fn):
        self.fn = fn

    def translate(self):
        returnType = translateType(self.fn.returnType)

        # Parameters.
        params = []
        for i in range(0, len(self.fn.parameters)):
            p = translateParameter(self.fn.parameters[i])
            params.append(p)
        strparams = "\n".join(params)

        # Statements.
        sts = []
        for i in range(0, len(self.fn.statements)):
          s = translateStatement(self.fn.statements[i])
          sts.append(s)
        strstatements = "\n".join(sts)

        return f"""{returnType} {self.fn.name}(
{strparams}
) {{
{strstatements}
}}
"""