static void TryHandleParameter(TypeData[] fnParams, int i,
CleanupAstNodeStates blockStates,
int startRange, int endRange,
Dictionary<string, TypeData> declarations)
{
var isFunction = blockStates[startRange + 1].Token == TokenKind.OpenParen;
var typeArgument = fnParams[i];
var tmp = typeArgument.Count != 1;
if (tmp)
return;
var argumentType = typeArgument[0].Content;
if (argumentType == TypeNames.Unknown)
return;
var token = blockStates[startRange];
var typeOfParam = declarations.GetTypeOfName(token.Content);
if (typeOfParam == null || typeOfParam.Count != 1)
return;
var paramType = typeOfParam[0].Content;
if (paramType == argumentType)
return;
if (!isFunction && endRange != startRange)
return;
var formatTypes = string.Format("{0}={1}", paramType, argumentType);
FixArgumentType(blockStates, startRange, isFunction, formatTypes);
}
static void SetTypeDataFromType(TypeData typeData, Type paramType)
{
switch (paramType.Name)
{
case "Int32":
AddNodeType(typeData, "int");
break;
case "String":
AddNodeType(typeData, "string");
break;
case "Double":
AddNodeType(typeData, "double");
break;
case "Boolean":
AddNodeType(typeData, TypeNames.Bool);
break;
case "Void":
AddNodeType(typeData, TypeNames.Void);
break;
case "datetime":
AddNodeType(typeData, TypeNames.DateTime);
break;
case "color":
AddNodeType(typeData, TypeNames.Color);
break;
default:
AddNodeType(typeData, TypeNames.Unknown);
break;
}
}
public TypeParameterTable(int length)
{
_paramTypes = new TypeData[length];
for (var i = 0; i < length; i++)
_paramTypes[i] = new TypeData();
ReturnType = new TypeData();
}
public bool Equals(TypeData typeData)
{
if (typeData == null)
return false;
if (TokenList.Count != typeData.TokenList.Count)
return false;
for (var index = 0; index < TokenList.Count; index++)
{
var data = TokenList[index].Content;
var otherData = typeData.TokenList[index].Content;
if (data != otherData)
return false;
}
return true;
}
static void TryHandleParameterNull(TypeData[] fnParams, int i, CleanupAstNodeStates blockStates, int startRange)
{
var token = blockStates[startRange];
var typeParam = fnParams[i];
var tmp = typeParam.Count != 1;
if (tmp)
return;
var paramType = typeParam[0].Content;
if (paramType == TypeNames.Unknown)
return;
switch (typeParam[0].Content)
{
case "double":
token.Token = TokenKind.Float;
token.Content = string.Format("0.0");
break;
case "int":
token.Token = TokenKind.Int;
token.Content = string.Format("0");
break;
}
}
static void TryHandleParameter(TypeData[] fnParams, int i, CleanupAstNodeStates blockStates, int startRange)
{
var token = blockStates[startRange];
var typeParam = fnParams[i];
var tmp = typeParam.Count != 1;
if (tmp)
return;
var paramType = typeParam[0].Content;
if (paramType == TypeNames.Unknown)
return;
var formatType = string.Format("{0}={1}", paramType, token.Token);
switch (formatType)
{
case "double=Int":
var intValue = int.Parse(token.Content);
token.Token = TokenKind.Float;
token.Content = string.Format("{0}.0", intValue);
break;
case "int=Float":
var floatValue = double.Parse(token.Content);
token.Token = TokenKind.Int;
token.Content = string.Format("{0}", (int)floatValue);
break;
case "string=Int":
case "string=Float":
var combinedText = string.Format("\"{0}\"", token.Content);
token.Token = TokenKind.QuotedString;
token.Content = combinedText;
break;
}
}
static void ExtractParameterData(ParseNode parent, Dictionary<string, TypeData> variableTypes)
{
var states = parent.States;
var openParam = 1;
if (states.Count == 2)
return;
if (states.Count == 3)
{
states.RemoveAt(1);
return;
}
var pos = openParam;
do
{
var typeData = new TypeData();
var i = pos;
for (; states[i].Token != TokenKind.Identifier; i++)
{
typeData.AddTypeNode(states[i]);
}
variableTypes[states[i].Content] = typeData;
pos = states.GeNextTokenKind(TokenKind.Comma, pos);
if (pos == 0)
return;
pos++;
} while (true);
}
static void EvaluateDeclaration(ParseNode node, Dictionary<string, TypeData> variableTypes)
{
var states = node.Parent.States;
var typeIndex = states.MappedNodes.IndexOf(node);
if (typeIndex != 0)
return;
var variableNameIndex = states.GeNextTokenKind(TokenKind.Identifier);
if (variableNameIndex == 0)
return;
var variableNode = states[variableNameIndex];
var variableContent = variableNode.Content;
var typeData = new TypeData();
for (var index = typeIndex; index < variableNameIndex; index++)
{
var mappedNode = states[index];
TypeData.ValidateToken(mappedNode);
typeData.AddTypeNode(mappedNode);
}
variableTypes[variableContent] = typeData;
do
{
var assignIndex = states.GeNextTokenKind(TokenKind.Assign, variableNameIndex);
var commaIndex = states.GeNextTokenKind(TokenKind.Comma, variableNameIndex);
var semiColonIndex = states.GeNextTokenKind(TokenKind.Comma, variableNameIndex);
var separatorIndex = Math.Max(commaIndex, semiColonIndex);
variableNameIndex = states.GeNextTokenKind(TokenKind.Identifier, variableNameIndex + 1);
if (assignIndex < variableNameIndex)
continue;
if (variableNameIndex == 0)
return;
variableNode = states[variableNameIndex];
variableContent = variableNode.Content;
variableTypes[variableContent] = typeData;
} while (true);
}
static void AddNodeType(TypeData typeData, string content)
{
typeData.AddTypeNode(TokenKind.TypeName.BuildTokenFromId(content));
}
public static TypeData DefineGlobalVariable(string variableName)
{
var result = new TypeData();
Instance._globalVariables[variableName] = result;
return result;
}
