Compiler construction 如何编写一个编译器/解释器，在输入为XML的情况下，它可以以不同的目标语言生成源代码？

如果我问错了地方，请原谅并指导我找一个更合适的

所以我有一个这样的XML

<range>
   unconstrained
   <span>
      <rttype>
         String
</range>

<range>
   x type
   <span>
      <rttype>
         int
      <assert>
         $ > 0
</range>

<range>
   Simple class reference
   <span>
      <rttype>
         SimpleClass
</range>

<range>
   Simple class set
   <span>
      <rttype>
         ArrayList<SimpleClass>
</range>

<class>
  Simple class


  <attribute>
     x
        <range>
           x type
  </attribute>

  <attribute>
     state
  </attribute>

  <action>
     initializer
     <guarantees>
        x has been set to zero
     </guarantees>
     <pimaction>
        .@a x @ = 0
     </pimaction>
  </action>

  <action>
     update x
     <parameter>
        new x
        x type
     <guarantees>
        x has been set to new x
     </guarantees>
     <pimaction>
        .@a x @ = @i new x @
     </pimaction>
  </action>

  <state>
     Exists
  </state>

  <state>
     Doesn't exist
  </state>

  <event>
     <<new>>
  </event>

  <event>
     <<destroy>>
  </event>

  <event>
     update
  </event>

  <transition>
     Doesn't exist
     <<new>>
     Exists
     <transitionaction>
        initializer
  </transition>

  <transition>
     Exists
     <<destroy>>
     Doesn't exist
  </transition>

  <transition>
     Exists
     update
     Exists
     <transitionaction>
        update x
  </transition>

问题是，我的生产规则需要访问他们正在编译的模型对象中的实例变量数据

例如，要生成

实例变量声明

，我需要一个用Java代码编写的生产规则，就像这样，它需要在

Context.model（）

我想知道是否有更简单的方法来添加目标语言或框架，而不必为每个目标语言创建单独的代码库

例如，我现在有一个ToJavaCompiler和一个ToPythonCompiler两个独立的代码库

所以我在这里询问是否有一种方法可以创建一个适合我需要的抽象产生式规则解释器/编译器。我的目标是最终在目标语言或框架（如Django或Rails）中生成模型类，并使用一个允许扩展不同目标语言/框架的代码库

如果有更好的语言适合我的工作，我可以离开Java

我脑海中浮现的其他想法：

也许我需要用目标语言编写预期类的模板

也许我需要编写一些定制的DSL来处理XML输入

class SimpleClass:

    # State Enum Declaration
    # see MMClass.ruleStateEnumDeclaration for implementation

    SimpleClass_states = Enum("SimpleClass_states", "EXISTS DOESNTEXIST")

    # Attribute instance variables
    # see MMClass.ruleAttributeInstVarList for implementation

    _x: int
    _state: SimpleClass_states

    # Class level attribute
    # All class members accessor

    SimpleClassSet: ClassVar[List[SimpleClass]] = []


    # Constructor
    # See MMClass.ruleConstructorOperation

    # See constructEvent.ruleConstructorOperation
    def __init__(self):
        # requires
        #    none
        # guarantees
        #    --> x has been set to zero and state == Exists
        self._initializer()
        self._state = SimpleClass.SimpleClass_states.EXISTS
        SimpleClass.SimpleClassSet.append(self)

    # Attribute getters

    @property
    def x(self) -> int:
        # requires
        #   none
        # guarantees
        #   returns the x
        return self._x

    @property
    def state(self) -> SimpleClass_states:
        # requires
        #   none
        # guarantees
        #   returns the state
        return self._state


    # Pushed events

    def destroy(self) -> None:
        # requires
        #    none
        # guarantees
        #   state was Exists --> state == Doesn't exist
        if self._state == SimpleClass.SimpleClass_states.EXISTS:
            self._state = SimpleClass.SimpleClass_states.DOESNTEXIST
            SimpleClass.SimpleClassSet.remove(self)

    def update(self, new_x: int) -> None:
        # requires
        #    none
        # guarantees
        #   state was Exists --> x has been set to new x
        if self._state == SimpleClass.SimpleClass_states.EXISTS:
            self._update_x(new_x)

    # Private transition actions

    def _initializer(self):
        # requires
        #   none
        # guarantees
        #   x has been set to zero
        self._x = 0

    def _update_x(self, new_x: int):
        # requires
        #   none
        # guarantees
        #   x has been set to new x
        self._x = new_x

public void ruleAttributeInstVarList() {
    // description
    // this rule emits the set of (private) instance variable declarations, if any
    //
    // Class.#ATTRIBUTE_INST_VAR_LIST -->
    // foreach anAttribute in class
    // anAttribute.#DEFINE_INST_VAR
    //
    // requires
    // none
    // guarantees
    // all attributes of this class have been declared as instance variable of the
    // PIM Overlay run-time type
    if (Context.model().isVerbose()) {
        Context.codeOutput().indent();
        Context.codeOutput().println("# Attribute instance variables");
        Context.codeOutput().println("# see MMClass.ruleAttributeInstVarList for implementation");
        
        Context.codeOutput().println("");
        if (!attributeSet.isEmpty()) {
            for (Attribute anAttribute : attributeSet) {
                anAttribute.ruleDefineInstVarAsPrivate();
            }
        } else {
            if (Context.model().isVerbose()) {
                Context.codeOutput().indent();
                Context.codeOutput().println("# none");
            }
        }
        Context.codeOutput().indentLess();
    } else {
        for (Attribute anAttribute : attributeSet) {
            anAttribute.ruleDefineInstVarAsPrivate();
        }
    }
    Context.codeOutput().println("");
    Context.codeOutput().println("");
}