[CBuilder] Eindeutige Namen für Methoden hinter der API gekapselt. (#105)

Author: CrappyAlgorithm

docs/usage_cbuilder.md

@@ -138,11 +138,9 @@ def func1(x):
 print(func1(a))
 ```
 
-Eine Funktion wird über ein Objekt der Klasse `Function` erzeugt. Der Konstruktor hat die
-beiden Parameter `funcName` und `uniqueName`, wobei `funcName` der Name der Funktion wie im
-Python-Code ist und zum Auflösen über Referenzen innerhalb des Scopes dient. Der Parameter
-`uniqueName` ist ein eindeutiger Name für die Funktion und muss identisch zu `funcName`
-sein.
+Eine Funktion wird über ein Objekt der Klasse `Function` erzeugt. Der Konstruktor hat einen
+Parameter `funcName`, der der Name der Funktion wie im Python-Code ist und der zum Auflösen
+über Referenzen innerhalb des Scopes dient.
 
 Der Body einer Funktion wird als Liste von Objekten vom Typ `Statement` repräsentiert und im
 Konstruktor über den Parameter `body` übergeben.
@@ -172,8 +170,8 @@ List<Argument> parameterArguments = List.of(new Argument[] {new Argument("x", 0)
 List<VariableDeclaration> localVariables = List.of(new VariableDeclaration[] {localVarYDecl});  // Liste der lokalen Variablen
 
 // Function erstellen
-Function func1 = new Function("func1", "func1", body, parameterArguments, localVariables);  // Funktion erzeugen
-builder.addFunction(func1);                                                                 // Function dem CBuilder übergeben
+Function func1 = new Function("func1", body, parameterArguments, localVariables);       // Funktion erzeugen
+builder.addFunction(func1);                                                             // Function dem CBuilder übergeben
 ```
 
 ``` java
@@ -326,28 +324,29 @@ Beim Methodenaufruf darf `self` aber nicht in der Parameterliste vorkommen. (Sta
 Methoden, die nicht umgesetzt werden müssen, haben kein `self`.)
 
 Methoden haben zwei Methodennamen. Der Parameter `funcName` im `Function`-Konstruktor
-entspricht dem Funktionsnamen im Python-Code. Über diesen Namen werden die Methoden im
-jeweiligen Scope aufgelöst. Da Methoden vom CBuilder als normale C-Funktion im globalen
-Scope angelegt werden, müssen sie noch einen im gesamten Programm eindeutigen (internen)
-Namen bekommen, der über den Parameter `uniqueName` im `Function`-Konstruktor festgelegt
-wird. (Dennoch können Methoden nicht als normale Funktionen aufgerufen werden, sondern immer
-nur über den Kontext ihrer Klasse.) Beim Überschreiben von Methoden muss der `funcName`
-entsprechend identisch sein (und `uniqueName` muss variieren).
+entspricht dem Funktions-/Methodennamen im Python-Code. Über diesen Namen werden die
+Methoden im jeweiligen Scope aufgelöst. Da Methoden vom CBuilder als normale C-Funktion im
+globalen Scope angelegt werden, müssen sie noch einen im gesamten Programm eindeutigen
+(internen) Namen bekommen, der mit der Methode `Function#createUniqueCName()` festgelegt
+wird - diese Methode wird automatisch vom Konstruktor von `MPyClass` aufgerufen. (Dennoch
+können Methoden nicht als normale Funktionen aufgerufen werden, sondern immer nur über den
+Kontext ihrer Klasse.) Beim Überschreiben von Methoden muss der `funcName` entsprechend
+identisch sein.
 
 *Anmerkung*: Der Parameter `classAttributes` im Konstruktor von `MPyClass` wird nur für
 statische Attribute verwendet und kann ignoriert werden, da statische Attribute hier nicht
 zum geforderten Sprachumfang gehören. Sie können hier einfach ein `Map.of()` übergeben.
 
 ``` java
 // Methode "__init__(self)" anlegen
-Statement simpleSuperCall = new SuperCall(List.of());                               // Aufruf von Super
-List<Statement> initBody = List.of(new Statement[] { simpleSuperCall });            // Body der Methode: super() kommt als erstes Statement
-List<Argument> initParamList = List.of(new Argument[] {new Argument("self", 0)});   // Parameterliste für "__init__" erstellen
-Function methodInit = new Function("__init__", "__init_11", initBody, initParamList, List.of());    // Methode "__init__(self)" erstellen; Name im C-Scope: "__init_11" (willkürlich, aber eindeutig im Programm)
+Statement simpleSuperCall = new SuperCall(List.of());                                   // Aufruf von Super
+List<Statement> initBody = List.of(new Statement[] { simpleSuperCall });                // Body der Methode: super() kommt als erstes Statement
+List<Argument> initParamList = List.of(new Argument[] {new Argument("self", 0)});       // Parameterliste für "__init__" erstellen
+Function methodInit = new Function("__init__", initBody, initParamList, List.of());     // Methode "__init__(self)" erstellen
 
 // Methode "foo(self, x)" anlegen
 List<Argument> fooParamList = List.of(new Argument[] {new Argument("self", 0), new Argument("x", 1)});  // Parameterliste für "foo"
-Function methodFooA = new Function("foo", "foo12", List.of(), fooParamList, List.of());                 // Methode "foo" mit leerem Body; Name im C-Scope: "foo12" (willkürlich, aber eindeutig im Programm)
+Function methodFooA = new Function("foo", List.of(), fooParamList, List.of());                          // Methode "foo" mit leerem Body
 
 // Klasse "A" anlegen: Erbt implizit von __MPyType_Object
 List<Function> functionListA = List.of(new Function[] { methodInit, methodFooA });  // Liste der Methoden in A
@@ -382,13 +381,13 @@ Für die Vererbung werden die bereits bekannten Elemente verwendet.
 Statement simpleSuperCall = new SuperCall(List.of());
 List<Statement> initBody = List.of(new Statement[] { simpleSuperCall });
 List<Argument> initParamList = List.of(new Argument[] {new Argument("self", 0)});
-Function methodInitB = new Function("__init__", "__init_111", initBody, initParamList, List.of());
+Function methodInitB = new Function("__init__", initBody, initParamList, List.of());
 
 // "foo(self, x)"
 Statement fooPrint = new Call(printRef, List.of(new Expression[] { new Reference("x")}));
 List<Argument> fooParamList = List.of(new Argument[] {new Argument("self", 0), new Argument("x", 1)});
 List<Statement> fooBody = List.of(new Statement[]{ fooPrint });
-Function methodFooB = new Function("foo", "foo122", fooBody, fooParamList, List.of());
+Function methodFooB = new Function("foo", fooBody, fooParamList, List.of());
 
 // Klasse "B"
 List<Function> functionListB = List.of(new Function[]{ methodInitB, methodFooB });
@@ -410,8 +409,8 @@ builder.addStatement(callFoo);
 
 Ausblick: Für den Aufruf von Methoden auf Objekten erzeugen Sie wieder einen `Call`, der als
 Referenz eine `AttributeReference` erhält. Diese `AttributeReference` gruppiert den
-Methodennamen (den `funcName`, nicht den `uniqueName`!) und eine Referenz auf das Objekt.
-Weitere Details [siehe unten](usage_cbuilder.md#methoden-auf-objekten-aufrufen).
+Methodennamen (`funcName`) und eine Referenz auf das Objekt. Weitere Details [siehe
+unten](usage_cbuilder.md#methoden-auf-objekten-aufrufen).
 
 ### Verwendung von `self`
 
@@ -441,12 +440,12 @@ Statement returnX = new ReturnStatement(getSelfX);
 // "__init__(self, y)"
 List<Statement> initBodyWithSelfAssign = List.of(new Statement[] { simpleSuperCall, assignSelfX });
 List<Argument> initParamListWithX = List.of(new Argument[] {new Argument("self", 0), new Argument("y", 1)});
-Function methodInitWithSelf = new Function("__init__", "__init_13", initBodyWithSelfAssign, initParamListWithX, List.of());
+Function methodInitWithSelf = new Function("__init__", initBodyWithSelfAssign, initParamListWithX, List.of());
 
 // "getX(self)"
 List<Statement> getXBody = List.of(new Statement[] { returnX });
 List<Argument> paramListGetX = List.of(new Argument[] {new Argument("self", 0)});
-Function getX = new Function("getX", "getX14", getXBody , paramListGetX, List.of());
+Function getX = new Function("getX", getXBody, paramListGetX, List.of());
 
 // Class "C"
 List<Function> functionListC = List.of(new Function[] { methodInitWithSelf, getX });
@@ -466,9 +465,9 @@ print(objectC.getX())
 Das Instanziieren einer Klasse erfolgt wie der Aufruf einer Funktion.
 
 Der Aufruf von Methoden wird über ein Objekt der Klasse `AttributeReference` und einen
-`Call` realisiert. Diese `AttributeReference` gruppiert den Methodennamen (den `funcName`,
-nicht den `uniqueName`!) und eine Referenz auf das Objekt. Der Parameter `self` darf beim
-Methodenaufruf nicht übergeben werden.
+`Call` realisiert. Diese `AttributeReference` gruppiert den Methodennamen (`funcName`) und
+eine Referenz auf das Objekt. Der Parameter `self` darf beim Methodenaufruf nicht übergeben
+werden.
 
 ``` java
 // Variable "objectC"

src/main/java/CBuilder/ManualTest.java

@@ -10,7 +10,6 @@
 import java.nio.file.Path;
 import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 /**
  * Allows to test the Builder without involving the ast or anything.
@@ -113,7 +112,7 @@ static void generateProgram(Path output) {
                                                       new Reference("type")
                                               })));
 
-        builder.addFunction(new Function("printA", "printA_global", List.of(new Statement[]{
+        builder.addFunction(new Function("printA", List.of(new Statement[]{
                 new Call(new Reference("print"),
                          List.of(new Expression[]{
                                  new Reference("a")
@@ -127,15 +126,15 @@ static void generateProgram(Path output) {
         })));
 
         builder.addClass(new MPyClass("B", new Reference("__MPyType_Object"), List.of(new Function[]{
-                new Function("print", "printA_TypeB", List.of(new Statement[]{
+                new Function("print", List.of(new Statement[]{
                         new Call(new Reference("print"),
                                  List.of(new Expression[]{
                                          new Reference("self")
                                  }))
                 }), List.of(new Argument[]{
                         new Argument("self", 0)
                 }), List.of()),
-                new Function("__init__", "__init___TypeB", List.of(new Statement[] {
+                new Function("__init__", List.of(new Statement[] {
                     new SuperCall(List.of()),
                     new AttributeAssignment(new AttributeReference("b", new Reference("self")), new IntLiteral(100))
                 }), List.of(new Argument[]{
@@ -144,7 +143,7 @@ static void generateProgram(Path output) {
         }), new HashMap<>()));
 
         builder.addClass(new MPyClass("C", new Reference("B"), List.of(new Function[]{
-               new Function("__init__", "__init___TypeC", List.of(new Statement[] {
+               new Function("__init__", List.of(new Statement[] {
                        new SuperCall(List.of())
                }), List.of(new Argument[]{
                        new Argument("self", 0)

src/main/java/CBuilder/manualTests/ClassTest.java

@@ -28,12 +28,12 @@ static void generateProgram(Path output) {
         Reference object = new Reference("__MPyType_Object");
 
         MPyClass clazz = new MPyClass("A", object, List.of(new Function[]{
-            new Function("foo", "foo1", List.of(new Expression[]{
+            new Function("foo", List.of(new Expression[]{
                 new Call(funcPrint, List.of(new Expression[]{
                     new StringLiteral("foo")
                 }))
             }), List.of(new Argument[]{new Argument("self", 0)}), List.of()),
-            new Function("__init__", "__init1_", List.of(new Expression[]{
+            new Function("__init__", List.of(new Expression[]{
                 new SuperCall(List.of())
             }), List.of(new Argument[]{new Argument("self", 0)}), List.of())
         }), Map.of());

src/main/java/CBuilder/objects/MPyClass.java

@@ -41,6 +41,7 @@ public MPyClass(String name, Reference parent, List<Function> functions, Map<Ref
         this.parent = parent;
         this.functions = functions;
         this.classAttributes = classAttributes;
+        this.functions.forEach(func -> func.createUniqueCName(this.name + "_"));
     }
 
     /**

src/main/java/CBuilder/objects/functions/Function.java

@@ -9,11 +9,12 @@
 
 /**
  * Mini-Python function declaration.
+ *
  * Implements the Reference interface to allow using instances for referring to the declaration too.
  */
 public class Function extends Reference {
 
-    private final String uniqueName;
+    private String cName;
     private final List<Statement> body;
     private final List<Argument> positionalArgs; // (a, b, c)
     // TODO default arguments (a=1)
@@ -24,27 +25,23 @@ public class Function extends Reference {
 
 
     /**
-     * Create a new function.
+     * Create a new function (or method).
      *
-     * Receives both funcName and unique name to fulfill requirements of both mini-python's duck typing
+     * Receives a funcName to fulfill requirements of both mini-python's duck typing
      * and the declaration of the native C function containing the functions' statements.
-     * Since C does not have namespaces, for declaring the function itself a globally unique name is needed.
-     * But to make duck typing work, function names that were equal in the original mini-python code
-     * need to be the same here too.
-     *
-     * By setting receivesPackedKeywordArgs or receivesPackedPositionalArgs to true,
-     * the functions arguments handling make 'args' and/or 'kwargs' variables available in the scope of the function.
+     * Since there are no namespaces in C, a globally unique name is required for the
+     * declaration of the function itself. For functions, funcName is used for this purpose;
+     * for methods, the class name is automatically added as a prefix to funcName once the
+     * class is created (MPyClass).
      *
      * @param funcName The mini-python name of the function.
-     * @param uniqueName The C name for the function.
      * @param body The body of the function.
      * @param positionalArgs The arguments of the function.
      * @param localVariables Variables declared inside the function.
      */
-    public Function(String funcName, String uniqueName, List<Statement> body, List<Argument> positionalArgs, List<VariableDeclaration> localVariables) {
+    public Function(String funcName, List<Statement> body, List<Argument> positionalArgs, List<VariableDeclaration> localVariables) {
         super(funcName);
-
-        this.uniqueName = uniqueName;
+        this.cName = funcName;
         this.body = body;
         this.positionalArgs = positionalArgs;
         this.receivesPackedKeywordArgs = false;
@@ -53,16 +50,35 @@ public Function(String funcName, String uniqueName, List<Statement> body, List<A
     }
 
     /**
-     * Create the c-code representation for the function.
+     * Creates a unique method name used in emitted C code (auxiliary method, called by MPyClass)
+     *
+     * A method is a function that can only be called in connection with its class. However,
+     * since a method is emitted just as a normal function in the C code, the method name must
+     * be extended with a prefix at C level and thus be made unique. The constructor of MPyClass
+     * handles this by calling this auxiliary method.
+     *
+     * <p> To call a method, use its name (funcName) and not its unique C name.
+     *
+     * <p>Warning: Do not use this helper method for functions, as functions are not allowed to
+     * have a different C name.
+     *
+     * @param prefix The prefix string which should be adde to the C name.
+     */
+    public void createUniqueCName(String prefix) {
+        cName = prefix + name;
+    }
+
+    /**
+     * Create the C code representation for the function.
      *
-     * @return The c-code of the  function implementing this mini-python function.
+     * @return The C code of the  function implementing this mini-python function.
      */
     public String buildCFunction() {
         StringBuilder declaration = new StringBuilder();
 
         // FIXME args and kwargs probably breaks code that does not use the same names
         // for accessing packed arguments
-        declaration.append("__MPyObj* func_" + uniqueName + "(__MPyObj *args, __MPyObj *kwargs) {\n");
+        declaration.append("__MPyObj* func_" + cName + "(__MPyObj *args, __MPyObj *kwargs) {\n");
 
         StringBuilder body = new StringBuilder();
 
@@ -116,7 +132,7 @@ public String buildCFunction() {
     }
 
     /**
-     * Create the c-code for object declaration of this function.
+     * Create the C code for object declaration of this function.
      *
      * @return A mini-python object declaration for this function.
      */
@@ -125,17 +141,17 @@ public String buildFuncObjectDeclaration() {
     }
 
     /**
-     * Create the c-code for initialization of the function's mini-python object.
+     * Create the C code for initialization of the function's mini-python object.
      *
      * @return Initialisation code for this function's mini-python object.
      */
     public String buildInitialisation() {
-        return name + " = __mpy_obj_init_func(&func_" + uniqueName +  ");\n" +
+        return name + " = __mpy_obj_init_func(&func_" + cName +  ");\n" +
                 "__mpy_obj_ref_inc(" + name + ");\n";
     }
 
     /**
-     * Create the c-code for cleaning up the function object.
+     * Create the C code for cleaning up the function object.
      *
      * @return Cleanup code for collecting this function's mini-python object.
      */