If I am asking in the wrong place, please forgive and direct me to a more suitable one
So I have a XML like this
<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>
I have a Java compiler (let’s call this ToJavaCompiler) that will compile this into a Java class
And another Java compiler (let’s call this ToPythonCompiler) that will also compile this into a Python class.
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
THe thing is my production rule need access to instance variable data from the model object they are compiling.
For example to generate the instance variables declarations i need a production rule that’s written in Java code like this which require access to the underlying model itself at Context.model()
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(""); }
I wonder if there’s an easier way to add target languages or frameworks without creating separate codebases per target language.
For e.g. I now have a ToJavaCompiler and a ToPythonCompiler two separate codebases
So I am here asking if there’s a way I can create an abstract production rule interpreter that suits my needs. My aim is to ultimately produce model classes in the target language or framework (such as Django or Rails) with a single codebase that allows extensions for different target languages/frameworks
I am okay to move away from Java if there’s a better language that suits what I am trying to do.
