public string Visit(FunDef node)
{
var funcName = node.AnchorToken.Lexeme;
currentFunction = funcName;
var sb = new StringBuilder();
//Console.WriteLine(currentFunction);
if (funcName == "main")
{
sb.Append($" (func\n");
sb.Append($" (export \"main\")\n");
}
else
{
sb.Append($" (func ${funcName}\n");
}
sb.Append(Visit((dynamic)node[0]));
sb.Append($" (result i32)\n");
sb.Append($" (local $_temp i32)\n");
sb.Append(Visit((dynamic)node[1]));
sb.Append(Visit((dynamic)node[2]));
if (hasReturn == 0)
{
sb.Append($" i32.const 0\n");
}
sb.Append($" )\n");
hasReturn = 0;
currentFunction = "";
return(sb.ToString());
}
private void AddToStringFun(Type type)
{
if (!type.IsEnum)
{
return;
}
var funName = ToStringFunName(type);
if (FunDefs.ContainsKey(funName))
{
return;
}
var caseExp = new CaseExp(new Id("v"));
foreach (var alt in type.GetEnumNames())
{
caseExp.Cases.Add(new Tuple <ElmAstNode, ElmAstNode>(
new Id(AdtAlternativeName(type, alt)),
new StringLiteral(alt)
));
}
var fun = new FunDef(funName, $"{funName} : {type.Name} -> {Elm.Types.STRING}");
fun.Params.Add("v");
fun.Body = caseExp;
FunDefs.Add(funName, fun);
}
public void Visit(FunDef node)
{
var funcName = node.AnchorToken.Lexeme;
var props = FunTable[funcName];
currentFunction = funcName;
level++;
props.reference = new SortedDictionary <string, string>();
FunTable[funcName] = props;
Visit((dynamic)node[0]);
Visit((dynamic)node[1]);
/*
* foreach (var entry in FunTable[funcName].reference) {
* Console.WriteLine(entry);
* }
* Console.WriteLine("");
*/
Visit((dynamic)node[2]);
level--;
}
public string Visit(FunDef node)
{
insideFunction = true;
localVariables = new SymbolTable();
var temp1 = " ";
var temp2 = " ";
parameters = new FunctionTable();
var ind = 0;
foreach (var n in node[0])
{
parameters[n.AnchorToken.Lexeme] = ind;
temp1 += "int32,";
temp2 += Line(Indent() + ".locals init (int32 '" + n.AnchorToken.Lexeme + "')");
localVariables.Add(n.AnchorToken.Lexeme);
ind++;
}
var result = Line(Indent() + ".method public static int32 '" + node.AnchorToken.Lexeme + "'(" + temp1.Substring(0, temp1.Length - 1) + ") {");
indentCounter++;
if (node.AnchorToken.Lexeme == "main")
{
result += Line(Indent() + ".entrypoint");
}
result += temp2
+ Visit((dynamic)node[1])
+ Visit((dynamic)node[2])
+ Line(Indent() + "ldc.i4.0")
+ Line(Indent() + "ret");
indentCounter--;
insideFunction = false;
return(result + Line(Indent() + "}") + Line(Indent()));
}
public Node FunDef()
{
//‹id›(‹id-list›?){‹var-def›* ‹stmt-list›*}
var n = new FunDef()
{
AnchorToken = Expect(TokenCategory.IDENTIFIER)
};
Expect(TokenCategory.OPENEDPAR);
//if(CurrentToken != TokenCategory.CLOSEDPAR){
n.Add(IdList());
//}
Expect(TokenCategory.CLOSEDPAR);
Expect(TokenCategory.OPENEDCURLY);
//while(CurrentToken == TokenCategory.VAR){
//n.Add(VarDef());
//}
n.Add(VarDefList());
//if(firstOfStmt.Contains(CurrentToken)){
n.Add(StmtList());
//}
Expect(TokenCategory.CLOSEDCURLY);
return(n);
}
//-----------------------------------------------------------
//<funDef>//
public void Visit(FunDef node, int i)
{
//visits id
Visit((dynamic)node[0], 2);
//visits param list
Visit((dynamic)node[1], 3);
}
public void AddEncodeFun(Type type)
{
var funName = EncodeFunName(type);
if (FunDefs.ContainsKey(funName))
{
return;
}
var f = new FunDef(funName, $"{funName} : {type.Name} -> {Elm.Types.ENCODER_VALUE}");
f.Params.Add("v");
if (type.IsEnum)
{
var encodeApp = new FunApp(new Id(Elm.Encoders.STRING))
{
Rands = { new FunApp(new Id(ToStringFunName(type)))
{
Rands ={ new Id("v") }
} }
};
f.Body = encodeApp;
}
else
{
var fieldTups = new List <ElmAstNode>();
foreach (var prop in type.GetProperties(PROP_FLAGS))
{
var jsonAttrs = prop.GetCustomAttributes(typeof(JsonPropertyAttribute));
if (jsonAttrs.FirstOrDefault() is JsonPropertyAttribute jsonAttr)
{
var jsonFieldName = jsonAttr.PropertyName ?? SnakeCase(prop.Name);
var keyExp = new StringLiteral(jsonFieldName);
var valExp = new FunApp(new Id(EncodeFunName(prop.PropertyType)))
{
Rands =
{
new Id($"v.{ElmRecordFieldName(prop)}")
}
};
fieldTups.Add(new TupleExp(keyExp, valExp));
}
}
f.Body = new FunApp(
new Id(Elm.Encoders.OBJECT),
new ListExp(fieldTups.ToArray())
);
}
FunDefs.Add(funName, f);
}
//-----------------------------------------------------------
//<funDef>//
public void Visit(FunDef node)
{
//visits id
Visit((dynamic)node[0], 'f');
//visits param list
parameterCounter = 0;
Visit((dynamic)node[1], 'p');
//visits var def list
Visit((dynamic)node[2], 'v');
//visits stmt list
Visit((dynamic)node[3], 's');
}
public void Visit(FunDef node)
{
var funcName = node.AnchorToken.Lexeme;
if (FunTable.ContainsKey(funcName))
{
throw new SemanticError(
"Duplicated function: " + funcName,
node.AnchorToken);
}
else
{
var arity = node[0].Size();
FunTable[funcName] = new FuncProperties(false, arity, null);
}
}
public Node FunDef()
{
var funToken = Expect(TokenCategory.IDENTIFIER);
Expect(TokenCategory.PARENTHESIS_OPEN);
var parList = ParamList();
Expect(TokenCategory.PARENTHESIS_CLOSE);
Expect(TokenCategory.BRACKET_OPEN);
var varDList = VarDefList();
var statementList = StmtList();
Expect(TokenCategory.BRACKET_CLOSE);
var result = new FunDef()
{
parList, varDList, statementList
};
result.AnchorToken = funToken;
return(result);
}
//<fundef>//
public Node FunDef()
{
var result = new FunDef();
result.Add(new Identifier()
{
AnchorToken = Expect(TokenCategory.IDENTIFIER)
});
Expect(TokenCategory.PARENTHESIS_OPEN);
result.Add(ParamList());
Expect(TokenCategory.PARENTHESIS_CLOSE);
Expect(TokenCategory.CURLY_BRACKET_OPEN);
result.Add(VarDefList());
result.Add(StmtList());
Expect(TokenCategory.CURLY_BRACKET_CLOSE);
return(result);
}
public void Visit(FunDef node)
{
var functionName = node.AnchorToken.Lexeme;
if (firstPass)
{
if (Global_Function_Table.Contains(functionName))
{
throw new SemanticError("Duplicated function: " + functionName, node.AnchorToken);
}
else
{
if (node[0] is IdList)
{
var t = 0;
foreach (var n in node[0])
{
t++;
}
Global_Function_Table[functionName] = t;
}
else
{
Global_Function_Table[functionName] = 0;
}
}
}
else
{
currentNamespaceTable = new SymbolTable();
insideFunction = true;
VisitChildren(node);
localSymbolTables[functionName] = currentNamespaceTable;
insideFunction = false;
currentNamespaceTable = new SymbolTable();
}
}
public void AddDecodeFun(Type type)
{
var funName = DecodeFunName(type);
if (FunDefs.ContainsKey(funName))
{
return;
}
var f = new FunDef(funName, $"{funName} : {Elm.Types.DECODER} {type.Name}");
if (type.IsEnum)
{
var innerFunName = $"{funName}Value";
if (FunDefs.ContainsKey(innerFunName))
{
return;
}
var innerF = new FunDef(innerFunName, $"{innerFunName} : {Elm.Types.STRING} -> {Elm.Types.DECODER} {type.Name}");
innerF.Params.Add("s");
var caseExp = new CaseExp(new Id("s"));
innerF.Body = caseExp;
foreach (var alt in type.GetEnumNames())
{
caseExp.Cases.Add(new Tuple <ElmAstNode, ElmAstNode>(
new StringLiteral(alt),
new FunApp(new Id("Decode.succeed"))
{
Rands = { new Id(AdtAlternativeName(type, alt)) }
}));
}
caseExp.Cases.Add(new Tuple <ElmAstNode, ElmAstNode>(
new Id("_"),
new FunApp(new Id("Decode.fail"))
{
Rands = { new Id("(\"Unknown value: \" ++ s)") }
}));
FunDefs.Add(innerFunName, innerF);
//Outer fun
f.Body = new PipelineExpr()
{
Exprs =
{
new Id(Elm.Decoders.STRING),
new FunApp(new Id(Elm.Decoders.ANDTHEN))
{
Rands = { new Id(innerFunName) }
}
}
};
}
else
{
var pipeline = new PipelineExpr();
pipeline.Exprs.Add(new FunApp(new Id("Decode.succeed"))
{
Rands = { new Id(type.Name) }
});
foreach (var prop in type.GetProperties(PROP_FLAGS))
{
var jsonAttrs = prop.GetCustomAttributes(typeof(JsonPropertyAttribute));
var jsonAttr = jsonAttrs.FirstOrDefault() as JsonPropertyAttribute;
if (null != jsonAttr)
{
var jsonFieldName = jsonAttr.PropertyName ?? SnakeCase(prop.Name);
pipeline.Exprs.Add(new FunApp(new Id("required"))
{
Rands = { new StringLiteral(jsonFieldName), new Id(DecodeFunName(prop.PropertyType)) }
});
}
}
f.Body = pipeline;
}
FunDefs.Add(funName, f);
}
//<funDef>//
public string Visit(FunDef node, int myint)
{
var currentFunc = Visit((dynamic)node[0], 1);
var sb = new StringBuilder();
actualFun = currentFunc;
if (currentFunc != "main")
{
amimain = "no";
sb.Append("\t.method public static int32 '" + currentFunc + "' (");
}
else if (currentFunc == "main")
{
amimain = "yes";
sb.Append("\t.method public static void 'start' (");
}
var functionAttr = functionsT[currentFunc];
var functionContainer = functionAttr.refToFunc;
var mypartFunct = functionContainer.ParticularFunction;
var mykeys = mypartFunct.getkeys();
IDictionary <int, string> paramposlist = new SortedDictionary <int, string>();
foreach (var elitemo in mykeys)
{
var sb2 = new StringBuilder();
var item = mypartFunct[elitemo];
if (item.paramPos > -1)
{
if (item.paramPos == 0)
{
sb2.Append(String.Format("int32 '{0}'", elitemo));
}
else
{
sb2.Append(String.Format(", int32 '{0}'", elitemo));
}
}
if (!paramposlist.ContainsKey(item.paramPos))
{
paramposlist.Add(item.paramPos, sb2.ToString());
}
}
foreach (var xOne in paramposlist)
{
sb.Append(xOne.Value);
}
sb.Append(")\n\t{\n");
if (currentFunc == "main")
{
sb.Append("\t\t.entrypoint\n");
sb.Append("\t\t.maxstack " + mymaxstackval * 5 + "\n");
}
else
{
sb.Append("\t\t.maxstack " + mymaxstackval * 5 + "\n");
}
foreach (var elitemo in mykeys)
{
var item = mypartFunct[elitemo];
if (item.paramPos <= -1)
{
sb.Append(String.Format(
"\t\t.locals init ({0} '{1}')\n",
myType,
elitemo)
);
}
}
sb.Append("\t\n" + Visit((dynamic)node[3]) + "\n");
if (currentFunc == "main" || mycoolReturn != 1)
{
if (mycoolReturn != 1)
{
sb.Append("\t\tldc.i4.0\n");
}
if (amimain.Equals("yes") && mycoolReturn != 1)
{
sb.Append("\t\tcall void class ['mscorlib']'System'.'Environment'::'Exit'(int32)\n");
}
if (mycoolReturn != 1)
{
sb.Append("\t\tret\n");
}
}
sb.Append("\t}\n");
mycoolReturn = 0;
amimain = "no";
actualFun = "";
return(sb.ToString());
}
