1169 lines
47 KiB
C#
1169 lines
47 KiB
C#
using System.Text;
|
|
|
|
namespace CompilerDesignIFlr1
|
|
{
|
|
internal class SemanticAnalysis
|
|
{
|
|
List<Quadruple> Quadruples = [];
|
|
internal List<IdentifierTable> IdentifierTables = [new IdentifierTable("Global")];
|
|
internal int QuadrupleIndex = 0;
|
|
internal int TempNameCounter = 0;
|
|
internal Stack<int> ElseIndex = [];
|
|
|
|
public void ShiftAnalysis(LR1Unit unit)
|
|
{
|
|
switch (unit.Name)
|
|
{
|
|
case "LBrace":
|
|
IdentifierTables.Add(new IdentifierTable("LBrace"));
|
|
break;
|
|
case "RBrace":
|
|
IdentifierTables.RemoveAt(IdentifierTables.Count - 1);
|
|
break;
|
|
case "If":
|
|
IdentifierTables.Add(new IdentifierTable("If"));
|
|
break;
|
|
case "Else":
|
|
ElseIndex.Push(QuadrupleIndex);
|
|
IdentifierTables.RemoveAt(IdentifierTables.Count - 1);
|
|
IdentifierTables.Add(new IdentifierTable("Else"));
|
|
break;
|
|
case "Type":
|
|
IdentifierTables.Add(new IdentifierTable("Type"));
|
|
break;
|
|
case "Const":
|
|
IdentifierTables.Add(new IdentifierTable("Const"));
|
|
break;
|
|
}
|
|
}
|
|
|
|
public LR1Unit Analysis(List<LR1Unit> units, LR1Unit unit)
|
|
{
|
|
switch (unit.Id)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
break;
|
|
case 2:
|
|
{
|
|
Assert(
|
|
units.Count == 5
|
|
&& Quadruples[units[1].QuadrupleIndex].To.Type == IdentifierType.Address
|
|
&& ElseIndex.Count > 0
|
|
);
|
|
IdentifierTables.RemoveAt(IdentifierTables.Count - 1);
|
|
var identifier = Quadruples[units[1].QuadrupleIndex].To;
|
|
identifier.Value = ElseIndex.Pop() + "";
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
Assert(
|
|
units.Count == 3
|
|
&& Quadruples[units[1].QuadrupleIndex].To.Type == IdentifierType.Address
|
|
);
|
|
IdentifierTables.RemoveAt(IdentifierTables.Count - 1);
|
|
var identifier = Quadruples[units[1].QuadrupleIndex].To;
|
|
identifier.Value = QuadrupleIndex + "";
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
Assert(
|
|
units.Count == 5
|
|
&& Quadruples[units[1].QuadrupleIndex].To.Type == IdentifierType.Address
|
|
&& ElseIndex.Count > 0
|
|
);
|
|
IdentifierTables.RemoveAt(IdentifierTables.Count - 1);
|
|
var identifier = Quadruples[units[1].QuadrupleIndex].To;
|
|
identifier.Value = ElseIndex.Pop() + "";
|
|
break;
|
|
}
|
|
case 5:
|
|
Assert(units.Count == 1);
|
|
//IdentifierTables.RemoveAt(IdentifierTables.Count - 1);
|
|
break;
|
|
case 6:
|
|
{
|
|
Assert(units.Count == 3 && units[1].Value.StartsWith('@'));
|
|
string tempName = GetTempName();
|
|
Identifier oldIdentifier = GetIdentifier(units[1].Value);
|
|
var valueIdentifier = GetFinalIdentifier(units[1].Value);
|
|
Assert(valueIdentifier.Type == IdentifierType.Int);
|
|
var value =
|
|
int.Parse(GetFinalValue(valueIdentifier.Value)) == 0 ? "True" : "False";
|
|
Identifier identifier = Identifier.Address(tempName, value);
|
|
AddToIdentifierTable(identifier);
|
|
Assert(unit.QuadrupleIndex == 0);
|
|
unit.QuadrupleIndex = QuadrupleIndex;
|
|
unit.Value = tempName;
|
|
Quadruples.Add(
|
|
new Quadruple(
|
|
"j==",
|
|
QuadrupleIndex++,
|
|
oldIdentifier,
|
|
Identifier.Literal("0"),
|
|
identifier
|
|
)
|
|
);
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
string tempName = GetTempName();
|
|
Assert(units.Count == 2);
|
|
if (units[1].Value == "None")
|
|
{
|
|
unit.Value = units[0].Value;
|
|
break;
|
|
}
|
|
Assert(units[0].Value.StartsWith("@"));
|
|
Identifier identifier1 = GetFinalIdentifier(units[0].Value);
|
|
string @operator = units[1].Value.Split()[0].Trim();
|
|
Identifier identifier2 = GetFinalIdentifier(units[1].Value.Split()[1].Trim());
|
|
Assert(
|
|
identifier1.Type is IdentifierType.Int
|
|
&& identifier2.Type is IdentifierType.Int
|
|
);
|
|
int value1 = int.Parse(GetFinalValue(identifier1.Value));
|
|
int value2 = int.Parse(GetFinalValue(identifier2.Value));
|
|
var value = @operator switch
|
|
{
|
|
"||" => value1 | value2,
|
|
"&&" => value1 & value2,
|
|
_ => throw new Exception("Type is not supported")
|
|
};
|
|
Identifier tempIdentifier = new(IdentifierType.Int, tempName, value + "");
|
|
AddToIdentifierTable(tempIdentifier);
|
|
Assert(unit.QuadrupleIndex == 0);
|
|
unit.Value = tempName;
|
|
unit.QuadrupleIndex = QuadrupleIndex;
|
|
Quadruples.Add(
|
|
new Quadruple(
|
|
@operator,
|
|
QuadrupleIndex++,
|
|
identifier1,
|
|
identifier2,
|
|
tempIdentifier
|
|
)
|
|
);
|
|
break;
|
|
}
|
|
case 8:
|
|
{
|
|
string tempName = GetTempName();
|
|
Assert(units.Count == 3);
|
|
Assert(units[0].Value.StartsWith('@') && units[2].Value.StartsWith('@'));
|
|
var value = OperatorCalculator(units[0].Value, units[1].Value, units[2].Value);
|
|
Identifier identifier = new Identifier(
|
|
IdentifierType.Int,
|
|
tempName,
|
|
value + ""
|
|
);
|
|
unit.Value = tempName;
|
|
unit.QuadrupleIndex = QuadrupleIndex;
|
|
Quadruples.Add(
|
|
new Quadruple(
|
|
units[1].Value,
|
|
QuadrupleIndex++,
|
|
GetIdentifier(units[0].Value),
|
|
GetIdentifier(units[2].Value),
|
|
identifier
|
|
)
|
|
);
|
|
AddToIdentifierTable(identifier);
|
|
break;
|
|
}
|
|
case 9:
|
|
{
|
|
string tempName = GetTempName();
|
|
Assert(units.Count == 1 && units[0].Value.StartsWith('@'));
|
|
var oldIdentifier = GetFinalIdentifier(units[0].Value);
|
|
Assert(oldIdentifier.Type == IdentifierType.Int);
|
|
var value = int.Parse(GetFinalValue(oldIdentifier.Value)) != 0 ? 1 : 0;
|
|
Identifier identifier = new Identifier(
|
|
IdentifierType.Int,
|
|
tempName,
|
|
value + ""
|
|
);
|
|
unit.Value = tempName;
|
|
unit.QuadrupleIndex = QuadrupleIndex;
|
|
Quadruples.Add(
|
|
new Quadruple(
|
|
"!=",
|
|
QuadrupleIndex++,
|
|
GetIdentifier(units[0].Value),
|
|
Identifier.Literal("0"),
|
|
identifier
|
|
)
|
|
);
|
|
AddToIdentifierTable(identifier);
|
|
break;
|
|
}
|
|
case 10:
|
|
{
|
|
string tempName = GetTempName();
|
|
Assert(units.Count == 2);
|
|
if (units[1].Value == "None")
|
|
{
|
|
unit.Value = units[0].Value;
|
|
break;
|
|
}
|
|
Assert(units[0].Value.StartsWith("@"));
|
|
Identifier identifier1 = GetIdentifier(units[0].Value);
|
|
string @operator = units[1].Value.Split()[0].Trim();
|
|
Identifier identifier2 = GetIdentifier(units[1].Value.Split()[1].Trim());
|
|
Assert(
|
|
identifier1.Type is IdentifierType.Int
|
|
&& identifier2.Type is IdentifierType.Int
|
|
);
|
|
int value1 = int.Parse(GetFinalValue(identifier1.Value));
|
|
int value2 = int.Parse(GetFinalValue(identifier2.Value));
|
|
var value = @operator switch
|
|
{
|
|
"+" => value1 + value2,
|
|
"-" => value1 - value2,
|
|
_ => throw new Exception("Type is not supported")
|
|
};
|
|
Identifier tempIdentifier = new(IdentifierType.Int, tempName, value + "");
|
|
AddToIdentifierTable(tempIdentifier);
|
|
Assert(unit.QuadrupleIndex == 0);
|
|
unit.Value = tempName;
|
|
unit.QuadrupleIndex = QuadrupleIndex;
|
|
Quadruples.Add(
|
|
new Quadruple(
|
|
@operator,
|
|
QuadrupleIndex++,
|
|
identifier1,
|
|
identifier2,
|
|
tempIdentifier
|
|
)
|
|
);
|
|
break;
|
|
}
|
|
case 11:
|
|
case 12:
|
|
break;
|
|
case 13:
|
|
case 14:
|
|
case 15:
|
|
case 16:
|
|
case 17:
|
|
break;
|
|
case 18:
|
|
{
|
|
Assert(units.Count == 3 && units[2].Value.StartsWith('@'));
|
|
Identifier oldIdentifier = GetIdentifier(units[2].Value);
|
|
var identifierValue = GetFinalIdentifier(units[2].Value).Value;
|
|
Identifier identifier = new Identifier(
|
|
oldIdentifier.Type,
|
|
units[0].Value,
|
|
identifierValue
|
|
);
|
|
unit.Value = units[0].Value;
|
|
unit.QuadrupleIndex = QuadrupleIndex;
|
|
if (IdentifierTables[^1].Value == "Type")
|
|
AddToIdentifierTable(identifier);
|
|
else
|
|
UpdateIdentifier(identifier);
|
|
Quadruples.Add(
|
|
new Quadruple("=", QuadrupleIndex++, oldIdentifier, null, identifier)
|
|
);
|
|
break;
|
|
}
|
|
case 19:
|
|
{
|
|
string tempName = GetTempName();
|
|
Assert(units.Count == 2);
|
|
if (units[1].Value == "None")
|
|
{
|
|
unit.Value = units[0].Value;
|
|
break;
|
|
}
|
|
Assert(units[0].Value.StartsWith("@"));
|
|
Identifier identifier1 = GetIdentifier(units[0].Value);
|
|
string @operator = units[1].Value.Split()[0].Trim();
|
|
Identifier identifier2 = GetIdentifier(units[1].Value.Split()[1].Trim());
|
|
Assert(
|
|
identifier1.Type is IdentifierType.Int
|
|
&& identifier2.Type is IdentifierType.Int
|
|
);
|
|
double value1 = int.Parse(GetFinalValue(identifier1.Value));
|
|
double value2 = int.Parse(GetFinalValue(identifier2.Value));
|
|
int value = (int)(
|
|
@operator switch
|
|
{
|
|
"*" => value1 * value2,
|
|
"/" => value1 / value2,
|
|
"%" => value1 % value2,
|
|
_ => throw new Exception("Type is not supported")
|
|
}
|
|
);
|
|
Identifier tempIdentifier = new(IdentifierType.Int, tempName, value + "");
|
|
AddToIdentifierTable(tempIdentifier);
|
|
Assert(unit.QuadrupleIndex == 0);
|
|
unit.Value = tempName;
|
|
unit.QuadrupleIndex = QuadrupleIndex;
|
|
Quadruples.Add(
|
|
new Quadruple(
|
|
@operator,
|
|
QuadrupleIndex++,
|
|
identifier1,
|
|
identifier2,
|
|
tempIdentifier
|
|
)
|
|
);
|
|
break;
|
|
}
|
|
case 20:
|
|
{
|
|
Assert(units.Count == 2);
|
|
foreach (var (name, identifier) in IdentifierTables[^1].Table)
|
|
{
|
|
if (name.StartsWith("@"))
|
|
continue;
|
|
if (
|
|
identifier.Type == IdentifierType.Int
|
|
|| identifier.Type == IdentifierType.Char
|
|
)
|
|
{
|
|
identifier.Type = identifier.Type switch
|
|
{
|
|
IdentifierType.Int => IdentifierType.ConstInt,
|
|
IdentifierType.Char => IdentifierType.ConstChar,
|
|
_ => throw new Exception("Type is not supported.")
|
|
};
|
|
IdentifierTables[^2].Table.Add(name, identifier);
|
|
}
|
|
else
|
|
throw new InvalidOperationException("Wrong type");
|
|
}
|
|
IdentifierTables.RemoveAt(IdentifierTables.Count - 1);
|
|
break;
|
|
}
|
|
case 21:
|
|
{
|
|
Assert(units.Count == 3);
|
|
IdentifierType type = units[0].Value switch
|
|
{
|
|
"int" => IdentifierType.Int,
|
|
"char" => IdentifierType.Char,
|
|
_ => throw new Exception("Type is not supported.")
|
|
};
|
|
foreach (var (name, identifier) in IdentifierTables[^1].Table)
|
|
{
|
|
if (name.StartsWith("@"))
|
|
continue;
|
|
if (identifier.Type == IdentifierType.Unknown || identifier.Type == type)
|
|
{
|
|
identifier.Type = type;
|
|
IdentifierTables[^2].Table.Add(name, identifier);
|
|
}
|
|
else
|
|
throw new InvalidOperationException("Wrong type");
|
|
}
|
|
IdentifierTables.RemoveAt(IdentifierTables.Count - 1);
|
|
break;
|
|
}
|
|
case 22:
|
|
case 23:
|
|
Assert(units.Count == 1);
|
|
unit.Value = units[0].Value;
|
|
break;
|
|
case 24:
|
|
{
|
|
Assert(units.Count == 1);
|
|
string tempName = GetTempName();
|
|
Identifier identifier = GetIdentifier(units[0].Value);
|
|
Assert(identifier.Type != IdentifierType.Literal);
|
|
Identifier tempIdentifier =
|
|
identifier.Type == IdentifierType.Int
|
|
? Identifier.Int(tempName, identifier.Value)
|
|
: Identifier.Char(tempName, identifier.Value);
|
|
Assert(unit.QuadrupleIndex == 0);
|
|
unit.Value = tempName;
|
|
unit.QuadrupleIndex = QuadrupleIndex;
|
|
Quadruples.Add(
|
|
new Quadruple("=", QuadrupleIndex++, identifier, null, tempIdentifier)
|
|
);
|
|
AddToIdentifierTable(tempIdentifier);
|
|
|
|
break;
|
|
}
|
|
case 25:
|
|
{
|
|
Assert(units.Count == 1);
|
|
string tempName = GetTempName();
|
|
Identifier tempIdentifier = Identifier.Int(tempName, units[0].Value);
|
|
Quadruples.Add(
|
|
new Quadruple(
|
|
"=",
|
|
QuadrupleIndex++,
|
|
Identifier.Literal(units[0].Value),
|
|
null,
|
|
tempIdentifier
|
|
)
|
|
);
|
|
Assert(unit.QuadrupleIndex == 0);
|
|
unit.Value = tempName;
|
|
unit.QuadrupleIndex = QuadrupleIndex;
|
|
AddToIdentifierTable(tempIdentifier);
|
|
break;
|
|
}
|
|
case 26:
|
|
{
|
|
Assert(units.Count == 1);
|
|
string tempName = GetTempName();
|
|
Identifier tempIdentifier = Identifier.Char(tempName, units[0].Value);
|
|
Quadruples.Add(
|
|
new Quadruple(
|
|
"=",
|
|
QuadrupleIndex++,
|
|
Identifier.Literal(units[0].Value),
|
|
null,
|
|
tempIdentifier
|
|
)
|
|
);
|
|
Assert(unit.QuadrupleIndex == 0);
|
|
unit.Value = tempName;
|
|
unit.QuadrupleIndex = QuadrupleIndex;
|
|
AddToIdentifierTable(tempIdentifier);
|
|
|
|
break;
|
|
}
|
|
case 27:
|
|
{
|
|
Assert(units.Count == 3);
|
|
Identifier identifier = GetIdentifier(units[1].Value);
|
|
string tempName = GetTempName();
|
|
Identifier tempIdentifier = identifier.Type switch
|
|
{
|
|
IdentifierType.Int => Identifier.Int(tempName, identifier.Value),
|
|
IdentifierType.Char => Identifier.Char(tempName, identifier.Value),
|
|
_ => throw new Exception("Type is not supported.")
|
|
};
|
|
Assert(unit.QuadrupleIndex == 0);
|
|
unit.Value = tempName;
|
|
unit.QuadrupleIndex = QuadrupleIndex;
|
|
Quadruples.Add(
|
|
new Quadruple("=", QuadrupleIndex++, identifier, null, tempIdentifier)
|
|
);
|
|
AddToIdentifierTable(tempIdentifier);
|
|
break;
|
|
}
|
|
case 28:
|
|
case 29:
|
|
Assert(units.Count == 1);
|
|
unit.Value = units[0].Value;
|
|
break;
|
|
case 30:
|
|
case 31:
|
|
case 32:
|
|
Assert(units.Count == 1);
|
|
unit.Value = units[0].Value;
|
|
break;
|
|
case 33:
|
|
{
|
|
Assert(units.Count == 1);
|
|
unit.Value = units[0].Value;
|
|
string tempName = GetTempName();
|
|
Identifier tempIdentifier = Identifier.Int(tempName, unit.Value);
|
|
Quadruples.Add(
|
|
new Quadruple(
|
|
"=",
|
|
QuadrupleIndex++,
|
|
Identifier.Literal(unit.Value),
|
|
null,
|
|
tempIdentifier
|
|
)
|
|
);
|
|
Assert(unit.QuadrupleIndex == 0);
|
|
unit.Value = tempName;
|
|
unit.QuadrupleIndex = QuadrupleIndex;
|
|
AddToIdentifierTable(tempIdentifier);
|
|
break;
|
|
}
|
|
case 34:
|
|
{
|
|
Assert(units.Count == 2);
|
|
unit.Value = "-" + units[1].Value;
|
|
string tempName = GetTempName();
|
|
Identifier tempIdentifier = Identifier.Int(tempName, unit.Value);
|
|
Quadruples.Add(
|
|
new Quadruple(
|
|
"=",
|
|
QuadrupleIndex++,
|
|
Identifier.Literal(unit.Value),
|
|
null,
|
|
tempIdentifier
|
|
)
|
|
);
|
|
Assert(unit.QuadrupleIndex == 0);
|
|
unit.Value = tempName;
|
|
unit.QuadrupleIndex = QuadrupleIndex;
|
|
AddToIdentifierTable(tempIdentifier);
|
|
break;
|
|
}
|
|
case 35:
|
|
{
|
|
Assert(units.Count == 2);
|
|
unit.Value = units[1].Value;
|
|
string tempName = GetTempName();
|
|
Identifier tempIdentifier = Identifier.Int(tempName, unit.Value);
|
|
Quadruples.Add(
|
|
new Quadruple(
|
|
"=",
|
|
QuadrupleIndex++,
|
|
Identifier.Literal(unit.Value),
|
|
null,
|
|
tempIdentifier
|
|
)
|
|
);
|
|
Assert(unit.QuadrupleIndex == 0);
|
|
unit.Value = tempName;
|
|
unit.QuadrupleIndex = QuadrupleIndex;
|
|
AddToIdentifierTable(tempIdentifier);
|
|
break;
|
|
}
|
|
case 36:
|
|
case 37:
|
|
case 38:
|
|
case 39:
|
|
case 40:
|
|
case 41:
|
|
Assert(units.Count == 1);
|
|
unit.Value = units[0].Value;
|
|
break;
|
|
case 42:
|
|
case 43:
|
|
Assert(units.Count == 1);
|
|
unit.Value = units[0].Value;
|
|
break;
|
|
case 44:
|
|
case 45:
|
|
break;
|
|
case 46:
|
|
Assert(units.Count == 0);
|
|
unit.Value = "None";
|
|
break;
|
|
case 47:
|
|
{
|
|
Assert(units.Count == 3);
|
|
if (units[2].Value == "None")
|
|
{
|
|
unit.Value = units[0].Value + " " + units[1].Value;
|
|
break;
|
|
}
|
|
string tempName = GetTempName();
|
|
string @operator = units[2].Value.Split()[0].Trim();
|
|
Assert(@operator is "||" or "&&");
|
|
string unit2Name = units[2].Value.Split()[1].Trim();
|
|
Identifier unit1Identifier = GetIdentifier(units[1].Value);
|
|
Identifier unit2Identifier = GetIdentifier(unit2Name);
|
|
string value1 = GetFinalValue(units[1].Value);
|
|
string value2 = GetFinalValue(unit2Name);
|
|
Assert(
|
|
unit1Identifier.Type == IdentifierType.Int
|
|
&& unit2Identifier.Type == IdentifierType.Int
|
|
);
|
|
var value = @operator switch
|
|
{
|
|
"||" => int.Parse(value1) | int.Parse(value2),
|
|
"&&" => int.Parse(value1) & int.Parse(value2),
|
|
_ => throw new Exception("Type is not supported")
|
|
};
|
|
Identifier tempIdentifier = new Identifier(
|
|
IdentifierType.Int,
|
|
tempName,
|
|
value + ""
|
|
);
|
|
AddToIdentifierTable(tempIdentifier);
|
|
unit.Value = units[0].Value + " " + tempName;
|
|
Quadruples.Add(
|
|
new Quadruple(
|
|
@operator,
|
|
QuadrupleIndex++,
|
|
unit1Identifier,
|
|
unit2Identifier,
|
|
tempIdentifier
|
|
)
|
|
);
|
|
break;
|
|
}
|
|
case 48:
|
|
Assert(units.Count == 0);
|
|
unit.Value = "None";
|
|
break;
|
|
case 49:
|
|
{
|
|
Assert(units.Count == 3);
|
|
if (units[2].Value == "None")
|
|
{
|
|
unit.Value = units[0].Value + " " + units[1].Value;
|
|
break;
|
|
}
|
|
string tempName = GetTempName();
|
|
string @operator = units[2].Value.Split()[0].Trim();
|
|
Assert(@operator is "+" or "-");
|
|
string unit2Name = units[2].Value.Split()[1].Trim();
|
|
Identifier unit1Identifier = GetIdentifier(units[1].Value);
|
|
Identifier unit2Identifier = GetIdentifier(unit2Name);
|
|
string value1 = GetFinalValue(units[1].Value);
|
|
string value2 = GetFinalValue(unit2Name);
|
|
Assert(
|
|
unit1Identifier.Type == IdentifierType.Int
|
|
&& unit2Identifier.Type == IdentifierType.Int
|
|
);
|
|
var value = @operator switch
|
|
{
|
|
"+" => int.Parse(value1) + int.Parse(value2),
|
|
"-" => int.Parse(value1) - int.Parse(value2),
|
|
_ => throw new Exception("Type is not supported")
|
|
};
|
|
Identifier tempIdentifier = new Identifier(
|
|
IdentifierType.Int,
|
|
tempName,
|
|
value + ""
|
|
);
|
|
AddToIdentifierTable(tempIdentifier);
|
|
unit.Value = units[0].Value + " " + tempName;
|
|
Quadruples.Add(
|
|
new Quadruple(
|
|
@operator,
|
|
QuadrupleIndex++,
|
|
unit1Identifier,
|
|
unit2Identifier,
|
|
tempIdentifier
|
|
)
|
|
);
|
|
break;
|
|
}
|
|
case 50:
|
|
case 51:
|
|
break;
|
|
case 52:
|
|
Assert(units.Count == 0);
|
|
unit.Value = "None";
|
|
break;
|
|
case 53:
|
|
{
|
|
Assert(units.Count == 3);
|
|
if (units[2].Value == "None")
|
|
{
|
|
unit.Value = units[0].Value + " " + units[1].Value;
|
|
break;
|
|
}
|
|
string tempName = GetTempName();
|
|
string @operator = units[2].Value.Split()[0].Trim();
|
|
Assert(@operator is "*" or "/" or "%");
|
|
string unit2Name = units[2].Value.Split()[1].Trim();
|
|
Identifier unit1Identifier = GetIdentifier(units[1].Value);
|
|
Identifier unit2Identifier = GetIdentifier(unit2Name);
|
|
string value1 = GetFinalValue(units[1].Value);
|
|
string value2 = GetFinalValue(unit2Name);
|
|
Assert(
|
|
unit1Identifier.Type == IdentifierType.Int
|
|
&& unit2Identifier.Type == IdentifierType.Int
|
|
);
|
|
var value = (int)(
|
|
@operator switch
|
|
{
|
|
"*" => int.Parse(value1) * int.Parse(value2),
|
|
"/" => int.Parse(value1) / int.Parse(value2),
|
|
"%" => int.Parse(value1) % int.Parse(value2),
|
|
_ => throw new Exception("Type is not supported")
|
|
}
|
|
);
|
|
Identifier tempIdentifier = new Identifier(
|
|
IdentifierType.Int,
|
|
tempName,
|
|
value + ""
|
|
);
|
|
AddToIdentifierTable(tempIdentifier);
|
|
unit.Value = units[0].Value + " " + tempName;
|
|
Quadruples.Add(
|
|
new Quadruple(
|
|
@operator,
|
|
QuadrupleIndex++,
|
|
unit1Identifier,
|
|
unit2Identifier,
|
|
tempIdentifier
|
|
)
|
|
);
|
|
break;
|
|
}
|
|
case 54:
|
|
Assert(units.Count == 1);
|
|
unit.Value = units[0].Value;
|
|
unit.QuadrupleIndex = units[0].QuadrupleIndex;
|
|
AddToIdentifierTable(Identifier.Unknown(unit.Value));
|
|
break;
|
|
case 55:
|
|
Assert(units.Count == 1);
|
|
unit.Value = units[0].Value;
|
|
unit.QuadrupleIndex = units[0].QuadrupleIndex;
|
|
break;
|
|
case 56:
|
|
Assert(units.Count == 0);
|
|
unit.Value = "None";
|
|
break;
|
|
case 57:
|
|
Assert(units.Count == 3);
|
|
unit.Value = units[1].Value;
|
|
unit.QuadrupleIndex = units[1].QuadrupleIndex;
|
|
AddToIdentifierTable(Identifier.Unknown(unit.Value));
|
|
break;
|
|
case 58:
|
|
Assert(units.Count == 3);
|
|
unit.Value = units[1].Value;
|
|
unit.QuadrupleIndex = units[1].QuadrupleIndex;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return unit;
|
|
}
|
|
|
|
internal void PrintQuadruples()
|
|
{
|
|
Console.WriteLine("四元式：");
|
|
for (int i = 0; i < Quadruples.Count; i++)
|
|
{
|
|
//Console.Write($"{i, 3}");
|
|
Console.WriteLine(Quadruples[i]);
|
|
}
|
|
}
|
|
|
|
internal void OptimizeQuadruples()
|
|
{
|
|
HashSet<int> basedOn = [];
|
|
bool CanBasedOn(Quadruple quadruple)
|
|
{
|
|
return quadruple.Operator != "=" || !quadruple.To.Name.StartsWith("@");
|
|
}
|
|
Identifier GetFinal(Identifier? identifier, int from)
|
|
{
|
|
if (identifier == null)
|
|
return null!;
|
|
if (identifier.Type == IdentifierType.Literal)
|
|
{
|
|
if (identifier.Value.StartsWith("@"))
|
|
{
|
|
for (int i = from - 1; i >= 0; i--)
|
|
{
|
|
if (Quadruples[i].To.Name == identifier.Value)
|
|
{
|
|
return Identifier.Literal(Quadruples[i].To.Value);
|
|
}
|
|
}
|
|
throw new Exception("Failed to track identifier");
|
|
}
|
|
else
|
|
return Identifier.Literal(identifier.Value);
|
|
}
|
|
if (identifier.Name.StartsWith("@"))
|
|
{
|
|
for (int i = from - 1; i >= 0; i--)
|
|
{
|
|
if (Quadruples[i].To.Name == identifier.Name)
|
|
{
|
|
if (Quadruples[i].Operator == "=")
|
|
return GetFinal(Quadruples[i].A, i);
|
|
else
|
|
return identifier;
|
|
}
|
|
}
|
|
throw new Exception("Failed to track identifier");
|
|
}
|
|
else
|
|
return identifier;
|
|
}
|
|
for (int i = 0; i < Quadruples.Count; i++)
|
|
{
|
|
if (CanBasedOn(Quadruples[i]))
|
|
{
|
|
basedOn.Add(i);
|
|
Quadruples[i].A = GetFinal(Quadruples[i].A, i);
|
|
Quadruples[i].B = GetFinal(Quadruples[i].B, i);
|
|
}
|
|
}
|
|
List<Quadruple> afterList = basedOn.Order().Select(x => Quadruples[x].Clone()).ToList();
|
|
HashSet<int> reAddInAfterList = [];
|
|
for (int i = 1; i <= afterList.Count; i++)
|
|
{
|
|
reAddInAfterList.Add(i);
|
|
Quadruple quadruple = afterList[^i];
|
|
if (quadruple.Operator == "=" && quadruple.A.Name.StartsWith('@'))
|
|
{
|
|
reAddInAfterList.Remove(i);
|
|
bool find = false;
|
|
for (i++; i <= afterList.Count; i++)
|
|
{
|
|
reAddInAfterList.Add(i);
|
|
if (afterList[^i].To.Name == quadruple.A.Name)
|
|
{
|
|
afterList[^i].To = quadruple.To;
|
|
find = true;
|
|
break;
|
|
}
|
|
}
|
|
if(!find)
|
|
throw new Exception("Failed to track identifier");
|
|
}
|
|
}
|
|
afterList = reAddInAfterList.Order().Select(x => afterList[^x]).Reverse().ToList();
|
|
Dictionary<string, string> tempValueReplace = [];
|
|
// >x 时 回填到 y
|
|
Stack<(int, int)> addressReset = [];
|
|
int tempValueIndex = 0;
|
|
string GetNewTempName()
|
|
{
|
|
return "@T" + tempValueIndex++;
|
|
}
|
|
for (int i = 0; i < afterList.Count; i++)
|
|
{
|
|
var quadruple = afterList[i];
|
|
while (addressReset.Count > 0 && addressReset.Peek().Item1 < quadruple.Index)
|
|
afterList[addressReset.Pop().Item2].To.Value = i + "";
|
|
quadruple.Index = i;
|
|
if (quadruple.A.Name.StartsWith("@"))
|
|
{
|
|
if (tempValueReplace.TryGetValue(quadruple.A.Name, out string? newName))
|
|
quadruple.A.Name = newName;
|
|
else
|
|
{
|
|
tempValueReplace.Add(quadruple.A.Name, GetNewTempName());
|
|
quadruple.A.Name = tempValueReplace[quadruple.A.Name];
|
|
}
|
|
}
|
|
if (quadruple.B is not null && quadruple.B.Name.StartsWith("@"))
|
|
{
|
|
if (tempValueReplace.TryGetValue(quadruple.B.Name, out string? newName))
|
|
quadruple.B.Name = newName;
|
|
else
|
|
{
|
|
tempValueReplace.Add(quadruple.B.Name, GetNewTempName());
|
|
quadruple.B.Name = tempValueReplace[quadruple.B.Name];
|
|
}
|
|
}
|
|
if (
|
|
quadruple.To.Name.StartsWith("@")
|
|
&& quadruple.To.Type != IdentifierType.Address
|
|
)
|
|
{
|
|
if (tempValueReplace.TryGetValue(quadruple.To.Name, out string? newName))
|
|
quadruple.To.Name = newName;
|
|
else
|
|
{
|
|
tempValueReplace.Add(quadruple.To.Name, GetNewTempName());
|
|
quadruple.To.Name = tempValueReplace[quadruple.To.Name];
|
|
}
|
|
}
|
|
if (quadruple.Operator.StartsWith('j'))
|
|
addressReset.Push((int.Parse(quadruple.To.Value), i));
|
|
}
|
|
while (addressReset.Count > 0)
|
|
afterList[addressReset.Pop().Item2].To.Value = afterList.Count + "";
|
|
Console.WriteLine("After optimize.");
|
|
//foreach (int i in basedOn.Order().ToList())
|
|
//{
|
|
// Console.WriteLine(Quadruples[i]);
|
|
//}
|
|
foreach (var t in afterList)
|
|
{
|
|
Console.WriteLine(t);
|
|
}
|
|
}
|
|
|
|
internal static bool Assert(bool val) =>
|
|
!val ? throw new Exception("Assertion failed.") : false;
|
|
|
|
internal void AddToIdentifierTable(Identifier identifier)
|
|
{
|
|
if (IdentifierTables[^1].Table.ContainsKey(identifier.Name))
|
|
throw new InvalidOperationException($"{identifier.Name} redefined.");
|
|
IdentifierTables[^1].Table.Add(identifier.Name, identifier);
|
|
}
|
|
|
|
internal string GetTempName() => "@T" + TempNameCounter++;
|
|
|
|
internal Identifier GetIdentifier(string identifier)
|
|
{
|
|
for (int i = 1; i <= IdentifierTables.Count; i++)
|
|
{
|
|
if (IdentifierTables[^i].Table.TryGetValue(identifier, out var val))
|
|
return val;
|
|
}
|
|
throw new InvalidOperationException($"No identifier called: {identifier}");
|
|
}
|
|
|
|
internal void UpdateIdentifier(Identifier identifier)
|
|
{
|
|
for (int i = 1; i <= IdentifierTables.Count; i++)
|
|
{
|
|
if (IdentifierTables[^i].Table.TryGetValue(identifier.Name, out var oldIdentifier))
|
|
{
|
|
if (oldIdentifier.Type is IdentifierType.ConstInt or IdentifierType.ConstChar)
|
|
throw new InvalidOperationException(
|
|
"Change the value of const is not allowed."
|
|
);
|
|
IdentifierTables[^i].Table[identifier.Name] = identifier;
|
|
return;
|
|
}
|
|
}
|
|
throw new InvalidOperationException($"No identifier called: {identifier.Name}");
|
|
}
|
|
|
|
internal Identifier GetFinalIdentifier(string identifier)
|
|
{
|
|
var nextIdentifier = GetIdentifier(identifier);
|
|
if (nextIdentifier.Value.StartsWith("@"))
|
|
return GetFinalIdentifier(nextIdentifier.Value);
|
|
else
|
|
return nextIdentifier;
|
|
}
|
|
|
|
internal string GetFinalValue(string any)
|
|
{
|
|
string ans = any;
|
|
if (any.StartsWith("@"))
|
|
{
|
|
ans = GetFinalIdentifier(any).Value;
|
|
}
|
|
if (ans.Length == 0)
|
|
throw new InvalidOperationException("Identifier used before assignment");
|
|
return ans;
|
|
}
|
|
|
|
internal int OperatorCalculator(string a, string op, string b)
|
|
{
|
|
if (a.StartsWith('@'))
|
|
{
|
|
var identifier = GetFinalIdentifier(a);
|
|
if (identifier.Type != IdentifierType.Int)
|
|
throw new InvalidOperationException("This type is not allowed to compare.");
|
|
a = GetFinalValue(identifier.Value);
|
|
}
|
|
if (b.StartsWith('@'))
|
|
{
|
|
var identifier = GetFinalIdentifier(b);
|
|
if (identifier.Type != IdentifierType.Int)
|
|
throw new InvalidOperationException("This type is not allowed to compare.");
|
|
b = GetFinalValue(identifier.Value);
|
|
}
|
|
int av = int.Parse(a),
|
|
bv = int.Parse(b);
|
|
return op.Trim() switch
|
|
{
|
|
"==" => av == bv,
|
|
">" => av > bv,
|
|
">=" => av >= bv,
|
|
"<" => av < bv,
|
|
"<=" => av <= bv,
|
|
"!=" => av != bv,
|
|
_ => throw new Exception("Type is not uspported.")
|
|
}
|
|
? 1
|
|
: 0;
|
|
}
|
|
}
|
|
|
|
enum IdentifierType
|
|
{
|
|
Int,
|
|
Char,
|
|
ConstInt,
|
|
ConstChar,
|
|
Literal,
|
|
Address,
|
|
Unknown
|
|
}
|
|
|
|
internal class Identifier
|
|
{
|
|
internal IdentifierType Type { get; set; } = IdentifierType.Literal;
|
|
internal string Name { get; set; } = "";
|
|
internal string Value { get; set; } = "";
|
|
|
|
internal Identifier(IdentifierType type, string name, string value)
|
|
{
|
|
Type = type;
|
|
Name = name;
|
|
Value = value;
|
|
}
|
|
|
|
internal static Identifier Literal(string value) =>
|
|
new Identifier(IdentifierType.Literal, "", value);
|
|
|
|
internal static Identifier Literal(string name, string value) =>
|
|
new Identifier(IdentifierType.Literal, name, value);
|
|
|
|
internal static Identifier Int(string name, string value) =>
|
|
new Identifier(IdentifierType.Int, name, value);
|
|
|
|
internal static Identifier Char(string name, string value) =>
|
|
new Identifier(IdentifierType.Char, name, value);
|
|
|
|
internal static Identifier Address(string name, string value) =>
|
|
new Identifier(IdentifierType.Address, name, value);
|
|
|
|
internal static Identifier Unknown(string name) =>
|
|
new Identifier(IdentifierType.Unknown, name, "");
|
|
|
|
internal Identifier Clone()
|
|
{
|
|
return new Identifier(Type, Name, Value);
|
|
}
|
|
}
|
|
|
|
internal class Quadruple
|
|
{
|
|
internal string Operator;
|
|
internal int Index = 0;
|
|
internal Identifier A;
|
|
internal Identifier? B;
|
|
internal Identifier To;
|
|
|
|
internal Quadruple(string @operator, int index, Identifier a, Identifier? b, Identifier to)
|
|
{
|
|
Operator = @operator;
|
|
Index = index;
|
|
A = a;
|
|
B = b;
|
|
To = to;
|
|
}
|
|
|
|
internal Quadruple Clone()
|
|
{
|
|
return new Quadruple(Operator, Index, A.Clone(), B?.Clone(), To.Clone());
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
var sb = new StringBuilder();
|
|
string GetValue(Identifier? identifier)
|
|
{
|
|
if (identifier is null)
|
|
return "";
|
|
if (identifier.Type == IdentifierType.Address)
|
|
return identifier.Value;
|
|
if (identifier.Name.Length != 0)
|
|
return identifier.Name;
|
|
return identifier.Value;
|
|
}
|
|
sb.Append($"{Index, 3}")
|
|
.Append('(')
|
|
.Append(Operator.PadLeft(4, ' '))
|
|
.Append(',')
|
|
.Append(GetValue(A).PadLeft(4, ' '))
|
|
.Append(',')
|
|
.Append(GetValue(B).PadLeft(4, ' '))
|
|
.Append(',')
|
|
.Append(GetValue(To).PadLeft(4, ' '))
|
|
.Append(")");
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
|
|
internal class IdentifierTable
|
|
{
|
|
internal string Value = "";
|
|
internal Dictionary<string, Identifier> Table { get; set; } = [];
|
|
|
|
internal IdentifierTable(string value)
|
|
{
|
|
Value = value;
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
文法：
|
|
key: Program
|
|
0 Program ::= . StatementList
|
|
key: StatementList
|
|
1 StatementList ::= . LBrace Statement_0 RBrace
|
|
key: IfStatement
|
|
2 IfStatement ::= . If ConditionPart PartIfStatement Else Statement
|
|
3 IfStatement ::= . If ConditionPart Statement
|
|
key: PartIfStatement
|
|
4 PartIfStatement ::= . If ConditionPart PartIfStatement Else PartIfStatement
|
|
5 PartIfStatement ::= . NoIfStatement
|
|
key: ConditionPart
|
|
6 ConditionPart ::= . LParen Condition RParen
|
|
key: Condition
|
|
7 Condition ::= . ConditionalExpression LogicalOperator_ConditionalExpression_0
|
|
key: ConditionalExpression
|
|
8 ConditionalExpression ::= . Expression Operator Expression
|
|
9 ConditionalExpression ::= . Expression
|
|
key: Expression
|
|
10 Expression ::= . Term AddLike_Term_0
|
|
key: Statement
|
|
11 Statement ::= . IfStatement
|
|
12 Statement ::= . NoIfStatement
|
|
key: NoIfStatement
|
|
13 NoIfStatement ::= . AssignmentStatement Semicolon
|
|
14 NoIfStatement ::= . VariableDefinition Semicolon
|
|
15 NoIfStatement ::= . LBrace Statement_1 RBrace
|
|
16 NoIfStatement ::= . ConstantDefinition Semicolon
|
|
17 NoIfStatement ::= . Semicolon
|
|
key: AssignmentStatement
|
|
18 AssignmentStatement ::= . Identifier Equal Expression
|
|
key: Term
|
|
19 Term ::= . Factor MultiplyLike_Factor_0
|
|
key: ConstantDefinition
|
|
20 ConstantDefinition ::= . Const VariableDefinition
|
|
key: VariableDefinition
|
|
21 VariableDefinition ::= . Type Identifier__AssignmentStatement_0 Comma_Identifier__Comma_AssignmentStatement_0
|
|
key: Type
|
|
22 Type ::= . Int
|
|
23 Type ::= . Char
|
|
key: Factor
|
|
24 Factor ::= . Identifier
|
|
25 Factor ::= . Number
|
|
26 Factor ::= . Character
|
|
27 Factor ::= . LParen Expression RParen
|
|
key: AddLike
|
|
28 AddLike ::= . Plus
|
|
29 AddLike ::= . Minus
|
|
key: MultiplyLike
|
|
30 MultiplyLike ::= . Multiply
|
|
31 MultiplyLike ::= . Divide
|
|
32 MultiplyLike ::= . Modulo
|
|
key: Number
|
|
33 Number ::= . UnsignedNumber
|
|
34 Number ::= . Minus UnsignedNumber
|
|
35 Number ::= . Plus UnsignedNumber
|
|
key: Operator
|
|
36 Operator ::= . EqualTo
|
|
37 Operator ::= . NotEqualTo
|
|
38 Operator ::= . LessThan
|
|
39 Operator ::= . GreaterThan
|
|
40 Operator ::= . LessThanOrEqual
|
|
41 Operator ::= . GreaterThanOrEqual
|
|
key: LogicalOperator
|
|
42 LogicalOperator ::= . And
|
|
43 LogicalOperator ::= . Or
|
|
key: Statement_0
|
|
44 Statement_0 ::= .
|
|
45 Statement_0 ::= . Statement Statement_0
|
|
key: LogicalOperator_ConditionalExpression_0
|
|
46 LogicalOperator_ConditionalExpression_0 ::= .
|
|
47 LogicalOperator_ConditionalExpression_0 ::= . LogicalOperator ConditionalExpression LogicalOperator_ConditionalExpression_0
|
|
key: AddLike_Term_0
|
|
48 AddLike_Term_0 ::= .
|
|
49 AddLike_Term_0 ::= . AddLike Term AddLike_Term_0
|
|
key: Statement_1
|
|
50 Statement_1 ::= .
|
|
51 Statement_1 ::= . Statement Statement_1
|
|
key: MultiplyLike_Factor_0
|
|
52 MultiplyLike_Factor_0 ::= .
|
|
53 MultiplyLike_Factor_0 ::= . MultiplyLike Factor MultiplyLike_Factor_0
|
|
key: Identifier__AssignmentStatement_0
|
|
54 Identifier__AssignmentStatement_0 ::= . Identifier
|
|
55 Identifier__AssignmentStatement_0 ::= . AssignmentStatement
|
|
key: Comma_Identifier__Comma_AssignmentStatement_0
|
|
56 Comma_Identifier__Comma_AssignmentStatement_0 ::= .
|
|
57 Comma_Identifier__Comma_AssignmentStatement_0 ::= . Comma Identifier Comma_Identifier__Comma_AssignmentStatement_0
|
|
58 Comma_Identifier__Comma_AssignmentStatement_0 ::= . Comma AssignmentStatement Comma_Identifier__Comma_AssignmentStatement_0
|
|
*/
|