private Value CreateRoutineArgument(Function func, int i, ParamDeclaration param)
{
TypeRef type = GetLLVMType(param.type);
Value alloca = builder.BuildEntryBlockAlloca(func, type, param.name);
builder.BuildStore(func.GetParameter((uint)i), alloca);
Debug.Assert(alloca != null);
valuemap.AddValue(param, alloca);
return(alloca);
}
/// <summary>
/// Finds a declaration (excluding methods) with the specified name
/// </summary>
/// <param name="name">The name of the declaration to search for.</param>
/// <returns>The declaration with the specified name or null if not found.</returns>
public IDeclaration GetDeclaration(string name)
{
// Project
if (Project == null)
{
return(null);
}
IDeclaration superGlobalDeclaration = Project.GetDeclaration(name);
if (superGlobalDeclaration != null)
{
return(superGlobalDeclaration);
}
// Sprite
if (CurrentSprite == null)
{
return(null);
}
ITypedDeclaration globalDeclaration = CurrentSprite.GetDeclaration(name);
if (globalDeclaration != null)
{
return(globalDeclaration);
}
// Methods
if (CurrentScope == null)
{
return(null);
}
// Method params
ParamDeclaration methodParam = (CurrentScope.Method as MethodDeclaration)?.FindParam(name);
if (methodParam != null)
{
return(methodParam);
}
// Scoped variables
return(CurrentScope.Search(name));
}
public Type Visit(ParamDeclaration node)
{
var idList = node[0];
var type = Visit((dynamic)node[1]);
foreach (var n in idList)
{
var name = n.AnchorToken.Lexeme;
if (currentFunctionParamTable.Contains(name))
{
throw new SemanticError(
"Parameter " + name
+ " already exists in function " + localscope,
n.AnchorToken);
}
currentFunctionParamTable[name] = type;
}
return(Type.VOID);
}
public string Visit(ParamDeclaration node)
{
var result = "";
var idList = node[0];
var type = Visit((dynamic)node[1]);
var counter = 0;
foreach (var n in idList)
{
counter++;
var name = n.AnchorToken.Lexeme;
result += CILTypes[type] + " " + name;
if (counter >= globalFunctionTable[localscope])
{
result += "";
}
}
return(result);
}
public void LoadbuiltinDecls()
{
var tfloat = FloatType.Single;
var tint = IntegerType.Single;
var tstring = StringType.Single;
var tarray = ArrayType.Single;
var p = new ParamDeclaration("x", tfloat);
string[] floatFuncs = { "cos", "sin", "trunc", "round", "frac", "exp" };
string[] intordFuncs = { "succ", "pred" };
string[] stringsFuncs = { "writeln", "readln" };
foreach (var s in floatFuncs)
{
CreateBuiltinFunction(new RoutineDeclaration(s, new ParametersSection(
new DeclarationList(new ParamDeclaration("x", tfloat))), tfloat));
}
foreach (var s in intordFuncs)
{
CreateBuiltinFunction(new RoutineDeclaration(s, new ParametersSection(
new DeclarationList(new ParamDeclaration("x", null))), tint));
}
foreach (var s in stringsFuncs)
{
CreateBuiltinFunction(new RoutineDeclaration(s, new ParametersSection(
new DeclarationList(new ParamDeclaration("x", tstring)))));
}
CreateBuiltinFunction(new RoutineDeclaration("assigned", new ParametersSection(
new DeclarationList(new ParamDeclaration("p", PointerType.Single))), BoolType.Single));
CreateBuiltinFunction(new RoutineDeclaration("length", new ParametersSection(
new DeclarationList(new ParamDeclaration("x", tarray))), tint));
var decls = new DeclarationList(new ParamDeclaration("arr", tarray));
decls.Add(new ParamDeclaration("len", tint));
CreateBuiltinFunction(new RoutineDeclaration("setlength", new ParametersSection(decls)));
}
public Node ParamDeclaration()
{
var result = new ParamDeclaration();
var idList = new IdentifierList();
idList.Add(new Identifier()
{
AnchorToken = Expect(TokenCategory.IDENTIFIER)
});
while (CurrentToken != TokenCategory.TWOPOINTS)
{
Expect(TokenCategory.COMA);
idList.Add(new Identifier()
{
AnchorToken = Expect(TokenCategory.IDENTIFIER)
});
}
result.Add(idList);
Expect(TokenCategory.TWOPOINTS);
result.Add(ChimeraType());
Expect(TokenCategory.SEMICOL);
return(result);
}
public virtual T Visit(ParamDeclaration node)
{
Visit((ValueDeclaration)node);
return(traverse(node.init));
}
private IEnumerable <ParamActionDefinition> GenerateParameter(CommandDeclaration command, MethodDefinition newMethod, ParamDeclaration parameter, int parameterIndex, bool isEnumeratePattern, bool isLastParamArray, bool lastParamReturns, List <MethodAction> marshalFromActions, List <MethodAction> marshalMidActions, List <MethodAction> marshalToActions, List <Action <ExpressionBuilder> > marshalledValues, Func <string, Action <ExpressionBuilder> > getHandle, Dictionary <string, Action <ExpressionBuilder> > handleLookup)
{
string paramName = parameter.Name;
var paramType = typeData[parameter.Type.VkName];
string GetMarshalledName(string baseName)
{
return("marshalled" + baseName.TrimStart('@').FirstToUpper());
}
List <ParamActionDefinition> result = new List <ParamActionDefinition>();
if (parameterIndex >= command.HandleParamsCount)
{
if (lastParamReturns && parameterIndex == command.Params.Count() - 2 && isEnumeratePattern)
{
newMethod.MemberActions.Add(new DeclarationAction
{
MemberType = paramType.Name,
MemberName = paramName
});
marshalledValues.Add(AddressOf(Variable(paramName)));
var patternInfo = new MemberPatternInfo();
this.memberPatternRules.ApplyFirst(command.Params, command.Params.Last(), new MemberPatternContext(command.Verb, true, command.Extension, getHandle, command.VkName), patternInfo);
string marshalledName = GetMarshalledName(patternInfo.Interop.Name);
marshalMidActions.Add(new AssignAction
{
Type = AssignActionType.Alloc,
MemberType = patternInfo.InteropFullType.TrimEnd('*'),
TargetExpression = Variable(marshalledName),
LengthExpression = Cast("uint", Variable(paramName))
});
}
else if (lastParamReturns && parameterIndex == command.Params.Count() - 1)
{
if (isLastParamArray)
{
var patternInfo = new MemberPatternInfo();
this.memberPatternRules.ApplyFirst(command.Params, parameter, new MemberPatternContext(command.Verb, true, command.Extension, getHandle, command.VkName), patternInfo);
string marshalledName = GetMarshalledName(patternInfo.Interop.Name);
marshalToActions.Add(new DeclarationAction
{
MemberType = patternInfo.InteropFullType,
MemberName = marshalledName
});
var newMarshalFrom = patternInfo.MarshalFrom.Select(action => action(targetName => Variable("result"), valueName => Variable(GetMarshalledName(valueName)))).ToArray();
if (!isEnumeratePattern)
{
var lengthExpression = newMarshalFrom.OfType <AssignAction>().First(x => x.IsLoop).LengthExpression;
marshalToActions.Add(new AssignAction
{
Type = AssignActionType.Alloc,
MemberType = patternInfo.InteropFullType.TrimEnd('*'),
TargetExpression = Variable(marshalledName),
LengthExpression = lengthExpression
});
}
marshalFromActions.AddRange(newMarshalFrom);
marshalledValues.Add(Variable(marshalledName));
newMethod.ReturnType = patternInfo.ReturnType ?? patternInfo.Public.Single().Type;
}
else
{
var patternInfo = new MemberPatternInfo();
var effectiveParam = new ParamDeclaration
{
Name = parameter.Name,
Type = parameter.Type.Deref(),
Dimensions = parameter.Dimensions,
VkName = parameter.VkName
};
this.memberPatternRules.ApplyFirst(command.Params, effectiveParam, new MemberPatternContext(command.Verb, true, command.Extension, getHandle, command.VkName), patternInfo);
string marshalledName = GetMarshalledName(patternInfo.Interop.Name);
marshalToActions.Add(new DeclarationAction
{
MemberType = patternInfo.InteropFullType,
MemberName = marshalledName
});
marshalFromActions.AddRange(patternInfo.MarshalFrom.Select(action => action(targetName => Variable("result"), valueName => Variable(GetMarshalledName(valueName)))));
marshalledValues.Add(AddressOf(Variable(marshalledName)));
newMethod.ReturnType = patternInfo.Public.Single().Type;
}
}
else
{
var patternInfo = new MemberPatternInfo();
this.memberPatternRules.ApplyFirst(command.Params, parameter, new MemberPatternContext(command.Verb, true, command.Extension, getHandle, command.VkName), patternInfo);
var actionList = marshalToActions;
Func <string, Action <ExpressionBuilder> > getValue = valueName => Variable(valueName);
foreach (var publicMember in patternInfo.Public)
{
result.Add(new ParamActionDefinition
{
Param = new ParamDefinition
{
Name = publicMember.Name,
Comment = publicMember.Comment,
Type = publicMember.Type,
DefaultValue = publicMember.DefaultValue
}
});
}
if (patternInfo.MarshalTo.Any())
{
string marshalledName = patternInfo.Interop.Name;
if (patternInfo.Public.Any())
{
marshalledName = GetMarshalledName(patternInfo.Interop.Name);
}
var newMarshalToActions = patternInfo.MarshalTo.Select(action => action(targetName => Variable(marshalledName), getValue));
var lastParam = command.Params.Last();
bool isLenForLastParam = lastParamReturns && lastParam.Dimensions != null && lastParam.Dimensions.Any(dimension => dimension.Type == LenType.Expression && this.tokenCheck.Check(dimension.Value, parameter.VkName));
if (!isLenForLastParam &&
newMarshalToActions.Count() == 1 &&
newMarshalToActions.First() is AssignAction newAssignAction &&
newAssignAction.Type == AssignActionType.Assign &&
!newAssignAction.IsLoop)
{
marshalledValues.Add(newAssignAction.ValueExpression);
}
else
{
marshalToActions.Add(new DeclarationAction
{
MemberType = patternInfo.InteropFullType,
MemberName = marshalledName
});
marshalledValues.Add(Variable(marshalledName));
actionList.AddRange(newMarshalToActions);
}
}
foreach (var lookup in patternInfo.HandleLookup)
{
handleLookup[lookup.Item1] = lookup.Item2(getValue);
}
}
}
public override bool Visit(ParamDeclaration node)
{
Visit((ValueDeclaration)node);
TraversePrint(node.init);
return(true);
}
public ParamInstruction(ParamDeclaration declaration)
{
Declaration = declaration;
}
