private GMacMacro Create_Namespace_Macro(GMacNamespace nameSpace, string macroName)
{
if (GMacCompilerFeatures.CanDefineNamespaceMacros == false)
{
CompilationLog.RaiseGeneratorError <int>("Can't define a macro inside a namespace", RootParseNode);
}
if (nameSpace.CanDefineChildSymbol(macroName) == false)
{
CompilationLog.RaiseGeneratorError <int>("Symbol name already used", RootParseNode);
}
//Create the macro and add it to the symbol table
return(nameSpace.DefineNamespaceMacro(macroName));
}
//public void Visit(GMacAccessScheme access_scheme)
//{
// this.Log.AppendAtNewLine("access ");
// this.Log.AppendLine(access_scheme.SymbolAccessName);
// this.Log.AppendLine("begin");
// this.Log.IncreaseIndentation();
// foreach (var language_name in GMacTargetCodeGenerator.AllowedTargetNames)
// {
// string template = access_scheme.GetTemplate(language_name);
// if (String.IsNullOrEmpty(template) == false)
// {
// this.Log.AppendAtNewLine(language_name);
// this.Log.Append(" @\"");
// this.Log.Append(template);
// this.Log.Append("\"");
// }
// }
// this.Log.DecreaseIndentation();
// this.Log.AppendLineAtNewLine("end");
//}
//public void Visit(GMacCommandBind command)
//{
// this.Log.AppendAtNewLine("bind ");
// this.Visit(command.ValueAccess);
// this.Log.Append(" to");
// if (command.IsConstant)
// {
// this.Log.Append(" constant ");
// command.AccessConstantValue.AcceptVisitor(this);
// }
// else
// {
// string access_name = "@\"" + command.AccessName + "\"";
// if (command.HasAccessScheme)
// {
// this.Log.Append(" ");
// this.Log.Append(command.AccessScheme.SymbolAccessName);
// this.Log.Append("(");
// this.Log.Append(access_name);
// this.Log.Append(")");
// }
// else
// {
// this.Log.Append(" ");
// this.Log.Append(access_name);
// }
// if (command.HasAccessBinding)
// {
// this.Log.Append(" with ");
// this.Log.Append(command.AccessBinding.SymbolAccessName);
// }
// }
// this.Log.AppendAtNewLine();
//}
//public void Visit(GMacBinding binding)
//{
// this.Log.AppendAtNewLine("binding ");
// this.Log.Append(binding.SymbolAccessName);
// this.Log.Append(" on ");
// this.Log.AppendLine(binding.BindingSymbol.SymbolAccessName);
// this.Log.AppendLine("begin");
// this.Log.IncreaseIndentation();
// foreach (var command in binding.BindingCommands)
// this.Visit(command);
// this.Log.DecreaseIndentation();
// this.Log.AppendLineAtNewLine("end");
// //if (binding.IsMacroBinding)
// //{
// // this.Log.AppendLineAtNewLine("Begin Generated Code");
// // this.Log.IncreaseIndentation();
// // var gen = new CodeGenerator.CSharpCodeGenerator(binding, true);
// // this.Log.Append(gen.WriteCode());
// // this.Log.DecreaseIndentation();
// // this.Log.AppendLineAtNewLine("End Generated Code");
// //}
//}
public void Visit(GMacNamespace nameSpace)
{
Log.AppendAtNewLine("namespace ");
Log.AppendLine(nameSpace.SymbolAccessName);
Log.AppendLine();
foreach (var itam in nameSpace.ChildFrames)
{
itam.AcceptVisitor(this);
}
foreach (var itam in nameSpace.ChildConstants)
{
itam.AcceptVisitor(this);
}
foreach (var itam in nameSpace.ChildStructures)
{
itam.AcceptVisitor(this);
}
foreach (var itam in nameSpace.ChildTransforms)
{
itam.AcceptVisitor(this);
}
foreach (var itam in nameSpace.ChildMacros)
{
itam.AcceptVisitor(this);
}
foreach (var itam in nameSpace.ChildMacroTemplates)
{
itam.AcceptVisitor(this);
}
//foreach (var itam in name_space.AccessSchemes)
// itam.AcceptVisitor(this);
//foreach (var itam in name_space.Bindings)
// itam.AcceptVisitor(this);
foreach (var itam in nameSpace.ChildNamespaces)
{
itam.AcceptVisitor(this);
}
}
private LanguageValueAccess translate_StartAt_NamespaceDefinition(GMacNamespace nameSpace)
{
while (true)
{
if (_qualList.ActiveLength == 0)
{
return(LanguageValueAccess.Create(nameSpace));
}
LanguageSymbol symbol;
if (nameSpace.ChildSymbolScope.LookupSymbol(_qualList.FirstItem, out symbol) == false)
{
CompilationLog.RaiseGeneratorError <LanguageValueAccess>("Symbol name not recognized", RootParseNode);
}
_qualList.IncreaseActiveStartOffset(1);
if (_isLValue)
{
CompilationLog.RaiseGeneratorError <int>("LValue symbol name not recognized", RootParseNode);
}
switch (symbol.SymbolRoleName)
{
case RoleNames.Constant:
return(translate_StartAt_DataSymbol((SymbolDataStore)symbol));
case RoleNames.Structure:
case RoleNames.Macro:
case RoleNames.Transform:
return(translate_StartAt_DirectSymbol(symbol));
case RoleNames.Frame:
return(translate_StartAt_FrameDefinition((GMacFrame)symbol));
case RoleNames.Namespace:
nameSpace = (GMacNamespace)symbol;
continue;
default:
return(CompilationLog.RaiseGeneratorError <LanguageValueAccess>("RValue symbol name not recognized", RootParseNode));
}
}
}
private GMacStructure Create_Namespace_Structure(GMacNamespace nameSpace, string structureName)
{
if (GMacCompilerFeatures.CanDefineNamespaceStructures == false)
{
CompilationLog.RaiseGeneratorError <int>("Can't define a structure inside a namespace", RootParseNode);
}
Context.PushState(nameSpace.ChildSymbolScope);
if (nameSpace.CanDefineChildSymbol(structureName) == false)
{
CompilationLog.RaiseGeneratorError <int>("Symbol name already used", RootParseNode);
}
Context.PopState();
return(nameSpace.DefineNamespaceStructure(structureName));
}
public void Visit(GMacNamespace nameSpace)
{
var node = new TreeNode(nameSpace.SymbolAccessName)
{
Tag = nameSpace
};
RoleNodes[NamespacesNode].Nodes.Add(node);
foreach (var childSymbol in nameSpace.ChildNamespaces)
{
Visit(childSymbol);
}
foreach (var childSymbol in nameSpace.ChildFrames)
{
Visit(childSymbol);
}
foreach (var childSymbol in nameSpace.ChildConstants)
{
Visit(childSymbol);
}
foreach (var childSymbol in nameSpace.ChildStructures)
{
Visit(childSymbol);
}
foreach (var childSymbol in nameSpace.ChildTransforms)
{
Visit(childSymbol);
}
foreach (var childSymbol in nameSpace.ChildMacros)
{
Visit(childSymbol);
}
foreach (var childSymbol in nameSpace.ChildMacroTemplates)
{
Visit(childSymbol);
}
}
//public override void ResetOnAcquire()
//{
// base.ResetOnAcquire();
// _generatedConstant = null;
//}
/// <summary>
/// Generate a constant defined inside a namespace
/// </summary>
/// <param name="nameSpace"></param>
/// <param name="constantName"></param>
/// <returns></returns>
private GMacConstant Create_Namespace_Constant(GMacNamespace nameSpace, string constantName)
{
if (GMacCompilerFeatures.CanDefineNamespaceConstants == false)
{
CompilationLog.RaiseGeneratorError <int>("Can't define a constant inside a namespace", RootParseNode);
}
Context.PushState(nameSpace.ChildSymbolScope);
if (nameSpace.CanDefineChildSymbol(constantName) == false)
{
CompilationLog.RaiseGeneratorError <int>("Symbol name already used", RootParseNode);
}
var constantExpr = GMacExpressionGenerator.Translate(Context, RootParseNode.ChildNodes[1]);
var constantValue = GMacExpressionEvaluator.EvaluateExpression(Context.ActiveParentScope, constantExpr);
Context.PopState();
return(nameSpace.DefineNamespaceConstant(constantName, constantValue));
}
public TreeNode Visit(GMacNamespace nameSpace)
{
var node = new TreeNode("<NAMESPACE> " + nameSpace.ObjectName)
{
Tag = nameSpace
};
foreach (var childSymbol in nameSpace.ChildNamespaces)
{
node.Nodes.Add(Visit(childSymbol));
}
if (ShowFrames)
{
foreach (var childSymbol in nameSpace.ChildFrames)
{
node.Nodes.Add(Visit(childSymbol));
}
}
if (ShowConstants)
{
foreach (var childSymbol in nameSpace.ChildConstants)
{
node.Nodes.Add(Visit(childSymbol));
}
}
if (ShowStructures)
{
foreach (var childSymbol in nameSpace.ChildStructures)
{
node.Nodes.Add(Visit(childSymbol));
}
}
if (ShowTransforms)
{
foreach (var childSymbol in nameSpace.ChildTransforms)
{
node.Nodes.Add(Visit(childSymbol));
}
}
if (ShowMacros)
{
foreach (var childSymbol in nameSpace.ChildMacros)
{
node.Nodes.Add(Visit(childSymbol));
}
}
if (!ShowMacroTemplates)
{
return(node);
}
foreach (var childSymbol in nameSpace.ChildMacroTemplates)
{
node.Nodes.Add(Visit(childSymbol));
}
return(node);
}
//public override void ResetOnAcquire()
//{
// base.ResetOnAcquire();
// _generatedTransform = null;
//}
private GMacMultivectorTransform Create_Namespace_Transform(GMacNamespace nameSpace, string constantName)
{
//TODO: Complete this
return(null);
}
internal AstNamespace(GMacNamespace nameSpave)
{
AssociatedNamespace = nameSpave;
}
internal static AstNamespace ToAstNamespace(this GMacNamespace nameSpace)
{
return(new AstNamespace(nameSpace));
}
//public override void ResetOnAcquire()
//{
// base.ResetOnAcquire();
// _generatedNamespace = null;
//}
private void translate_Namespace()
{
try
{
Context.MarkCheckPointState();
//Read the namespace name: for example main.conformal.cga5d
var qualList = GenUtils.Translate_Qualified_Identifier(RootParseNode.ChildNodes[0]);
//Find the root namespace inside the root global scope of the GMacDSL (search for a namespace called 'main')
GMacNamespace nameSpace;
if (GMacRootAst.LookupRootNamespace(qualList.FirstItem, out nameSpace) == false)
{
if (GMacRootAst.RootScope.SymbolExists(qualList.FirstItem))
{
CompilationLog.RaiseGeneratorError <int>("Namespace name already used", RootParseNode.ChildNodes[0]);
}
nameSpace = GMacRootAst.DefineRootNamespace(qualList.FirstItem);
}
//Starting from the created\found root namespace, repeat the previous operation for each child namespace in qual_list
for (var i = 1; i < qualList.ActiveLength; i++)
{
GMacNamespace childNamespace;
if (nameSpace.LookupNamespace(qualList[i], out childNamespace))
{
nameSpace = childNamespace;
}
else
{
if (nameSpace.CanDefineChildSymbol(qualList[i]) == false)
{
CompilationLog.RaiseGeneratorError <int>("Symbol with same name already exists", RootParseNode.ChildNodes[0]);
}
nameSpace = nameSpace.DefineNamespace(qualList[i]);
}
}
_generatedNamespace = nameSpace;
_generatedNamespace.AddCodeLocation(Context.GetCodeLocation(RootParseNode));
Context.UnmarkCheckPointState();
Context.CompilationLog.ReportNormal("Translated Namespace: " + _generatedNamespace.SymbolAccessName, ProgressEventArgsResult.Success);
}
catch (CompilerException)
{
Context.RestoreToCheckPointState();
Context.CompilationLog.ReportNormal("Translate Namespace Failed", ProgressEventArgsResult.Failure);
}
catch (Exception e)
{
Context.RestoreToCheckPointState();
Context.CompilationLog.ReportError("Translate Namespace Failed With Error", e);
}
}
