Update ccmeta.leg

Add a file containing the order of the _DO

.gitignore

@@ -4,3 +4,10 @@
 tests-c/*.otags
 tests-c/*.tags
 tests-c/*.expected
+*.out
+*tmp*
+
+ccmeta
+ccmeta.c
+
+.vscode/

AUTHORS

@@ -11,3 +11,8 @@ Mahe Tardy (2020)
 
 Nathan Razafimanantsoa, Kumar Mahadayya (2021)
 	C AST
+
+Theo Souchon (2022-2023)
+    metalanguage features, development, tests, examples
+    grammar, object system changes for metalanguage
+    source and repository reorganisation

README.md

@@ -1,3 +0,0 @@
-# ccmeta
-
-C compiler with embedded metalanguage.

README.md

@@ -0,0 +1 @@
+doc/README.md

doc/README.md

@@ -0,0 +1,96 @@
+# CCMETA
+
+C compiler with embedded metalanguage.
+
+## <div id="toc">Table of contents<div>
+1. [Architecture](#ar)
+2. [Build the project](#bp)
+   - [Requirements](#ar)
+   - [Makefile](#makefile)
+     - [Build](#makefile_Build)
+     - [Clean](#makefile_Clean)
+     - [Test](#makefile_Test)
+3. [Usage](#usage)
+4. [Help](#help)
+   - [Peg/Leg](#pegleg)
+5. [Authors](#authors)
+
+
+## <div id="ar">Architecture<div>
+![alt text](doc/ccmeta.drawio.png)
+### [Go to the table of contents](#toc)
+
+## <div id="bp">Build the project<div>
+### <div id="req">Requirements<div>
+
+Please install [peg/leg](https://www.piumarta.com/software/peg/) manually or with a package manager, for example with Homebrew: 
+```bash
+$ brew install peg
+```
+
+Please install [the Boehm-Demers-Weiser conservative garbage collector](https://www.hboehm.info/gc/) manually or with a package manager, for example with Homebrew:
+```bash
+$ brew install bdw-gc
+```
+
+### <div id="makefile"> Makefile<div>
+>Compatible with the homebrew installed on the apple silicon ship
+
+#### <div id="makefile_Build">Build<div>
+```bash
+$ make
+```
+
+#### <div id="makefile_Clean">Clean<div>
+```bash
+$ make clean
+```
+
+#### <div id="makefile_Test">Test <div>
+```bash
+$ make test
+```
+### [Go to the table of contents](#toc)
+
+## <div id="usage">Usage<div>
+### How it works
+You can pass your program:
+* via an input file
+```bash
+$ ./ccmeta < file
+```
+* via a file
+```bash
+$ ./ccmeta file
+```
+### **Check each test file to get an idea of how parsimony works**
+### [Go to the table of contents](#toc)
+
+## <div id="help">Help<div>
+
+### <div id="pegleg">peg/leg<div>
+
+``` shell
+$ man peg
+```
+### [Go to the table of contents](#toc)
+
+## <div id="authors">Authors<div>
+#### Ian Piumarta (2016-)
+- infrastructure
+- parsing framework
+- C grammar, C AST
+- object system design and implementation
+- metalanguage design and implementation
+
+#### Mahe Tardy (2020)
+- object system implementation
+- metalanguage implementation
+
+#### Nathan Razafimanantsoa, Kumar Mahadayya (2021)
+- C AST
+
+#### Theo Souchon (2022-2023)
+- metalanguage features, development, tests, examples
+- grammar, object system changes for metalanguage
+- source and repository reorganisation

examples/projectExample

@@ -0,0 +1,3 @@
+enum foo { Closed = 0, ReadOnly = 1, WriteOnly = 2 };
+
+static char *stateNames[] = { "Closed", "ReadOnly", "WriteOnly"};

examples/projectExample.c

@@ -0,0 +1,19 @@
+@{
+  mapast(f, seq)
+  {
+    out = {};
+    for (i in seq) {
+      e = seq[i];
+      out[length(out)] = e.__proto__ != Token ? f(e) : e ;
+    }
+    out;
+  }
+
+  idToString(x) { { __proto__: C_string, value: "\"" + string(x.name.identifier) + "\"" } }
+
+  nil;
+}
+
+enum foo { Closed = 0, ReadOnly = 1, WriteOnly = 2 };
+
+static char *stateNames[] = { @(mapast(idToString, program.last.enumList)) };

examples/realObjectED

@@ -0,0 +1,149 @@
+// This example serves to illustrate the possibility 
+// of adding the object aspect to C 
+// using the everyExternalDeclaration function. 
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct Symbol {
+  char *name;
+  int class, selector;
+};
+
+struct Symbol *newSymbol(char *name)
+{
+  struct Symbol *symbol = malloc(sizeof(*symbol));
+  symbol->name = strdup(name);
+  symbol->class = 0;
+  symbol->selector = 0;
+  return symbol;
+}
+
+struct Symbol **symbols = 0;
+int nSymbols = 0;
+
+struct Symbol *intern(char *name)
+{
+  int lo = 0; 
+  int hi = nSymbols - 1;
+  while (lo <= hi ) {
+    int mid = (lo+hi)/2;
+    int cmp = strcmp(name, symbols[mid]->name);
+    if (cmp > 0) lo = mid + 1;
+    else if (cmp < 0) hi = mid - 1;
+    else return symbols[mid];
+  }
+  symbols = realloc(symbols, sizeof(*symbols) * ++nSymbols);
+  memmove(symbols + lo + 1, symbols + lo, sizeof(*symbols)*(nSymbols - lo - 1));
+  return symbols[lo] = newSymbol(name);
+}
+
+typedef void *(*method_t)();
+
+void *method_dnu()
+{
+  printf("method not found\n");
+  exit(1);
+  return 0;
+}
+
+method_t **methods = 0; 
+int nClasses    = 0;
+int nSelectors  = 0;
+
+int ensureClass(struct Symbol *symbol)
+{
+  if (symbol->class == 0) {
+    if (nClasses == 0) nClasses++;
+    symbol->class = nClasses++;
+    methods = realloc(methods, sizeof(*methods)*nClasses);
+    methods[symbol->class] = malloc(sizeof(*methods)*nSelectors);
+    for (int i = 0; i<nSelectors; ++i)
+      methods[symbol->class][i] = method_dnu;
+  }
+  return symbol->class;
+}
+
+int ensureSelector(struct Symbol *symbol)
+{
+  if (symbol->selector == 0) {
+    if (nSelectors == 0) nSelectors++;
+    symbol->selector = nSelectors++;
+    for (int i = 0; i<nClasses; ++i) {
+      methods[i] = realloc(methods[i], sizeof(**methods)*nSelectors);
+      methods[i][nSelectors-1] = method_dnu;
+    }
+  }
+  return symbol->selector;
+}
+
+int findClass(char *class)
+{
+  return ensureClass(intern(class));
+}
+
+int findSelector(char *selector)
+{
+  return ensureSelector(intern(selector));
+}
+
+void addMethod(int class, int selector, method_t method)
+{
+  methods[class][selector] = method; 
+}
+
+#define lookup(C, S) (methods[C][S])
+
+struct Object {
+  int class;
+};
+
+#define send(R, M, ...) ({ struct Object *__ = (struct Object *)(R); lookup(__->class, _selector_##M)(__, ##__VA_ARGS__); })
+
+struct __oop { int class; };
+
+typedef struct __oop *oop;
+
+#include <math.h>
+
+struct Point { int class; double x, y; };
+
+oop newPoint(double x, double y)
+{
+  struct Point *self = calloc(1, sizeof *self);
+  self->x = x;
+  self->y = y;
+self->class = findClass("Point");
+  return (struct __oop *) self;
+}
+
+double Point_magnitude(struct __oop *__self) 
+{
+  struct Point *self = (struct Point *) __self;
+  printf("point method : %f\n", sqrt(self->x * self->x * self->y * self->y));
+  return sqrt(self->x * self->x * self->y * self->y);
+}
+
+double Point_getX(struct __oop *__self) 
+{
+  struct Point *self = (struct Point *) __self;
+  printf("point method : %f\n", self->x);
+  return self->x;
+}
+
+int main()
+{
+  int _selector_getX= findSelector("getX");
+  int _selector_magnitude= findSelector("magnitude");
+  int _class_Point= findClass("Point");
+  addMethod(_class_Point, _selector_getX, (method_t) Point_getX);
+  addMethod(_class_Point, _selector_magnitude, (method_t) Point_magnitude);
+  oop p = newPoint(3, 4);
+
+  send(p, magnitude);
+
+  send(p, getX);
+
+  return 0;
+}

examples/realObjectED.c

@@ -0,0 +1,34 @@
+@import("parsimonyLibrary/dynamicObjectExtDecl.mc")
+
+#include <math.h>
+
+@class struct Point { double x, y; };
+
+@constructor("Point") oop newPoint(double x, double y)
+{
+  self->x = x;
+  self->y = y;
+}
+
+@method("Point") double magnitude() 
+{
+  printf("point method : %f\n", sqrt(self->x * self->x * self->y * self->y));
+  return sqrt(self->x * self->x * self->y * self->y);
+}
+
+@method("Point") double getX() 
+{
+  printf("point method : %f\n", self->x);
+  return self->x;
+}
+
+int main()
+{
+  oop p = newPoint(3, 4);
+
+  @send("p", "magnitude");
+
+  @send("p", "getX");
+
+  return 0;
+}

examples/realObjectPF

@@ -0,0 +1,149 @@
+// This example serves to illustrate the possibility 
+// of adding the object aspect to C 
+// using the parseFrom primitive. 
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct Symbol {
+  char *name;
+  int class, selector;
+};
+
+struct Symbol *newSymbol(char *name)
+{
+  struct Symbol *symbol = malloc(sizeof(*symbol));
+  symbol->name = strdup(name);
+  symbol->class = 0;
+  symbol->selector = 0;
+  return symbol;
+}
+
+struct Symbol **symbols = 0;
+int nSymbols = 0;
+
+struct Symbol *intern(char *name)
+{
+  int lo = 0; 
+  int hi = nSymbols - 1;
+  while (lo <= hi ) {
+    int mid = (lo+hi)/2;
+    int cmp = strcmp(name, symbols[mid]->name);
+    if (cmp > 0) lo = mid + 1;
+    else if (cmp < 0) hi = mid - 1;
+    else return symbols[mid];
+  }
+  symbols = realloc(symbols, sizeof(*symbols) * ++nSymbols);
+  memmove(symbols + lo + 1, symbols + lo, sizeof(*symbols)*(nSymbols - lo - 1));
+  return symbols[lo] = newSymbol(name);
+}
+
+typedef void *(*method_t)();
+
+void *method_dnu()
+{
+  printf("method not found\n");
+  exit(1);
+  return 0;
+}
+
+method_t **methods = 0; 
+int nClasses    = 0;
+int nSelectors  = 0;
+
+int ensureClass(struct Symbol *symbol)
+{
+  if (symbol->class == 0) {
+    if (nClasses == 0) nClasses++;
+    symbol->class = nClasses++;
+    methods = realloc(methods, sizeof(*methods)*nClasses);
+    methods[symbol->class] = malloc(sizeof(*methods)*nSelectors);
+    for (int i = 0; i<nSelectors; ++i)
+      methods[symbol->class][i] = method_dnu;
+  }
+  return symbol->class;
+}
+
+int ensureSelector(struct Symbol *symbol)
+{
+  if (symbol->selector == 0) {
+    if (nSelectors == 0) nSelectors++;
+    symbol->selector = nSelectors++;
+    for (int i = 0; i<nClasses; ++i) {
+      methods[i] = realloc(methods[i], sizeof(**methods)*nSelectors);
+      methods[i][nSelectors-1] = method_dnu;
+    }
+  }
+  return symbol->selector;
+}
+
+int findClass(char *class)
+{
+  return ensureClass(intern(class));
+}
+
+int findSelector(char *selector)
+{
+  return ensureSelector(intern(selector));
+}
+
+void addMethod(int class, int selector, method_t method)
+{
+  methods[class][selector] = method; 
+}
+
+#define lookup(C, S) (methods[C][S])
+
+struct Object {
+  int class;
+};
+
+#define send(R, M, ...) ({ struct Object *__ = (struct Object *)(R); lookup(__->class, _selector_##M)(__, ##__VA_ARGS__); })
+
+struct __oop { int class; };
+
+typedef struct __oop *oop;
+
+#include <math.h>
+
+struct Point { int class; double x, y; };
+
+oop newPoint(double x, double y)
+{
+  struct Point *self = calloc(1, sizeof *self);
+  self->x = x;
+  self->y = y;
+self->class = findClass("Point");
+  return (struct __oop *) self;
+}
+
+double Point_magnitude(struct __oop *__self) 
+{
+  struct Point *self = (struct Point *) __self;
+  printf("point method : %f\n", sqrt(self->x * self->x * self->y * self->y));
+  return sqrt(self->x * self->x * self->y * self->y);
+}
+
+double Point_getX(struct __oop *__self) 
+{
+  struct Point *self = (struct Point *) __self;
+  printf("point method : %f\n", self->x);
+  return self->x;
+}
+
+int main()
+{
+  int _selector_getX= findSelector("getX");
+  int _selector_magnitude= findSelector("magnitude");
+  int _class_Point= findClass("Point");
+  addMethod(_class_Point, _selector_getX, (method_t) Point_getX);
+  addMethod(_class_Point, _selector_magnitude, (method_t) Point_magnitude);
+  oop p = newPoint(3, 4);
+
+  // @send p magnitude();
+  
+  // @send p getX();
+
+  return 0;
+}

examples/realObjectPF.c

@@ -0,0 +1,34 @@
+@import("parsimonyLibrary/dynamicObjectParsFrom.mc")
+
+#include <math.h>
+
+@class struct Point { double x, y; };
+
+@constructor Point oop newPoint(double x, double y)
+{
+  self->x = x;
+  self->y = y;
+}
+
+@method Point double magnitude() 
+{
+  printf("point method : %f\n", sqrt(self->x * self->x * self->y * self->y));
+  return sqrt(self->x * self->x * self->y * self->y);
+}
+
+@method Point double getX() 
+{
+  printf("point method : %f\n", self->x);
+  return self->x;
+}
+
+int main()
+{
+  oop p = newPoint(3, 4);
+
+  // @send p magnitude();
+  
+  // @send p getX();
+
+  return 0;
+}

Makefile → src/Makefile

@@ -1,5 +1,5 @@
-CFLAGS = -I/opt/local/include -std=gnu99 -Wall -Wno-unused-label -Wno-unused-function -g
-LDLIBS = -L/opt/local/lib -lgc -lm
+CFLAGS = -I/opt/local/include -I/opt/homebrew/include -std=gnu99 -Wall -Wno-unused-label -Wno-unused-function -g
+LDLIBS = -L/opt/local/lib -L/opt/homebrew/lib -lgc -lm
 TREE = -t
 
 MAIN = ccmeta
@@ -39,6 +39,8 @@ $(MAIN) : $(MAIN).c object.c buffer.h
 clean : .FORCE
 	rm -f $(MAIN) $(MAIN).c
 	rm -f *~ $(MAIN)-output.out
+	rm -rf */*.out
+	rm -rf ccmeta.dSYM
 
 tidy : .FORCE
 	rm -f *~ $(MAIN)-tree.out

