private LanguageValueAccess translate_FollowComponentsSequence(GMacStructure structure, LanguageValueAccess valAccess)
{
while (true)
{
//TODO: Search for a structure macro here
SymbolStructureDataMember dataMember;
if (structure.LookupDataMember(_qualList.FirstItem, out dataMember) == false)
{
CompilationLog.RaiseGeneratorError <LanguageValueAccess>("Structure member '" + _qualList.FirstItem + "' not recognized", RootParseNode);
}
valAccess.Append(dataMember.ObjectName, dataMember.SymbolType);
_qualList.IncreaseActiveStartOffset();
if (_qualList.ActiveLength <= 0)
{
return(valAccess);
}
if (!dataMember.SymbolType.IsStructure())
{
return(CompilationLog.RaiseGeneratorError <LanguageValueAccess>("Data components not recognized", RootParseNode));
}
structure = (GMacStructure)dataMember.SymbolType;
}
}
public void Visit(GMacStructure structure)
{
var node = new TreeNode(structure.SymbolAccessName)
{
Tag = structure
};
RoleNodes[StructuresNode].Nodes.Add(node);
}
private GMacMacro Create_Structure_Macro(GMacStructure structure, string macroName)
{
if (structure.CanDefineChildSymbol(macroName) == false)
{
CompilationLog.RaiseGeneratorError <int>("Symbol name already used", RootParseNode);
}
//Create the macro and add it to the symbol table
return(structure.DefineStructureMacro(macroName));
//TODO: add the 'this' parameter after the result parameter for structure macros
}
private void translate_Structure()
{
try
{
Context.MarkCheckPointState();
string childSymbolName;
SymbolWithScope parentSymbol;
Translate_ParentSymbolAndChildSymbolName(RootParseNode.ChildNodes[0], out parentSymbol, out childSymbolName);
var nameSpace = parentSymbol as GMacNamespace;
if (nameSpace != null)
{
_generatedStructure = Create_Namespace_Structure(nameSpace, childSymbolName);
}
else
{
var frame = parentSymbol as GMacFrame;
if (frame != null)
{
_generatedStructure = Create_Frame_Structure(frame, childSymbolName);
}
else
{
CompilationLog.RaiseGeneratorError <int>("Expecting a Frame or Namespace scope", RootParseNode.ChildNodes[0]);
}
}
_generatedStructure.CodeLocation = Context.GetCodeLocation(RootParseNode);
Context.UnmarkCheckPointState();
Context.CompilationLog.ReportNormal("Translated Structure: " + _generatedStructure.SymbolAccessName, ProgressEventArgsResult.Success);
}
catch (CompilerException)
{
Context.RestoreToCheckPointState();
Context.CompilationLog.ReportNormal("Translate Structure", ProgressEventArgsResult.Failure);
}
catch (Exception e)
{
Context.RestoreToCheckPointState();
Context.CompilationLog.ReportError("Translate Structure Failed With Error", e);
}
}
public TreeNode Visit(GMacStructure structure)
{
var node = new TreeNode("<STRUCTURE> " + structure.ObjectName)
{
Tag = structure
};
if (!ShowStructureMembers)
{
return(node);
}
foreach (var childSymbol in structure.DataMembers)
{
node.Nodes.Add(Visit(childSymbol));
}
return(node);
}
public void Visit(GMacStructure structure)
{
Log.AppendAtNewLine("structure ");
Log.Append(structure.SymbolAccessName);
Log.AppendLine("(");
Log.IncreaseIndentation();
var flag = false;
foreach (var dataMember in structure.DataMembers)
{
if (flag)
{
Log.Append(", ");
}
else
{
flag = true;
}
Log.AppendAtNewLine(dataMember.ObjectName);
Log.Append(" : ");
Log.Append(dataMember.SymbolTypeSignature);
}
Log.DecreaseIndentation();
Log.AppendAtNewLine(")");
foreach (var itam in structure.Macros)
{
itam.AcceptVisitor(this);
}
Log.AppendLineAtNewLine();
}
private ILanguageExpression translate_Expression_Function_Structure(GMacStructure structure, ILanguageExpressionAtomic defaultValueSource, ParseTreeNode node)
{
var operands = OperandsByValueAccess.Create();
if (node.ChildNodes.Count == 0)
{
return
(defaultValueSource == null
? structure.CreateConstructorExpression(operands)
: structure.CreateConstructorExpression(defaultValueSource, operands));
}
var expressionFunctionInputsNode = node.ChildNodes[0];
var subNode = expressionFunctionInputsNode.ChildNodes[0];
switch (subNode.Term.ToString())
{
case GMacParseNodeNames.ExpressionFunctionInputsAssignments:
var expressionFunctionInputsAssignmentsNode = subNode;
foreach (var nodeExpressionFunctionInputsAssignmentsItem in expressionFunctionInputsAssignmentsNode.ChildNodes)
{
var lhsNode = nodeExpressionFunctionInputsAssignmentsItem.ChildNodes[0].ChildNodes[0];
var rhsNode = nodeExpressionFunctionInputsAssignmentsItem.ChildNodes[1];
var lhsValAccess = GMacValueAccessGenerator.Translate_LValue_StructureMember(Context, lhsNode, structure);
var rhsExpr =
BasicExpressionGenerator.Generate_PolyadicOperand(
lhsValAccess.ExpressionType,
GMacExpressionGenerator.Translate(BasicExpressionGenerator, rhsNode)
);
operands.AddOperand(lhsValAccess, rhsExpr);
}
break;
case GMacParseNodeNames.ExpressionFunctionInputsExpressions:
var expressionFunctionInputsExpressionsNode = subNode;
var i = 0;
foreach (var dataMember in structure.DataMembers)
{
if (i >= expressionFunctionInputsExpressionsNode.ChildNodes.Count)
{
break;
}
var rhsNode = expressionFunctionInputsExpressionsNode.ChildNodes[i];
var lhsValAccess = LanguageValueAccess.Create(dataMember);
var rhsExpr =
BasicExpressionGenerator.Generate_PolyadicOperand(
lhsValAccess.ExpressionType,
GMacExpressionGenerator.Translate(BasicExpressionGenerator, rhsNode)
);
operands.AddOperand(lhsValAccess, rhsExpr);
i = i + 1;
}
if (expressionFunctionInputsExpressionsNode.ChildNodes.Count > i)
{
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a list of at most " + i + " expression as input to the structure construction", node));
}
break;
default:
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a list of expressions or a list of member assignments as input to the structure construction", node));
}
return
(defaultValueSource == null
? structure.CreateConstructorExpression(operands)
: structure.CreateConstructorExpression(defaultValueSource, operands));
}
internal AstValueStructureTerm(GMacStructure structure, string dataMemberName, ILanguageValue dataMemberValue)
{
AssociatedStructure = structure;
DataMemberName = dataMemberName;
TermDataMemberValue = dataMemberValue;
}
public static LanguageValueAccess Translate_LValue_StructureMember(GMacSymbolTranslatorContext context, ParseTreeNode node, GMacStructure structure)
{
context.PushState(structure.ChildSymbolScope, node);
var translator = new GMacValueAccessGenerator();//new GMacValueAccessGenerator(context, true, false);
translator.SetContext(context, true, false);
translator.Translate();
context.PopState();
if (translator._generatedValueAccess.RootSymbol is SymbolStructureDataMember)
{
var result = translator._generatedValueAccess;
//MasterPool.Release(translator);
return(result);
}
return(context.CompilationLog.RaiseGeneratorError <LanguageValueAccess>("Expecting a structure member", node));
}
internal static AstStructure ToAstStructure(this GMacStructure structure)
{
return(new AstStructure(structure));
}
internal AstStructure(GMacStructure structure)
{
AssociatedStructure = structure;
}
