private void ParseStructDeclarationList()
{
Symbols.Type type = null;
Symbols.Var variable = null;
Pair <Symbols.Var, Pair <Symbols.RefType, Symbols.RefType> > pair = null;
while (IsType(scan.Peek()) && (type = ParseTypeSpecifier()) != null)
{
while (true)
{
pair = ParseDeclarator();
variable = pair.first;
if (pair.last == null)
{
variable.SetType(type);
}
else
{
pair.last.last.SetType(type);
variable.SetType(pair.last.first);
}
tstack.AddSymbol(variable);
if (scan.Peek().type != Token.Type.COMMA)
{
break;
}
scan.Read();
}
CheckToken(scan.Peek(), Token.Type.SEMICOLON, true);
}
}
public void Decl(Symbols.Var var)
{
int size = var.GetType() is Symbols.CHAR ? 4 : var.GetType().GetSizeType();
this.offset += size;
AddCode(Com.SUB, new Addr(Reg.ESP), new Val(size, 4));
this.address.Add(var, new Addr(Reg.EBP, size) - this.offset);
}
public void Push(Syntax.Identifier identifier)
{
Reg r1 = GetFreeReg();
Symbols.Var var = identifier.GetVariable();
AddCode(Com.LEA, new Addr(r1), new Val(this.address[var])); //lea eax, cast[addr]
AddCode(Com.PUSH, new Addr(r1)); //push eax
FreeReg(r1);
this.stack.Push(Type.GetType(var.GetType().GetSizeType()));
}
public void Import(Symbols.Var func)
{
Symbols.Func f = (Symbols.Func)func.GetType();
this.address.Add(func, new Addr(func.GetName()));
this.imports.Add(func.GetName() + ", '" + func.GetName() + "'");
}
public void SetVariable(Symbols.Var variable)
{
this.variable = variable;
this.type = variable.GetType();
}
public Identifier(Token identifier, Symbols.Var variable)
{
this.SetIdentifier(identifier);
this.SetVariable(variable);
this.lvalue = true;
}
public void SetVariable(Symbols.Var variable)
{
this.variable = variable;
this.type = variable.GetType();
}
private void ParseDeclaration()
{
while (scan.Peek().type == Token.Type.SEMICOLON)
{
scan.Read();
}
if (scan.Peek().type == Token.Type.EOF)
{
return;
}
Token first_token = scan.Peek();
Symbols.Type type = ParseTypeSpecifier(), variable_type = null;
Pair <Symbols.Var, Pair <Symbols.RefType, Symbols.RefType> > pair = null;
bool function = true;
while (true)
{
variable_type = type;
if ((pair = ParseDeclarator()) != null)
{
if (pair.last != null)
{
pair.last.last.SetType(type);
variable_type = pair.last.first;
}
///Когда мы устанавливаем финальный тип, то нужно пересчитать размер всех типов
if (pair.first == null && !(variable_type is Symbols.RECORD))
{
throw new Syntax.Exception("требуется идентификатор", scan.GetPos(), scan.GetLine());
}
if (pair.first != null)
{
pair.first.SetType(variable_type);
}
if (scan.Peek().type == Token.Type.OP_ASSIGN) // init declarator
{
Symbols.Var v = pair.first;
Syntax.Expression node = new Syntax.Identifier(
new Token(v.GetIndex(), v.GetLine(), Token.Type.IDENTIFICATOR, v.GetName()),
v
);
node = ParseBinaryOper(0, node, true);
//pair.first.SetInitializer(ParseInitializer());
pair.first.SetInitializer(node);
function = false;
}
if (function && scan.Peek().type == Token.Type.LBRACE && tstack.IsGlobal())
{
pair.last.first.SetName(pair.first.GetName());
tstack.AddSymbol(pair.first);
tstack.NewTable();
if (((Symbols.Func)pair.last.first).GetArguments()
.Count(x => x.GetName() == pair.first.GetName()) == 0)
{
tstack.AddSymbol(pair.first);
}
foreach (Symbols.Var arg in ((Symbols.Func)pair.last.first).GetArguments())
{
tstack.AddSymbol(arg);
}
this.ret_func_type = ((Symbols.Func)pair.last.first).GetRefType();
((Symbols.Func)pair.last.first).SetBody(ParseCompound(false));
tstack.GetCurrentTable().RemoveSymbol(pair.first);
((Symbols.Func)pair.last.first).SetTable(tstack.PopTable());
}
else
{
function = false;
}
if (!function && variable_type is Symbols.VOID)
{
throw new Symbols.Exception("недопустимо использование типа \"void\"",
first_token.GetIndex(), first_token.GetLine());
}
if (pair.first != null && !function)
{
try
{
tstack.AddSymbol(pair.first);
}
catch (Symbols.Exception e)
{
this.logger.Add(e);
}
}
}
if (scan.Peek().type != Token.Type.COMMA || function)
{
break;
}
scan.Read();
function = false;
}
if (!function)
{
CheckToken(scan.Peek(), Token.Type.SEMICOLON, true);
}
}
private Pair <Symbols.Var, Pair <Symbols.RefType, Symbols.RefType> > ParseDirectDeclarator(
bool parse_abstract = false, bool parse_parameter = false)
{
Symbols.Var variable = null;
Pair <Symbols.RefType, Symbols.RefType> tpair = null;
Symbols.RefType type = null;
if (scan.Peek().type == Token.Type.IDENTIFICATOR && !parse_abstract)
{
if (parse_parameter)
{
variable = new Symbols.ParamVar(scan.Read());
}
else if (tstack.IsGlobal())
{
variable = new Symbols.GlobalVar(scan.Read());
}
else
{
variable = new Symbols.LocalVar(scan.Read());
}
}
else if (scan.Peek().type == Token.Type.LPAREN)
{
scan.Read();
Pair <Symbols.Var, Pair <Symbols.RefType, Symbols.RefType> > res =
ParseDeclarator(parse_abstract, parse_parameter);
variable = res.first;
if (res.last != null)
{
if (tpair == null)
{
tpair = new Pair <Symbols.RefType, Symbols.RefType>(res.last.first, res.last.last);
}
else
{
tpair.last.SetType(res.last.first);
tpair.last = res.last.last;
}
}
CheckToken(scan.Peek(), Token.Type.RPAREN, false);
if (res.last == null && res.first == null)
{
throw new Syntax.Exception("требуется выражение", scan.GetPos(), scan.GetLine());
}
scan.Read();
}
bool ret = false;
while (true)
{
if (scan.Peek().type == Token.Type.LBRACKET)
{
type = new Symbols.ARRAY(scan.Read());
((Symbols.ARRAY)type).SetSize(ParseAssignmentExpression());
CheckToken(scan.Peek(), Token.Type.RBRACKET, true);
}
else if (scan.Peek().type == Token.Type.LPAREN)
{
type = new Symbols.Func("", scan.Peek().pos, scan.Peek().line);
scan.Read();
tstack.NewTable();
((Symbols.Func)type).SetArguments(ParseParameterList());
((Symbols.Func)type).SetTable(tstack.PopTable());
CheckToken(scan.Peek(), Token.Type.RPAREN, true);
}
else
{
ret = true;
}
if (type != null)
{
if (tpair != null)
{
tpair.last.SetType(type);
tpair.last = type;
}
else
{
tpair = new Pair <Symbols.RefType, Symbols.RefType>(type, type);
}
}
type = null;
if (ret)
{
return(new Pair <Symbols.Var, Pair <Symbols.RefType, Symbols.RefType> >(variable, tpair));
}
}
}