object.c → src/object.c

@@ -89,6 +89,7 @@ struct Undefined {
     type_t type;
 };
 
+
 struct Integer {
     type_t type;
     int_t _value;
@@ -427,6 +428,8 @@ int oopcmp(oop a, oop b)
             }
             case String:
                 return strcmp(get(a, String, value), get(b, String, value));
+            case Symbol:
+                return strcmp(get(a, Symbol, name), get(b, Symbol, name));
             default: {
                 intptr_t l= (intptr_t)a, r= (intptr_t)b;
                 if (l < r) return -1;
@@ -545,6 +548,15 @@ oop map_append(oop map, oop value)
     return map_set(map, makeInteger(map_size(map)), value);
 }
 
+oop map_pop(oop map)
+{                                                                   assert(map_isArray(map));
+    size_t size = get(map, Map, size);
+    if (size == 0) return null;
+    oop val = get(map, Map, elements)[--size].value;
+    set(map, Map, size, size);
+    return val;
+}
+
 oop makeArrayFromElement(oop elem, int repeat)
 {
     oop array= makeMapCapacity(repeat);

src/parsimonyLibrary/boot.mc

@@ -0,0 +1,179 @@
+@{
+    // create the function println
+    println(){
+        apply(print, __arguments__);
+        print("\n");
+        __arguments__;
+    }
+
+    __requires__ = {};
+
+    // Import the file
+    require(__fileName__)
+    {
+        if (__requires__[__fileName__] != null)
+        {
+            return __requires__[__fileName__]
+        }
+        import(__fileName__);
+        __requires__[__fileName__] = scope();
+        return scope();
+    }
+
+    // Get the current time in milliseconds
+    millis()
+    {
+        microseconds() / 1000;
+    }
+
+    // Get the last element of s
+    last(s)
+    {
+        s[length(s) - 1];
+    }
+
+    // adding the element e at the end of the list l
+    append(s, e)
+    {
+        s[length(s)] = e;
+    }
+
+    // adding the element e at the end of the list l
+    push(s, e)
+    {
+        append(s, e);
+    }
+
+    // remove the last element of the list s or remove the element e if not null
+    pop(s, e)
+    {
+        if (e == null)
+        {
+            e = length(s) - 1
+        }
+        ret = s[e];
+        t = {};
+        for (i in s)
+        {
+            if (i == e)
+                continue;
+            append(t, s[i]);
+        }
+        s = t;
+        ret;
+    }
+
+    // add or don't change an element in a dictionnary
+    intern(s, e)
+    {
+        lo = 0;
+        hi = length(s) - 1;
+        while (lo <= hi)
+        {
+            mid = (lo + hi) / 2;
+            if (e > s[mid])
+                lo = mid + 1;
+            else if (e < s[mid])
+                hi = mid - 1;
+            else
+                return e;
+        }
+        for (i = length(s); i > lo; i = i - 1)
+        {
+            s[i] = s[i - 1];
+        }
+        return s[lo] = e;
+    }
+
+    // merge the two list s1 and s2
+    fusion(s1, s2)
+    {
+        for (i in s2)
+        {
+            append(s1, s2[i]);
+        }
+        return s1;
+    }
+
+    // If g then we add a filter on the application of the function f to each element of seq
+    map(f, seq, g)
+    {
+        out = {};
+        if (!g) g = (){ 1 };
+        for (i in seq) {
+            e = seq[i];
+            out[length(out)] = g(e) ? f(e) : e ;
+        }
+        out;
+    }
+
+    notToken(x){x.__proto__ != Token}
+
+    // Select element e of s if the the result of the application of f on e is true
+    select(f, s)
+    {
+        out = {};
+        for (i in s)
+        {
+            e = s[i];
+            if (f(e))
+            {
+                append(out, e);
+            }
+        }
+        out;
+    }
+
+    // Select element e of s if the the result of the application of f on e is false
+    reject(f, s)
+    {
+        out = {};
+        for (i in s)
+        {
+            e = s[i];
+            if (!f(e))
+            {
+                append(out, e);
+            }
+        }
+        out;
+    }
+
+    //------------ C structure ------------//
+
+    newId(x, comm)
+    {
+        if (comm == null)
+        {
+            {identifier : x, __proto__ : C_id};
+        }
+        else
+        {
+            {identifier : x, comment : {text : comm, __proto__ : Comment}, __proto__ : C_id};
+        }
+    }
+
+    newText(x) { {value : x, __proto__ : C_string}; }
+
+    newComment(com) { {text : com, __proto__ : Comment}; }
+
+    newToken(txt, com)
+    {
+        if (com == null) return {text : txt, comment : newComment(""), __proto__ : Token};
+        {text : txt, comment : newComment(com), __proto__ : Token};
+    }
+
+    newSemicolon(com){newToken(";", com)}
+
+    newComma() { newToken(",", " "); }
+
+    newStar(com) { newToken("*", com); }
+
+    newBinary(com) { newToken("=", com); }
+
+    newEnum(x) { {attributeL : null, expression : null, name : newId(x), __proto__ : C_enum}; }
+
+    //-------------------- end ---------------------//
+
+    nil;
+}

src/parsimonyLibrary/dynamicObject.c

@@ -0,0 +1,134 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct Symbol {
+  char *name;
+  int class, selector;
+};
+
+struct Symbol *newSymbol(char *name)
+{
+  struct Symbol *symbol = malloc(sizeof(*symbol));
+  symbol->name = strdup(name);
+  symbol->class = 0;
+  symbol->selector = 0;
+  return symbol;
+}
+
+struct Symbol **symbols = 0;
+int nSymbols = 0;
+
+struct Symbol *intern(char *name)
+{
+  int lo = 0; 
+  int hi = nSymbols - 1;
+  while (lo <= hi ) {
+    int mid = (lo+hi)/2;
+    int cmp = strcmp(name, symbols[mid]->name);
+    if (cmp > 0) lo = mid + 1;
+    else if (cmp < 0) hi = mid - 1;
+    else return symbols[mid];
+  }
+  symbols = realloc(symbols, sizeof(*symbols) * ++nSymbols);
+  memmove(symbols + lo + 1, symbols + lo, sizeof(*symbols)*(nSymbols - lo - 1));
+  return symbols[lo] = newSymbol(name);
+}
+
+typedef void *(*method_t)();
+
+void *method_dnu()
+{
+  printf("method not found\n");
+  exit(1);
+  return 0;
+}
+
+method_t **methods = 0; 
+int nClasses    = 0;
+int nSelectors  = 0;
+
+int ensureClass(struct Symbol *symbol)
+{
+  if (symbol->class == 0) {
+    if (nClasses == 0) nClasses++;
+    symbol->class = nClasses++;
+    methods = realloc(methods, sizeof(*methods)*nClasses);
+    methods[symbol->class] = malloc(sizeof(*methods)*nSelectors);
+    for (int i = 0; i<nSelectors; ++i)
+      methods[symbol->class][i] = method_dnu;
+  }
+  return symbol->class;
+}
+
+int ensureSelector(struct Symbol *symbol)
+{
+  if (symbol->selector == 0) {
+    if (nSelectors == 0) nSelectors++;
+    symbol->selector = nSelectors++;
+    for (int i = 0; i<nClasses; ++i) {
+      methods[i] = realloc(methods[i], sizeof(**methods)*nSelectors);
+      methods[i][nSelectors-1] = method_dnu;
+    }
+  }
+  return symbol->selector;
+}
+
+int findClass(char *class)
+{
+  return ensureClass(intern(class));
+}
+
+int findSelector(char *selector)
+{
+  return ensureSelector(intern(selector));
+}
+
+void addMethod(int class, int selector, method_t method)
+{
+  methods[class][selector] = method; 
+}
+
+#define lookup(C, S) (methods[C][S])
+
+struct Object {
+  int class;
+};
+
+void *Object_print()
+{
+  printf("Object\n");
+  return 0; 
+}
+
+struct Point {
+  int class;
+  double x, y;
+};
+
+void *Point_print(struct Point *self) 
+{
+  printf("Point(%f, %f)\n", self->x, self->y);
+  return 0;
+}
+
+#define send(R, M, ...) ({ struct Object *__ = (struct Object *)(R); lookup(__->class, _selector_##M)(__, ##__VA_ARGS__); })
+
+int main()
+{
+  int _selector_print = findSelector("print"  );
+  int _class_object   = findClass   ("Object" );
+  int _class_point    = findClass   ("Point"  );
+
+  addMethod(_class_object, _selector_print, Object_print);
+  struct Object *o = calloc(1, sizeof(*o));
+  o->class = _class_object; 
+  send(o, print);
+
+  addMethod(_class_point, _selector_print, Point_print);
+  struct Point *p = calloc(1, sizeof(*p));
+  p->class = _class_point;
+  send(p, print);
+  
+  return 0;
+}

src/parsimonyLibrary/dynamicObjectExtDecl.mc

@@ -0,0 +1,233 @@
+// This example serves to illustrate the possibility 
+// of adding the object aspect to C 
+// using the everyExternalDeclaration function. 
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct Symbol {
+  char *name;
+  int class, selector;
+};
+
+struct Symbol *newSymbol(char *name)
+{
+  struct Symbol *symbol = malloc(sizeof(*symbol));
+  symbol->name = strdup(name);
+  symbol->class = 0;
+  symbol->selector = 0;
+  return symbol;
+}
+
+struct Symbol **symbols = 0;
+int nSymbols = 0;
+
+struct Symbol *intern(char *name)
+{
+  int lo = 0; 
+  int hi = nSymbols - 1;
+  while (lo <= hi ) {
+    int mid = (lo+hi)/2;
+    int cmp = strcmp(name, symbols[mid]->name);
+    if (cmp > 0) lo = mid + 1;
+    else if (cmp < 0) hi = mid - 1;
+    else return symbols[mid];
+  }
+  symbols = realloc(symbols, sizeof(*symbols) * ++nSymbols);
+  memmove(symbols + lo + 1, symbols + lo, sizeof(*symbols)*(nSymbols - lo - 1));
+  return symbols[lo] = newSymbol(name);
+}
+
+typedef void *(*method_t)();
+
+void *method_dnu()
+{
+  printf("method not found\n");
+  exit(1);
+  return 0;
+}
+
+method_t **methods = 0; 
+int nClasses    = 0;
+int nSelectors  = 0;
+
+int ensureClass(struct Symbol *symbol)
+{
+  if (symbol->class == 0) {
+    if (nClasses == 0) nClasses++;
+    symbol->class = nClasses++;
+    methods = realloc(methods, sizeof(*methods)*nClasses);
+    methods[symbol->class] = malloc(sizeof(*methods)*nSelectors);
+    for (int i = 0; i<nSelectors; ++i)
+      methods[symbol->class][i] = method_dnu;
+  }
+  return symbol->class;
+}
+
+int ensureSelector(struct Symbol *symbol)
+{
+  if (symbol->selector == 0) {
+    if (nSelectors == 0) nSelectors++;
+    symbol->selector = nSelectors++;
+    for (int i = 0; i<nClasses; ++i) {
+      methods[i] = realloc(methods[i], sizeof(**methods)*nSelectors);
+      methods[i][nSelectors-1] = method_dnu;
+    }
+  }
+  return symbol->selector;
+}
+
+int findClass(char *class)
+{
+  return ensureClass(intern(class));
+}
+
+int findSelector(char *selector)
+{
+  return ensureSelector(intern(selector));
+}
+
+void addMethod(int class, int selector, method_t method)
+{
+  methods[class][selector] = method; 
+}
+
+#define lookup(C, S) (methods[C][S])
+
+struct Object {
+  int class;
+};
+
+#define send(R, M, ...) ({ struct Object *__ = (struct Object *)(R); lookup(__->class, _selector_##M)(__, ##__VA_ARGS__); })
+
+struct __oop { int class; };
+
+typedef struct __oop *oop;
+
+@import("../src/parsimonyLibrary/boot.mc")
+
+@{
+
+  rmSemi(x) {
+    x.semicolon = null;
+    x;
+  }
+
+  makeln(x, tabs, newLine) {
+    x.semicolon.comment = newComment("\n");
+    nbTabs = 0;
+    nbLn = 1;
+    if (tabs != null) { nbTabs = tabs; }
+    if (newLine != null) { nbLn = newLine; }
+    for (i = 1; i<nbLn; i++) {
+      x.semicolon.comment.text = x.semicolon.comment.text + "\n";
+    }
+    for (i = 0; i<tabs; i++) {
+      x.semicolon.comment.text = x.semicolon.comment.text + "  ";
+    }
+    x;
+  }
+
+  program.objects = {};
+  program.objects.class = {};
+  program.objects.methods = {};
+
+  class() 
+  {
+    program.objects.function = "class";
+    nil;
+  }
+
+  method(object_name) 
+  {
+    program.objects.currentClassName = object_name;
+    program.objects.function = "method";
+    nil;
+  }
+
+  constructor(object_name) {
+    program.objects.currentClassName = object_name;
+    program.objects.function = "constructor";
+    nil;
+  }
+
+  send(object, method) 
+  {
+    rmSemi(`declaration send(@@(newText(object)), @@(newText(method))););
+  }
+
+  everyExternalDeclaration(s)
+  {
+/*********** Class function ************/
+    if (program.objects.function == "class") {
+      program.objects.class[program.last.name.identifier] = {};
+      for (i=length(program.last.declarationL); i>0; i--) {
+        program.last.declarationL[i] = program.last.declarationL[i-1];
+      };
+      program.last.declarationL[0] = `declaration int class; ;
+      program.objects.function = "none";
+      return s;
+    }
+/*********** Method function ************/
+    if (program.objects.function == "method") {
+      intern(program.objects.methods, program.last.declarators.declarators.identifier);
+      for (i in program.objects.class) {
+        if (string(i) ==  program.objects.currentClassName) intern(program.objects.class[i], program.last.declarators.declarators.identifier);
+      }
+      program.last.declarators.declarators.identifier = program.objects.currentClassName + "_" + string(program.last.declarators.declarators.identifier);
+      param = rmSemi(`declaration struct __oop *__self;);
+      if (length(s.declarators.paramTypeL) > 0) {
+        append(s.declarators.paramTypeL, newComma());
+        append(s.declarators.paramTypeL, param);
+      } else {
+        s.declarators.paramTypeL = {};
+        s.declarators.paramTypeL[0] = param;
+      }
+      tmp = {};
+      tmp[0] = makeln(`declaration struct @@(newId(program.objects.currentClassName, " ")) *self = (struct @@(newId(program.objects.currentClassName, " ")) *) __self;, 1);
+      s.compoundS.expression = fusion(tmp, s.compoundS.expression);
+      program.objects.function = "none";
+      return s;
+    }
+/*********** Constructor function ************/
+    if (program.objects.function == "constructor") {
+      rawDeclaration = makeln(`declaration class = findClass(@@(newText("\"" + program.objects.currentClassName + "\"")));, 1);
+      t = {};
+      append(t, makeln(`declaration struct @@(newId(program.objects.currentClassName, " ")) *self = calloc(1, sizeof *self);, 1));
+      // take the structure of self->foo
+      lhs = treeCopy(s.compoundS.expression[0].expression.lhs);
+      lhs.rhs = newId("class", " ");
+      // Change foo to Class
+      rawDeclaration.declarators[0].lhs = lhs;
+      // prepare the right object to return
+      append(s.compoundS.expression, rawDeclaration);
+      append(s.compoundS.expression, makeln(`statement return (struct __oop *) self;));
+      s.compoundS.expression = fusion(t, s.compoundS.expression);
+      program.objects.function = "none";
+      return s;
+    }
+/*********** Main function ************/
+    if (s.declarators != null && s.declarators.declarators != null && string(s.declarators.declarators.identifier) == "main") {
+      t = {};
+      for(i in program.objects.methods) {
+          methodName = string(program.objects.methods[i]);
+          append(t, makeln(`declaration int @@(newId("_selector_" + methodName)) = findSelector(@@(newId("\"" + methodName + "\"")));, 1));
+      }
+      for (i in program.objects.class) {
+        className = string(i);
+        append(t, makeln(`declaration int @@(newId("_class_" + className)) = findClass(@@(newId("\"" + className + "\"")));, 1));
+        for (k in program.objects.class[i]) {
+          linkedMethod = string(program.objects.class[i][k]);
+          castMethod   = "(method_t) " + className + "_" + linkedMethod;
+          append(t, makeln(`declaration addMethod(@@(newId("_class_" + className)), @@(newId("_selector_" + linkedMethod)), @@(newId(castMethod)));, 1));
+        }
+      }
+      s.compoundS.expression = fusion(t, s.compoundS.expression);
+      return s;
+    }
+    s;
+  }
+  
+  nil;
+}

