public FUNCTION_INFO(string name, TYPE_INFO ret_value,
ArrayList formals)
{
_ret_value = ret_value;
_typeinfo = formals;
_name = name;
}
/// <summary>
/// Recursively check the type and bubble up the type
/// information to the top...
/// </summary>
/// <param name="cont"></param>
/// <returns></returns>
public override TYPE_INFO TypeCheck(COMPILATION_CONTEXT cont)
{
TYPE_INFO eval_left = ex1.TypeCheck(cont);
TYPE_INFO eval_right = ex2.TypeCheck(cont);
if (eval_left != eval_right)
{
throw new Exception("Wrong Type in expression");
}
if (eval_left == TYPE_INFO.TYPE_STRING &&
(!(m_op == RELATION_OPERATOR.TOK_EQ ||
m_op == RELATION_OPERATOR.TOK_NEQ)))
{
throw new Exception("Only == amd != supported for string type ");
}
if (eval_left == TYPE_INFO.TYPE_BOOL &&
(!(m_op == RELATION_OPERATOR.TOK_EQ ||
m_op == RELATION_OPERATOR.TOK_NEQ)))
{
throw new Exception("Only == amd != supported for boolean type ");
}
// store the operand type as well
_optype = eval_left;
_type = TYPE_INFO.TYPE_BOOL;
return(_type);
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="ret_type"></param>
/// <param name="type_infos"></param>
/// <returns></returns>
public bool CheckFunctionProtoType(string name, TYPE_INFO ret_type,
ArrayList type_infos)
{
foreach (FUNCTION_INFO fpinfo in protos)
{
if (fpinfo._name.Equals(name))
{
if (fpinfo._ret_value == ret_type)
{
if (type_infos.Count == fpinfo._typeinfo.Count)
{
int i = 0;
for (i = 0; i < type_infos.Count; ++i)
{
TYPE_INFO a = (TYPE_INFO)type_infos[i];
TYPE_INFO b = (TYPE_INFO)type_infos[i];
if (a != b)
{
return(false);
}
}
return(true);
}
}
}
}
return(false);
}
public override bool Compile(DNET_EXECUTABLE_GENERATION_CONTEXT cont)
{
//
// Compile the Expression
// The Output will be on the top of stack
exp1.Compile(cont);
//
// Generate Code to Call Console.Write
//
System.Type typ = Type.GetType("System.Console");
Type[] Parameters = new Type[1];
TYPE_INFO tdata = exp1.get_type();
if (tdata == TYPE_INFO.TYPE_STRING)
{
Parameters[0] = typeof(string);
}
else if (tdata == TYPE_INFO.TYPE_NUMERIC)
{
Parameters[0] = typeof(double);
}
else
{
Parameters[0] = typeof(bool);
}
cont.CodeOutput.Emit(OpCodes.Call, typ.GetMethod("Write", Parameters));
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="ret_type"></param>
/// <param name="type_infos"></param>
public void AddFunctionProtoType(string name, TYPE_INFO ret_type,
ArrayList type_infos)
{
FUNCTION_INFO info = new FUNCTION_INFO(name, ret_type, type_infos);
protos.Add(info);
}
/// <summary>
///
/// </summary>
/// <param name="cont"></param>
/// <returns></returns>
public override TYPE_INFO TypeCheck(COMPILATION_CONTEXT cont)
{
if (m_proc != null)
{
_type = m_proc.TypeCheck(cont);
}
return(_type);
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="formals"></param>
/// <param name="stats"></param>
/// <param name="locals"></param>
/// <param name="type"></param>
public Procedure(string name,
ArrayList stats,
SymbolTable locals,
TYPE_INFO type)
{
m_name = name;
m_formals = null;
m_statements = stats;
m_locals = locals;
_type = type;
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="formals"></param>
/// <param name="stats"></param>
/// <param name="locals"></param>
/// <param name="type"></param>
public Procedure(string name,
ArrayList formals,
ArrayList stats,
SymbolTable locals,
TYPE_INFO type)
{
m_name = name;
//
// The value is only supplied for STEP 7
m_formals = formals;
m_statements = stats;
m_locals = locals;
_type = type;
}
/// <summary>
///
/// </summary>
/// <param name="local"></param>
/// <param name="global"></param>
/// <returns></returns>
public override TYPE_INFO TypeCheck(COMPILATION_CONTEXT cont)
{
TYPE_INFO eval_left = exp1.TypeCheck(cont);
if (eval_left == TYPE_INFO.TYPE_NUMERIC)
{
_type = eval_left;
return(_type);
}
else
{
throw new Exception("Type mismatch failure");
}
}
public AssignmentStatement(SYMBOL_INFO var, Exp ind, Exp e)
{
if (var.Type == TYPE_INFO.TYPE_ARRAY)
{
variable = new IndexedVariable(var, ind, e);
exp1 = e;
tp = TYPE_INFO.TYPE_ARRAY;
}
else if (var.Type == TYPE_INFO.TYPE_MAP)
{
variable = new HashedVariable(var, ind, e);
exp1 = e;
tp = TYPE_INFO.TYPE_MAP;
}
}
public Procedure(string name,
ArrayList formals,
ArrayList stats,
SymbolTable locals,
TYPE_INFO type,
Procedure clsr)
{
m_name = name;
//
m_formals = formals;
m_statements = stats;
m_locals = locals;
_type = type;
clossure = clsr;
}
/// <summary>
///
/// </summary>
/// <param name="cont"></param>
/// <returns></returns>
public override TYPE_INFO TypeCheck(COMPILATION_CONTEXT cont)
{
TYPE_INFO eval_left = ex1.TypeCheck(cont);
if (
eval_left == TYPE_INFO.TYPE_BOOL)
{
_type = TYPE_INFO.TYPE_BOOL;
return(_type);
}
else
{
throw new Exception("Wrong Type in expression");
}
}
/// <summary>
/// Look it up in the Symbol Table and
/// return the type
/// </summary>
/// <param name="local"></param>
/// <param name="global"></param>
/// <returns></returns>
public override TYPE_INFO TypeCheck(COMPILATION_CONTEXT cont)
{
if (cont.TABLE == null)
{
return(TYPE_INFO.TYPE_ILLEGAL);
}
else
{
SYMBOL_INFO a = cont.TABLE.Get(m_name);
if (a != null)
{
_type = a.Type;
return(_type);
}
return(TYPE_INFO.TYPE_ILLEGAL);
}
}
/// <summary>
///
/// </summary>
/// <param name="cont"></param>
/// <returns></returns>
public override TYPE_INFO TypeCheck(COMPILATION_CONTEXT cont)
{
TYPE_INFO eval_left = ex1.TypeCheck(cont);
TYPE_INFO eval_right = ex2.TypeCheck(cont);
// The Types should be Boolean...
// Logical Operators only make sense
// with Boolean Types
if (eval_left == eval_right &&
eval_left == TYPE_INFO.TYPE_BOOL)
{
_type = TYPE_INFO.TYPE_BOOL;
return(_type);
}
else
{
throw new Exception("Wrong Type in expression");
}
}
public override bool Compile(DNET_EXECUTABLE_GENERATION_CONTEXT cont)
{
exp1.Compile(cont);
System.Type typ = Type.GetType("System.Console");
Type[] Parameters = new Type[1];
TYPE_INFO tdata = exp1.get_type();
if (tdata == TYPE_INFO.TYPE_STRING)
{
Parameters[0] = typeof(string);
}
else if (tdata == TYPE_INFO.TYPE_NUMERIC)
{
Parameters[0] = typeof(double);
}
else
{
Parameters[0] = typeof(bool);
}
cont.CodeOutput.Emit(OpCodes.Call, typ.GetMethod("WriteLine", Parameters));
return(true);
}
/// <summary>
/// Parse the Assignment Statement
/// <variable> = <expr>
/// </summary>
/// <param name="pb"></param>
/// <returns></returns>
public Stmt ParseAssignmentStatement(ProcedureBuilder ctx)
{
//
// Retrieve the variable and look it up in
// the symbol table ..if not found throw exception
//
string variable = base.last_str;
SYMBOL_INFO s = ctx.TABLE.Get(variable);
Exp index_expression = null;
if (s == null)
{
CSyntaxErrorLog.AddLine("Variable not found " + last_str);
CSyntaxErrorLog.AddLine(GetCurrentLine(SaveIndex()));
throw new CParserException(-100, "Variable not found", SaveIndex());
}
if (s.Type == TYPE_INFO.TYPE_ARRAY || s.Type == TYPE_INFO.TYPE_MAP)
{
GetNext();
if (Current_Token != TOKEN.TOK_OSUBSCRIPT)
{
CSyntaxErrorLog.AddLine("[ expected ");
CSyntaxErrorLog.AddLine(GetCurrentLine(SaveIndex()));
throw new CParserException(-100, "[ expected ", SaveIndex());
}
GetNext();
Exp a = BExpr(ctx);
//
// Do the type analysis ...
//
TYPE_INFO tp = a.TypeCheck(ctx.Context);
if (s.Type == TYPE_INFO.TYPE_MAP)
{
if (tp != s.m_info.key)
{
CSyntaxErrorLog.AddLine("Type mismatch in key ");
CSyntaxErrorLog.AddLine(GetCurrentLine(SaveIndex()));
throw new CParserException(-100, "Type mismatch in key ", SaveIndex());
}
}
else
{
if (tp != s.a_info.tf)
{
CSyntaxErrorLog.AddLine("Type mismatch in index ");
CSyntaxErrorLog.AddLine(GetCurrentLine(SaveIndex()));
throw new CParserException(-100, "Type mismatch in index ", SaveIndex());
}
}
index_expression = a;
if (Current_Token != TOKEN.TOK_CSUBSCRIPT)
{
throw new CParserException(-100, "] is expected", SaveIndex());
}
}
//------------ The next token ought to be an assignment
// expression....
GetNext();
if (Current_Token != TOKEN.TOK_ASSIGN)
{
CSyntaxErrorLog.AddLine("= expected");
CSyntaxErrorLog.AddLine(GetCurrentLine(SaveIndex()));
throw new CParserException(-100, "= expected", SaveIndex());
}
//-------- Skip the token to start the expression
// parsing on the RHS
GetNext();
Exp exp = BExpr(ctx);
//------------ Do the type analysis ...
if (s.Type == TYPE_INFO.TYPE_BOOL || s.Type == TYPE_INFO.TYPE_NUMERIC ||
s.Type == TYPE_INFO.TYPE_STRING)
{
if (exp.TypeCheck(ctx.Context) != s.Type)
{
throw new CParserException(-1, "Type mismatch in assignment", SaveIndex());
}
}
else
{
exp.TypeCheck(ctx.Context);
}
// -------------- End of statement ( ; ) is expected
if (Current_Token != TOKEN.TOK_SEMI)
{
CSyntaxErrorLog.AddLine("; expected");
CSyntaxErrorLog.AddLine(GetCurrentLine(SaveIndex()));
throw new CParserException(-100, " ; expected", SaveIndex());
}
// return an instance of AssignmentStatement node..
// s => Symbol info associated with variable
// exp => to evaluated and assigned to symbol_info
if (index_expression == null)
{
return(new AssignmentStatement(s, exp));
}
else
{
return(new AssignmentStatement(s, index_expression, exp));
}
}
public AssignmentStatement(Variable var, Exp e)
{
variable = var;
exp1 = e;
tp = TYPE_INFO.TYPE_ILLEGAL;
}
