Nie możesz wybrać więcej, niż 25 tematów
Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
229 wiersze
6.8 KiB
229 wiersze
6.8 KiB
#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("parsimonyLibrary/boot.mc")
|
|
|
|
@{
|
|
|
|
rmSemi(x) {
|
|
x.semicolon = null;
|
|
x;
|
|
}
|
|
|
|
makeln(x, tabs) {
|
|
x.semicolon.comment = newComment("\n");
|
|
nbTabs = 0;
|
|
if (tabs != null) { nbTabs = tabs; }
|
|
for (i = 0; i<tabs; i++) {
|
|
x.semicolon.comment.text = string(x.semicolon.comment.text) + " ";
|
|
}
|
|
x;
|
|
}
|
|
|
|
program.objects = {};
|
|
program.objects.class = {};
|
|
program.objects.methods = {};
|
|
program.objects.send = {};
|
|
program.objects.send.object = {};
|
|
program.objects.send.method = {};
|
|
sendLen = -1;
|
|
sw = 0;
|
|
|
|
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)
|
|
{
|
|
treeCopy(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] = treeCopy(`declaration int class; );
|
|
program.objects.function = "none";
|
|
return s;
|
|
}
|
|
/*********** Method function ************/
|
|
if (program.objects.function == "method") {
|
|
intern(program.objects.methods, string(program.last.declarators.declarators.identifier));
|
|
for (i in program.objects.class) {
|
|
if (string(i) == string(program.objects.currentClassName)) intern(program.objects.class[i], string(program.last.declarators.declarators.identifier));
|
|
}
|
|
program.last.declarators.declarators.identifier = string(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, treeCopy(param));
|
|
} else {
|
|
s.declarators.paramTypeL = {};
|
|
s.declarators.paramTypeL[0] = treeCopy(param);
|
|
}
|
|
tmp = {};
|
|
// @@ problem for variable changement
|
|
tmp[0] = makeln(`declaration struct @@(newId(string(program.objects.currentClassName), " ")) *self = (struct @@(newId(string(program.objects.currentClassName))) *) __self;, 1);
|
|
s.compoundS.expression = treeCopy(fusion(tmp, s.compoundS.expression));
|
|
program.objects.function = "none";
|
|
return s;
|
|
}
|
|
/*********** Constructor function ************/
|
|
if (program.objects.function == "constructor") {
|
|
rawDeclaration = makeln(`declaration class = findClass(@@(newText("\"" + string(program.objects.currentClassName) + "\"")));, 1);
|
|
t = {};
|
|
append(t, treeCopy(makeln(`declaration struct @@(newId(string(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.class) {
|
|
className = string(i); // can't work other way
|
|
append(t, treeCopy(makeln(`declaration int @@(newId("_class_" + className)) = findClass(@@(newId("\"" + className + "\"")));, 1)));
|
|
for (k in program.objects.class[i]) {
|
|
linkedMethod = string(program.objects.class[i][k]);
|
|
append(t, treeCopy(makeln(`declaration int @@(newId("_selector_" + linkedMethod)) = findSelector(@@(newId("\"" + linkedMethod + "\"")));, 1)));
|
|
castMethod = "(method_t) " + string(i) + "_" + string(program.objects.class[i][k]);
|
|
append(t, treeCopy(makeln(`declaration addMethod(@@(newId("_class_" + className)), @@(newId("_selector_" + linkedMethod)), @@(newId(castMethod)));, 1)));
|
|
}
|
|
}
|
|
s.compoundS.expression = fusion(t, s.compoundS.expression);
|
|
return s;
|
|
}
|
|
s;
|
|
}
|
|
|
|
nil;
|
|
}
|