src/parsimonyLibrary/dynamicObjectParsFrom.mc

@@ -0,0 +1,221 @@
+// This example serves to illustrate the possibility 
+// of adding the object aspect to C 
+// using the parseFrom primitive. 
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct Symbol {
+  char *name;
+  int class, selector;
+};
+
+struct Symbol *newSymbol(char *name)
+{
+  struct Symbol *symbol = malloc(sizeof(*symbol));
+  symbol->name = strdup(name);
+  symbol->class = 0;
+  symbol->selector = 0;
+  return symbol;
+}
+
+struct Symbol **symbols = 0;
+int nSymbols = 0;
+
+struct Symbol *intern(char *name)
+{
+  int lo = 0; 
+  int hi = nSymbols - 1;
+  while (lo <= hi ) {
+    int mid = (lo+hi)/2;
+    int cmp = strcmp(name, symbols[mid]->name);
+    if (cmp > 0) lo = mid + 1;
+    else if (cmp < 0) hi = mid - 1;
+    else return symbols[mid];
+  }
+  symbols = realloc(symbols, sizeof(*symbols) * ++nSymbols);
+  memmove(symbols + lo + 1, symbols + lo, sizeof(*symbols)*(nSymbols - lo - 1));
+  return symbols[lo] = newSymbol(name);
+}
+
+typedef void *(*method_t)();
+
+void *method_dnu()
+{
+  printf("method not found\n");
+  exit(1);
+  return 0;
+}
+
+method_t **methods = 0; 
+int nClasses    = 0;
+int nSelectors  = 0;
+
+int ensureClass(struct Symbol *symbol)
+{
+  if (symbol->class == 0) {
+    if (nClasses == 0) nClasses++;
+    symbol->class = nClasses++;
+    methods = realloc(methods, sizeof(*methods)*nClasses);
+    methods[symbol->class] = malloc(sizeof(*methods)*nSelectors);
+    for (int i = 0; i<nSelectors; ++i)
+      methods[symbol->class][i] = method_dnu;
+  }
+  return symbol->class;
+}
+
+int ensureSelector(struct Symbol *symbol)
+{
+  if (symbol->selector == 0) {
+    if (nSelectors == 0) nSelectors++;
+    symbol->selector = nSelectors++;
+    for (int i = 0; i<nClasses; ++i) {
+      methods[i] = realloc(methods[i], sizeof(**methods)*nSelectors);
+      methods[i][nSelectors-1] = method_dnu;
+    }
+  }
+  return symbol->selector;
+}
+
+int findClass(char *class)
+{
+  return ensureClass(intern(class));
+}
+
+int findSelector(char *selector)
+{
+  return ensureSelector(intern(selector));
+}
+
+void addMethod(int class, int selector, method_t method)
+{
+  methods[class][selector] = method; 
+}
+
+#define lookup(C, S) (methods[C][S])
+
+struct Object {
+  int class;
+};
+
+#define send(R, M, ...) ({ struct Object *__ = (struct Object *)(R); lookup(__->class, _selector_##M)(__, ##__VA_ARGS__); })
+
+struct __oop { int class; };
+
+typedef struct __oop *oop;
+
+@import("../src/parsimonyLibrary/boot.mc")
+
+@{
+
+  rmSemi(x) {
+    x.semicolon = null;
+    x;
+  }
+
+  makeln(x, tabs, newLine) {
+    x.semicolon.comment = newComment("\n");
+    nbTabs = 0;
+    nbLn = 1;
+    if (tabs != null) { nbTabs = tabs; }
+    if (newLine != null) { nbLn = newLine; }
+    for (i = 1; i<nbLn; i++) {
+      x.semicolon.comment.text = x.semicolon.comment.text + "\n";
+    }
+    for (i = 0; i<tabs; i++) {
+      x.semicolon.comment.text = x.semicolon.comment.text + "  ";
+    }
+    x;
+  }
+
+  program.objects = {};
+  program.objects.class = {};
+  program.objects.methods = {};
+
+  class() 
+  {
+    exp = parseFrom("declaration");
+    program.objects.class[exp.specifiers[0].name.identifier] = {};
+    for (i=length(exp.specifiers[0].declarationL); i>0; i--) {
+      exp.specifiers[0].declarationL[i] = exp.specifiers[0].declarationL[i-1];
+    };
+    exp.specifiers[0].declarationL[0] = `declaration int class; ;
+    exp;
+  }
+
+  method() 
+  {
+    id = string(parseFrom("id").identifier);
+    decl = parseFrom("func");
+    intern(program.objects.methods, decl.declarators.declarators.identifier);
+    for (i in program.objects.class) {
+      if (string(i) ==  id) intern(program.objects.class[i], decl.declarators.declarators.identifier);
+    }
+    decl.declarators.declarators.identifier = id + "_" + string(decl.declarators.declarators.identifier);
+    param = rmSemi(`declaration struct __oop *__self;);
+    if (length(decl.declarators.paramTypeL) > 0) {
+      append(decl.declarators.paramTypeL, newComma());
+      append(decl.declarators.paramTypeL, param);
+    } else {
+      decl.declarators.paramTypeL = {};
+      decl.declarators.paramTypeL[0] = param;
+    }
+    tmp = {};
+    tmp[0] = makeln(`declaration struct @@(newId(id, " ")) *self = (struct @@(newId(id, " ")) *) __self;, 1);
+    decl.compoundS.expression = fusion(tmp, decl.compoundS.expression);
+    program.objects.function = "none";
+    decl;
+  }
+
+  constructor() {
+    id = string(parseFrom("id").identifier);
+    decl = parseFrom("func");
+    rawDeclaration = makeln(`declaration class = findClass(@@(newText("\"" + id + "\"")));, 1);
+    t = {};
+    append(t, makeln(`declaration struct @@(newId(id, " ")) *self = calloc(1, sizeof *self);, 1));
+    // take the structure of self->foo
+    lhs = treeCopy(decl.compoundS.expression[0].expression.lhs);
+    lhs.rhs = newId("class", " ");
+    // Change foo to Class
+    rawDeclaration.declarators[0].lhs = lhs;
+    // prepare the right object to return
+    append(decl.compoundS.expression, rawDeclaration);
+    append(decl.compoundS.expression, makeln(`statement return (struct __oop *) self;));
+    decl.compoundS.expression = fusion(t, decl.compoundS.expression);
+    program.objects.function = "none";
+    decl;
+  }
+
+  // TODO
+  send()
+  {
+    nil;
+  }
+
+  everyExternalDeclaration(s)
+  {
+/*********** Main function ************/
+    if (s.declarators != null && s.declarators.declarators != null && string(s.declarators.declarators.identifier) == "main") {
+      t = {};
+      for(i in program.objects.methods) {
+          methodName = string(program.objects.methods[i]);
+          append(t, makeln(`declaration int @@(newId("_selector_" + methodName)) = findSelector(@@(newId("\"" + methodName + "\"")));, 1));
+      }
+      for (i in program.objects.class) {
+        className     = string(i);
+        append(t, makeln(`declaration int @@(newId("_class_" + className)) = findClass(@@(newId("\"" + className + "\"")));, 1));
+        for (k in program.objects.class[i]) {
+          linkedMethod  = string(program.objects.class[i][k]);
+          castMethod    = "(method_t) " + className + "_" + linkedMethod;
+          append(t, makeln(`declaration addMethod(@@(newId("_class_" + className)), @@(newId("_selector_" + linkedMethod)), @@(newId(castMethod)));, 1));
+        }
+      }
+      s.compoundS.expression = fusion(t, s.compoundS.expression);
+      return s;
+    }
+    s;
+  }
+  
+  nil;
+}

src/protoNumber.txt

@@ -0,0 +1,118 @@
+_DO(Undefined)
+_DO(Integer)
+_DO(Float)
+_DO(String)
+_DO(Symbol)
+_DO(Function)
+_DO(Map)
+_DO(If)
+_DO(While)
+_DO(Do)
+_DO(For)
+_DO(ForIn)
+_DO(Switch)
+_DO(Call)
+_DO(Invoke)
+_DO(Func)
+_DO(Block)
+_DO(Declaration)
+_DO(Assign)
+_DO(Logor)
+_DO(Logand)
+_DO(Bitor)
+_DO(Bitxor)
+_DO(Bitand)
+_DO(Equal)
+_DO(Noteq)
+_DO(Less)
+_DO(Lesseq)
+_DO(Greater)
+_DO(Greatereq)
+_DO(Shleft)
+_DO(Shright)
+_DO(Add)
+_DO(Sub)
+_DO(Mul)
+_DO(Div)
+_DO(Mod)
+_DO(Not)
+_DO(Neg)
+_DO(Com)
+_DO(PreIncVariable)
+_DO(PreIncMember)
+_DO(PreIncIndex)
+_DO(PostIncVariable)
+_DO(PostIncMember)
+_DO(PostIncIndex)
+_DO(PreDecVariable)
+_DO(PreDecMember)
+_DO(PreDecIndex)
+_DO(PostDecVariable)
+_DO(PostDecMember)
+_DO(PostDecIndex)
+_DO(GetVariable)
+_DO(GetMember)
+_DO(SetMember)
+_DO(GetIndex)
+_DO(SetIndex)
+_DO(Return)
+_DO(Break)
+_DO(Continue)
+_DO(Throw)
+_DO(Try)
+_DO(Quote)
+_DO(Quasiquote)
+_DO(Comment)
+_DO(Token)
+_DO(C_declaration)
+_DO(C_string)
+_DO(C_if)
+_DO(C_int)
+_DO(C_float)
+_DO(C_char)
+_DO(C_id)
+_DO(C_while)
+_DO(C_do)
+_DO(C_for)
+_DO(C_binary)
+_DO(C_initializer)
+_DO(C_range)
+_DO(C_conditional)
+_DO(C_index)
+_DO(C_designation)
+_DO(C_attribution)
+_DO(C_deref)
+_DO(C_block)
+_DO(C_call)
+_DO(C_subexpr)
+_DO(C_array)
+_DO(C_parameter)
+_DO(C_typeOf)
+_DO(C_unary)
+_DO(C_prefix)
+_DO(C_alignOf)
+_DO(C_sizeOf)
+_DO(C_cast)
+_DO(C_attributeSpec)
+_DO(C_asm)
+_DO(C_asmExpr)
+_DO(C_asmExprArg)
+_DO(C_aggregate)
+_DO(C_attribute)
+_DO(C_postfix)
+_DO(C_compound)
+_DO(C_functionDef)
+_DO(C_exprStatement)
+_DO(C_switch)
+_DO(C_goto)
+_DO(C_continue)
+_DO(C_break)
+_DO(C_return)
+_DO(C_case)
+_DO(C_default)
+_DO(C_label)
+_DO(C_labelDeclaration)
+_DO(C_structSpec)
+_DO(C_structDeclarator)
+_DO(C_enumSpec)
+_DO(C_enum)