本文整理汇总了C#中SymbolTable.TypeOfVar方法的典型用法代码示例。如果您正苦于以下问题：C# SymbolTable.TypeOfVar方法的具体用法？C# SymbolTable.TypeOfVar怎么用？C# SymbolTable.TypeOfVar使用的例子？那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类SymbolTable的用法示例。
在下文中一共展示了SymbolTable.TypeOfVar方法的4个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: TypeOfExpr
private Type TypeOfExpr(ParseTreeNode expr, SymbolTable symbolTable)
{
if (expr.Term.Name == "stringLiteral")
{
return typeof(string);
}
if (expr.Term.Name == "number")
{
if (expr.Token.Value is int)
{
return typeof(int);
}
else
{
return typeof(float);
}
}
else if (expr.Term.Name == "binExpr")
{
Type type1 = TypeOfExpr(expr.ChildNodes[0], symbolTable);
Type type2 = TypeOfExpr(expr.ChildNodes[2], symbolTable);
if (type1 == typeof(float) || type2 == typeof(float))
return typeof(float);
return typeof(int);
}
else if (expr.Term.Name == "identifier")
{
string ident = expr.Token.ValueString;
return symbolTable.TypeOfVar(ident);
}
else if (expr.Term.Name == "functionCall")
{
string funcName = expr.ChildNodes[0].Token.ValueString;
if (!this.functionTable.ContainsKey(funcName))
{
throw new System.Exception("undeclared function or procedure '" + funcName + "'");
}
return functionTable[funcName].methodDefinition.ReturnType;
}
else if (expr.Term.Name == "varType")
{
switch (expr.ChildNodes[0].Token.ValueString)
{
case "int":
return typeof(int);
case "real":
return typeof(float);
default:
throw new Exception("Did not recognize type: " + expr.ChildNodes[0].Token.ValueString);
}
}
else
{
throw new System.Exception("don't know how to calculate the type of " + expr.Term.Name);
}
}示例2: GenStmt
private void GenStmt(ParseTreeNode stmt, ILGenerator il, SymbolTable symbolTable, Label? exitScope = null)
{
if (stmt.Term.Name == "program")
{
if (stmt.ChildNodes.Count > 0)
{
this.GenStmt(stmt.ChildNodes[0].ChildNodes[0], il, symbolTable);
this.GenStmt(stmt.ChildNodes[1], il, symbolTable);
}
}
else if (stmt.Term.Name == "variableDeclaration")
{
Type localType;
// declare a local
if (stmt.ChildNodes[2].Term.Name == "typeSpecifier")
{
localType = this.TypeOfTypeDeclaration(stmt.ChildNodes[2].ChildNodes[0]);
}
else
{
localType = TypeOfExpr(stmt.ChildNodes[2].ChildNodes[1], symbolTable);
}
Action<string> generateAssign = null;
ParseTreeNode assign = stmt.ChildNodes.Where(x => x.Term.Name == "setEqual").SingleOrDefault();
// set the initial value
if (assign != null)
{
generateAssign = new Action<string>(name =>
{
this.GenExpr(assign.ChildNodes[1], symbolTable.Locals[name].LocalType, il, symbolTable);
symbolTable.Store(name, TypeOfExpr(assign.ChildNodes[1], symbolTable), il);
});
}
var variableIden = stmt.ChildNodes[1];
while (true)
{
string name = variableIden.ChildNodes[0].Token.ValueString;
symbolTable.AddLocal(name, il.DeclareLocal(localType));
if (generateAssign != null)
generateAssign(name);
if (variableIden.ChildNodes.Count < 2)
break;
variableIden = variableIden.ChildNodes[1];
}
}
else if (stmt.Term.Name == "io")
{
if (stmt.ChildNodes[0].Token.ValueString == "put")
{
//the first argument is always there, until we can build a proper AST this'll have to do
ParseTreeNode argItem = stmt.ChildNodes[1];
this.GenExpr(argItem.ChildNodes[0], typeof(string), il, symbolTable);
il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("Write", new System.Type[] { typeof(string) }));
argItem = stmt.ChildNodes[2];
while (true)
{
if (argItem.ChildNodes.Count == 0)
break;
this.GenExpr(argItem.ChildNodes[0].ChildNodes[0], typeof(string), il, symbolTable);
il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("Write", new System.Type[] { typeof(string) }));
argItem = argItem.ChildNodes[1];
}
if (stmt.ChildNodes[3].ChildNodes.Count == 0)//put a newline character if there is no ...
il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("WriteLine", new System.Type[] { }));
}
else if (stmt.ChildNodes[0].Token.ValueString == "get")
{
foreach (var argument in stmt.ChildNodes[1].ChildNodes)
{
//switch(symbolTable.TypeOfVar(
il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("ReadLine", new System.Type[] { }));
symbolTable.Store(argument.Token.ValueString, typeof(string), il);
}
}
}
else if (stmt.Term.Name == "assignment")
{
if (stmt.ChildNodes[0].Term.Name == "functionCall")//if we see this as a function call, we know that's not true, and it's actually an array (which is kinda the same thing in turing)
{
string arrayName = stmt.ChildNodes[0].ChildNodes[0].Token.ValueString;
if (symbolTable.TypeOfVar(arrayName).IsArray)
{
symbolTable.PushVar(arrayName, il);
if (stmt.ChildNodes[0].ChildNodes[1].ChildNodes.Count > 1)
throw new NotImplementedException("Multi-Dimensional arrays are not yet supported");
this.GenExpr(stmt.ChildNodes[0].ChildNodes[1].ChildNodes[0], typeof(int), il, symbolTable);
this.GenExpr(stmt.ChildNodes[1].ChildNodes[1], TypeOfExpr(stmt.ChildNodes[1].ChildNodes[1], symbolTable), il, symbolTable);
il.Emit(OpCodes.Stelem, symbolTable.TypeOfVar(arrayName).GetElementType());
}
else
throw new NotSupportedException(String.Format("Non-array identifier used like an array: {0}", arrayName));
}
else
{
this.GenExpr(stmt.ChildNodes[1].ChildNodes[1], TypeOfExpr(stmt.ChildNodes[1].ChildNodes[1], symbolTable), il, symbolTable);
string ident = stmt.ChildNodes[0].Token.ValueString;
//.........这里部分代码省略.........
示例3: TypeOfExpr
public static Type TypeOfExpr(ParseTreeNode expr, SymbolTable symbolTable)
{
if (expr.Term.Name == "stringLiteral")
{
return typeof(string);
}
if (expr.Term.Name == "number")
{
if (expr.Token.Value is int)
{
return typeof(int);
}
else
{
return typeof(double);
}
}
else if (expr.Term.Name == "binExpr")
{
//Type type1 = TypeOfExpr(expr.ChildNodes[0], symbolTable);
//Type type2 = TypeOfExpr(expr.ChildNodes[2], symbolTable);
return TypeOfAny(symbolTable, expr.ChildNodes[0], expr.ChildNodes[2]);
//if (type1 == typeof(float) || type2 == typeof(float))
// return typeof(float);
//return typeof(int);
}
else if (expr.Term.Name == "identifier")
{
string ident = expr.Token.ValueString;
return symbolTable.TypeOfVar(ident);
}
else if (expr.Term.Name == "functionCall")
{
string funcName = expr.ChildNodes[0].Token.ValueString;
if (!symbolTable.functionTable.ContainsKey(funcName))
{
//it might be an array, so we should check for that
if (symbolTable.HasVar(funcName) && symbolTable.TypeOfVar(funcName).IsArray)
{
//it is an array, so just return the appropriate type for the array
return symbolTable.TypeOfVar(funcName).GetElementType();
}
else//nope, throw an error
throw new System.Exception("undeclared function or procedure '" + funcName + "'");
}
return symbolTable.functionTable[funcName].methodDefinition.ReturnType;
}
else if (expr.Term.Name == "memberCall")
{
return symbolTable.functionTable[GetIdentifier(expr)].methodDefinition.ReturnType;
}
else if (expr.Term.Name == "varType")
{
switch (expr.ChildNodes[0].Token.ValueString)
{
case "int":
return typeof(int);
case "real":
return typeof(double);
default:
throw new Exception("Did not recognize type: " + expr.ChildNodes[0].Token.ValueString);
}
}
else if (expr.Term.Name == "initExpr")
{
return TypeOfAny(symbolTable, expr.ChildNodes[0].ChildNodes.ToArray()).MakeArrayType();
}
else
{
throw new System.Exception("don't know how to calculate the type of " + expr.Term.Name);
}
}示例4: GenExpr
//.........这里部分代码省略.........
case "div":
il.Emit(OpCodes.Div);
expectedType = typeof(int);
break;
case "mod":
il.Emit(OpCodes.Rem);
break;
default:
throw new Exception("Unrecognized operator " + expr.ChildNodes[1].Term.Name);
}
}
}
else if (expr.Term.Name == "identifier")
{
string ident = expr.Token.ValueString;
symbolTable.PushVar(ident, il);
deliveredType = TypeOfExpr(expr, symbolTable);
if (deliveredType == typeof(float))
{
throw new NotImplementedException();
}
}
else if (expr.Term.Name == "functionCall"|expr.Term.Name=="memberCall")
{
deliveredType = TypeOfExpr(expr, symbolTable);
if (deliveredType == typeof(float))
{
throw new NotImplementedException();
}
string funcName = GetIdentifier(expr);
if (!symbolTable.functionTable.ContainsKey(funcName))
{
if (symbolTable.HasVar(funcName) && symbolTable.TypeOfVar(funcName).IsArray)
{
//this is an array, return the appropriate value
symbolTable.PushVar(funcName, il);
if (expr.ChildNodes[1].ChildNodes.Count > 1)
throw new NotImplementedException("Multi-Dimensional arrays are not yet supported");
this.GenExpr(expr.ChildNodes[1].ChildNodes[0], typeof(int), il, symbolTable);
il.Emit(OpCodes.Stelem, symbolTable.TypeOfVar(funcName).GetElementType());
}
else
throw new System.Exception("undeclared function or procedure '" + funcName + "'");
}
else
{
var parameters = symbolTable.functionTable[funcName].arguments;
int currentArgument = 0;
foreach (var arg in GetArgs(expr))//expr.ChildNodes[1].ChildNodes)
{
this.GenExpr(arg, parameters[currentArgument].argType, il, symbolTable);
currentArgument++;
}
il.Emit(OpCodes.Call, symbolTable.functionTable[funcName].methodDefinition);
}
}
else if (expr.Term.Name == "initExpr")
{
deliveredType = TypeOfAny(symbolTable, expr.ChildNodes[0].ChildNodes.ToArray());
int arraySize = expr.ChildNodes[0].ChildNodes.Count;
//LocalBuilder paramValues = il.DeclareLocal(deliveredType.MakeArrayType());
//paramValues.SetLocalSymInfo("parameters");