public bool checkUniqueLocalVar(DiagnosticPosition pos, VarSymbol varSymbol, WritableScope scope)
{
if (scope.getSymbolsByName(varSymbol.name, s => (s.kind & Kind.VAR) != 0).Any())
{
log.error(pos, messages.duplicateVar, varSymbol.name);
return(false);
}
return(true);
}
public bool checkUniqueParam(DiagnosticPosition pos, VarSymbol param, Scope scope)
{
if (scope.getSymbolsByName(param.name, LookupKind.NON_RECURSIVE).Any())
{
log.error(pos, messages.duplicateParamName, param.name, scope.owner.name);
return(false);
}
return(true);
}
public bool checkUnique(DiagnosticPosition pos, StructSymbol ssym, WritableScope scope)
{
bool contains = scope.getSymbolsByName(ssym.name, LookupKind.NON_RECURSIVE).Any();
if (contains)
{
log.error(pos, messages.duplicateStructName, ssym.name);
}
return(!contains);
}
public bool checkMainFunction(DiagnosticPosition pos, FuncSymbol main)
{
// Mimic C main function sig: int main(int,char**)
// with long substituting pointer (implying 64bit arch)
if (main.type.ReturnType != symtab.intType ||
main.type.ParameterTypes.Count != 2 ||
main.type.ParameterTypes[0] != symtab.intType ||
main.type.ParameterTypes[1] != symtab.longType)
{
log.error(pos, messages.mainFunctionSig);
return(false);
}
return(true);
}
public OperatorSymbol resolveUnary(DiagnosticPosition pos, Tag tag, Type argType)
{
if (argType.IsError)
{
return(symtab.errorOpSymbol);
}
OperatorSymbol[] variants = this.operators[tag.operatorIndex()];
for (var i = 0; i < variants.Length; i++)
{
OperatorSymbol op = variants[i];
// We check for exact match for unary operators
if (op.type.ParameterTypes[0] == argType.BaseType)
{
return(op);
}
}
log.error(pos, messages.unresolvedUnaryOperator, operatorNames[tag.operatorIndex()], argType);
return(symtab.errorOpSymbol);
}
public OperatorSymbol resolveBinary(DiagnosticPosition pos, Tag tag, Type leftType, Type rightType)
{
if (leftType.IsError || rightType.IsError)
{
return(symtab.errorOpSymbol);
}
OperatorSymbol[] variants = this.operators[tag.operatorIndex()];
for (var i = 0; i < variants.Length; i++)
{
OperatorSymbol op = variants[i];
IList <Type> paramTypes = op.type.ParameterTypes;
// We take numeric promotion into account
if (typings.isAssignableFrom(paramTypes[0], leftType) &&
typings.isAssignableFrom(paramTypes[1], rightType))
{
return(op);
}
}
log.error(pos, messages.unresolvedBinaryOperator, operatorNames[tag.operatorIndex()], leftType, rightType);
return(symtab.errorOpSymbol);
}
