def var_name(name: str) -> str: """Transform a variable name into a valid one for Rust""" candidate = snake_case(name) if candidate in EXTENDED_KEYWORDS: return candidate + "_" if candidate.startswith("read_struct_") or candidate.endswith("_elem"): return candidate + "_" return candidate
def var_name(name: str) -> str: """Transform a variable name into a valid one for Python""" candidate = snake_case(name) return ( candidate + "_" if iskeyword(candidate) or candidate == "dataclass" else candidate )
def method_name(name: str) -> str: """Transform a method name into a valid procedure name for Prolog""" candidate = snake_case(name) if candidate in KEYWORDS or candidate in USED_PROCEDURES: return candidate + "_" if candidate.startswith("read_assoc_"): return candidate + "_" return candidate
def var_name(var: Variable) -> str: """Transform a variable name into a valid one for Perl""" name = snake_case(var.name) if name in ("a", "b"): # $a and $b are used by Perl name += "_" if var.type.main == TypeEnum.LIST: return "@" + name if var.type.main == TypeEnum.STRUCT: return "%" + name return "$" + name
def var_name(name: str) -> str: """Transform a variable name into a valid one for PHP""" if not name: return "" snake = snake_case(name) try: int(snake) return snake except ValueError: return "$" + snake
def declare_read_struct(self) -> str: """Declare a procedure reading a struct into a assoc""" output = "" for struct in self.input.structs: name = "read_assoc_{}(X) :-".format(snake_case(struct.name)) keys = ", ".join('"{}"'.format(i.name) for i in struct.fields) if Type(TypeEnum.STRUCT, struct_name=struct.name).fits_in_one_line( self.input.structs): if all(i.type.main == TypeEnum.INT for i in struct.fields): self.read.add("List[int]") output += ("{} read_int_list(L), pairs_keys_values(P, " "[{}], L), list_to_assoc(P, X).\n").format( name, keys) elif all(i.type.main == TypeEnum.CHAR for i in struct.fields): self.read.add("List[char]") output += ("{} read_line(S), atomic_list_concat(L, ' '," "S), pairs_keys_values(P, [{}], L), " "list_to_assoc(P, X).\n").format(name, keys) else: output += "{}\n".format(name) output += INDENTATION + ( "read_line_to_codes(user_input, C), " 'split_string(C, " ", "", L), empty_assoc(A0),\n') for i, field in enumerate(struct.fields): output += INDENTATION + ( "nth0({1}, L, L{1}), {3}, " 'put_assoc("{0}", A{1}, C{1}, A{2}),\n').format( field.name, i, i + 1, ("number_string(C{0}, L{0})" if field.type.main == TypeEnum.INT else "sub_atom(L{0}, 0, 1, _, C{0})").format(i), ) output += INDENTATION + "X = A{}.\n".format( len(struct.fields)) else: output += "{}\n".format(name) names = [var_name(f.name) for f in struct.fields] var_x = "X" var_p = "P" while var_x in names: var_x += "X" while var_p in names: var_p += "P" for field in struct.fields: output += (INDENTATION + call_goal( self.read_lines(field.type), var_name(field.name)) + "\n") output += INDENTATION + ( "pairs_keys_values({0}, [{1}], [{2}]), " "list_to_assoc({0}, {3}).\n").format( var_p, keys, ", ".join(names), var_x) return output
def size_name(name: str) -> str: """Transform a variable name or an integer into a valid Perl identifier""" if not name: return "" snake = snake_case(name) try: int(snake) return snake except ValueError: if snake in ("a", "b"): # $a and $b are used by Perl snake += "_" return "$" + snake
def read_lines(self, type_: Type, style: FormatStyle = FormatStyle.DEFAULT) -> str: """Read one or several lines and parse them""" if type_.fits_in_one_line(self.input.structs, style): return self.read_line(type_) if type_.main == TypeEnum.STRUCT: return "read_assoc_{}".format(snake_case(type_.struct_name)) assert type_.main == TypeEnum.LIST assert type_.encapsulated is not None self.read.add("List") replicate = self.read_lines(type_.encapsulated) return "read_list({}, {})".format(replicate, var_name(type_.size))
def read_line(self, type_: Type) -> str: """Read an entire line and parse it""" assert type_.fits_in_one_line(self.input.structs) if type_.main == TypeEnum.INT: self.read.add("int") return "read_int" if type_.main == TypeEnum.CHAR: self.read.add("char") return "read_char" if type_.main == TypeEnum.STR: self.read.add("str") return "read_line" if type_.main == TypeEnum.LIST: assert type_.encapsulated is not None if type_.encapsulated.main == TypeEnum.INT: self.read.add("List[int]") return "read_int_list" assert type_.encapsulated.main == TypeEnum.CHAR self.read.add("List[char]") return "read_char_list" assert type_.main == TypeEnum.STRUCT return "read_assoc_{}".format(snake_case(type_.struct_name))
def sub_name(name: str) -> str: """Transform a subroutine name into a valid one for Perl""" candidate = snake_case(name) return candidate + "_" if candidate in KEYWORDS else candidate
def var_name(name: str) -> str: """Transform a variable name into a valid one for Julia""" candidate = snake_case(name) return candidate + "_" if candidate in RESERVED else candidate
def struct_name(name: str) -> str: """Transform a struct name into a valid one for C""" candidate = snake_case(name) # We make want an other style if candidate in KEYWORDS: return candidate + "_" return candidate
def var_name(name: str) -> str: """Transform a variable name into a valid one for C""" candidate = snake_case(name) if candidate in KEYWORDS or candidate == "main": return candidate + "_" return candidate
def var_name(name: str) -> str: """Transform a variable name into a valid one for Lua""" candidate = snake_case(name) return candidate + "_" if candidate in KEYWORDS else candidate
def record_name(name: str) -> str: """Transform a record name into a valid one for OCaml""" candidate = snake_case(name) if candidate in ("int", "char", "string", "list"): return candidate + "_" return candidate + "_" if candidate in KEYWORDS else candidate
def function_name(name: str) -> str: """Transform a function name into a valid one for PHP""" candidate = snake_case(name) return candidate + "_" if candidate in KEYWORDS else candidate