public CommandIfElse(LanguageScope parentScope, ILanguageExpression condExpr, ILanguageExpression trueExpr, ILanguageExpression falseExpr)
: base(parentScope)
{
ConditionExpression = condExpr;
TrueExpression = trueExpr;
FalseExpression = falseExpr;
}
protected CommandBlock(LanguageScope parentScope, string localVariableRoleName)
: base(parentScope)
{
ChildCommandBlockScope = ScopeCommandBlockChild.Create(this, "command_" + ObjectId + "_scope");
LocalVariables = ChildCommandBlockScope.Symbols(localVariableRoleName).Cast <SymbolLocalVariable>();
}
internal GMacMultivectorTransform(string transformName, LanguageScope parentScope, GMacFrame sourceFrame, GMacFrame targetFrame, GaLinearTransform symbolicTransform)
: base(transformName, parentScope, RoleNames.Transform)
{
SourceFrame = sourceFrame;
TargetFrame = targetFrame;
AssociatedSymbolicTransform = symbolicTransform;
}
/// <summary>
/// Open a new scope
/// </summary>
/// <param name="scope"></param>
public void OpenScope(LanguageScope scope)
{
//if (this._OpenedScopes.Exists((LanguageScope x) => (x.ScopeID == scope.ScopeID)))
// return;
_openedScopes.Push(scope);
}
internal GMacRefResContextInfo Clear(LanguageScope scopeSymbol)
{
MainScope = scopeSymbol;
_openedScopes.Clear();
return(this);
}
public CommandComment(LanguageScope parentScope, string commentPrefix, string commentText)
: base(parentScope)
{
CommentPrefix = commentPrefix;
_commentTextLines = commentText.SplitLines();
}
protected TypeStructure(string symbolName, LanguageScope parentScope, string symbolRoleName, string dataMemberRoleName)
: base(symbolName, parentScope, symbolRoleName)
{
//if (this.ChildScope.ContainsSymbolDictionary(data_member_role_name) == false)
// throw new Exception("Illegal symbol dictionary name: " + data_member_role_name);
DataMembers = ChildSymbolScope.Symbols(dataMemberRoleName).Cast <SymbolStructureDataMember>();
}
protected LanguageSymbol(LanguageScope parentScope, string symbolRoleName)
: base(parentScope)
{
ObjectName = "tmp_" + ObjectId.ToString("X");//.PadLeft(9, '_');
SymbolRole = ParentScope.RootAst.RoleDictionary[symbolRoleName];
ParentScope.AddLangugeSymbol(this);
}
protected LanguageSymbol(string symbolName, LanguageScope parentScope, string symbolRoleName)
: base(parentScope)
{
ObjectName = symbolName;
SymbolRole = ParentScope.RootAst.RoleDictionary[symbolRoleName];
ParentScope.AddLangugeSymbol(this);
}
/// <summary>
/// Create a sub-activation record
/// </summary>
/// <param name="callingAr">The dynamic link (the following activation record on the stack)</param>
/// <param name="associatedScope">The associated scope</param>
/// <param name="useUpperStaticAr">If true, use the dynamic link as the static link (make the upper static scope the same as the following activation record on the stack)</param>
public ActivationRecord(ActivationRecord <TSymbolData> callingAr, LanguageScope associatedScope, bool useUpperStaticAr)
{
Arid = CreateNewId();
ParentInterpreter = callingAr.ParentInterpreter;
UpperStaticAr = useUpperStaticAr ? callingAr : null;
UpperDynamicAr = callingAr;
AssociatedScope = associatedScope;
}
internal SymbolTranslatorContextState(LanguageScope parentScope, string curSymbolRoleName, ParseTreeNode curParseNode)
{
StateId = CreateNewId();
ParentScope = parentScope;
ParseNode = curParseNode;
SymbolRoleName = curSymbolRoleName;
IsCheckPointState = false;
}
/// <summary>
/// Push the given state into the stack
/// </summary>
/// <param name="curParentScope"></param>
/// <param name="curSymbolRoleName"></param>
/// <param name="curParseNode"></param>
/// <returns></returns>
public SymbolTranslatorContext PushState(LanguageScope curParentScope, string curSymbolRoleName, ParseTreeNode curParseNode)
{
var state = new SymbolTranslatorContextState(curParentScope, curSymbolRoleName, curParseNode);
StateStack.Push(state);
return(this);
}
/// <summary>
/// Push the given state into the stack. Any missing state information is set to be the active information
/// </summary>
/// <param name="curParentScope"></param>
/// <returns></returns>
public SymbolTranslatorContext PushState(LanguageScope curParentScope)
{
var state = new SymbolTranslatorContextState(curParentScope, ActiveSymbolRoleName, ActiveParseNode);
StateStack.Push(state);
return(this);
}
protected LanguageInterpreter(LanguageScope rootScope, LanguageValueAccessPrecessor valueAccessProc)
{
ParentDsl = rootScope.RootAst;
ValueAccessProcessor = valueAccessProc;
ActiveAr = new ActivationRecord <TSymbolData>(this, rootScope);
}
//public SymbolWithScope AssociatedSymbolWithScope { get { return (AssociatedScope is ScopeSymbolChild) ? ((ScopeSymbolChild)AssociatedScope).ParentLanguageSymbolWithScope : null; } }
/// <summary>
/// Create a root activation record
/// </summary>
/// <param name="interpreter">The controlling evaluator for this activation record</param>
/// <param name="associatedScope">The associated scope</param>
public ActivationRecord(ILanguageInterpreter <TSymbolData> interpreter, LanguageScope associatedScope)
{
Arid = CreateNewId();
ParentInterpreter = interpreter;
UpperStaticAr = null;
UpperDynamicAr = null;
AssociatedScope = associatedScope;
}
public static ScopeScopeChild Create(LanguageScope parentScope, string scopeName)
{
var scope = new ScopeScopeChild(parentScope, scopeName);
RegisterChildScope(scope.ParentScope, scope);
return(scope);
}
internal GMacRefResContextInfo SetMainScope(LanguageScope scopeSymbol)
{
//If the main scope is one of the opened scopes, close it first
CloseScope(scopeSymbol);
MainScope = scopeSymbol;
return(this);
}
/// <summary>
/// Close the last scope that was opened
/// </summary>
/// <param name="scope"></param>
public void CloseScope(LanguageScope scope)
{
if (_openedScopes.Count == 0 || _openedScopes.Peek().ObjectId != scope.ObjectId)
{
throw new Exception("Closed scope not matching last opened scope!");
}
_openedScopes.Pop();
}
public static IEnumerable <Language> FromScope(LanguageScope scope)
{
foreach (var language in database)
{
if (language.Scope == scope)
{
yield return(language);
}
}
}
private bool InitializeCompiler(LanguageScope scope, string targetObject, string codeText)
{
var progressTitle = InitProgressTitle(targetObject);
var result = InitializeCompiler(codeText, GMacSourceParser.ParseQualifiedItem, scope);
this.ReportNormal(progressTitle, codeText, result);
return(result);
}
protected override void InitializeTranslatorContext(LanguageScope parentScope, IEnumerable <LanguageScope> openedScopes)
{
Context = GMacSymbolTranslatorContext.Create(this);
Context.PushState(parentScope, RootParseNode);
foreach (var scope in openedScopes)
{
Context.OpenScope(scope);
}
}
//protected SymbolTranslatorContext(IronyAst rootAst, LanguageCompilationLog compilationLog)
//{
// RootAst = rootAst;
// CompilationLog = compilationLog;
//}
/// <summary>
/// If the stack has no states this pushes the given state. Else it pops the active state then pushes the given state
/// </summary>
/// <param name="curParentScope"></param>
/// <param name="curSymbolRoleName"></param>
/// <param name="curParseNode"></param>
/// <returns>The newly pushed state</returns>
public SymbolTranslatorContext SetActiveState(LanguageScope curParentScope, string curSymbolRoleName, ParseTreeNode curParseNode)
{
if (!HasActiveState)
{
return(PushState(curParentScope, curSymbolRoleName, curParseNode));
}
var state = PopState();
return(PushState(curParentScope, curSymbolRoleName, curParseNode, state.IsCheckPointState));
}
/// <summary>
/// Evaluates the given expression if it's a simple expression else it returns null
/// </summary>
/// <param name="rootScope"></param>
/// <param name="expr"></param>
/// <returns></returns>
internal static ILanguageValue EvaluateExpressionIfSimple(LanguageScope rootScope, ILanguageExpression expr)
{
if (!expr.IsSimpleExpression)
{
return(null);
}
var evaluator = new GMacExpressionEvaluator(rootScope);
return(expr.AcceptVisitor(evaluator));
}
/// <summary>
/// Push the given state into the stack
/// </summary>
/// <param name="curParentScope"></param>
/// <param name="curSymbolRoleName"></param>
/// <param name="curParseNode"></param>
/// <param name="isCheckpointState"></param>
/// <returns>The newly pushed state</returns>
private SymbolTranslatorContext PushState(LanguageScope curParentScope, string curSymbolRoleName, ParseTreeNode curParseNode, bool isCheckpointState)
{
var state =
new SymbolTranslatorContextState(curParentScope, curSymbolRoleName, curParseNode)
{
IsCheckPointState = isCheckpointState
};
StateStack.Push(state);
return(this);
}
public void Given_an_email_formatter_when_attempting_to_format_a_message_using_the_default_language_it_should_not_throw()
{
try
{
LanguageScope.SetDefaultLanguage("en-AU");
_emailFormatter.BuildTemplatedEmailFrom(new SimpleEmailModel());
}
finally
{
LanguageScope.ClearDefaultLanguage();
}
}
private Language([NotNull] string name, [NotNull] string part3, [CanBeNull] string part2B,
[CanBeNull] string part2, [CanBeNull] string part1, LanguageType type, LanguageScope scope)
{
Name = name ?? throw new ArgumentNullException(nameof(name));
Part3 = part3 ?? throw new ArgumentNullException(nameof(part3));
#pragma warning disable 612
Part2B = part2B;
#pragma warning restore 612
Part2 = part2;
Part1 = part1;
Type = type;
Scope = scope;
}
/// <summary>
/// For the given parent scope this method extracts an identifier from the given node and
/// returns it if it isn't already used for a child symbol of the scope.
/// Else it raises a generator exception
/// </summary>
/// <param name="parentScope"></param>
/// <param name="node"></param>
/// <returns></returns>
protected string TranslateChildSymbolName(LanguageScope parentScope, ParseTreeNode node)
{
//Read the name of the new child symbol
var childSymbolName = GenUtils.Translate_Identifier(node);
//Make sure the child symbol name is not used inside the parent scope
if (parentScope.SymbolExists(childSymbolName))
{
CompilationLog.RaiseGeneratorError <int>("Child symbol name already used", node);
}
return(childSymbolName);
}
internal GMacRefResContextInfo OpenScope(LanguageScope scopeSymbol)
{
var scopeName = scopeSymbol.QualifiedScopeName;
if (MainScope.QualifiedScopeName == scopeName)
{
return(this);
}
if (_openedScopes.ContainsKey(scopeName))
{
_openedScopes.Remove(scopeName);
}
_openedScopes.Add(scopeName, scopeSymbol);
return(this);
}
internal GMacFrame(string frameName, LanguageScope parentScope, GaFrame attachedFrame)
: base(frameName, parentScope, RoleNames.Frame)
{
AssociatedSymbolicFrame = attachedFrame;
FrameBasisVectors =
ChildSymbolScope.Symbols(RoleNames.FrameBasisVector).Cast <GMacFrameBasisVector>();
ChildConstants =
ChildSymbolScope.Symbols(RoleNames.Constant).Cast <GMacConstant>();
ChildMacros =
ChildSymbolScope.Symbols(RoleNames.Macro).Cast <GMacMacro>();
FrameSubspaces =
ChildSymbolScope.Symbols(RoleNames.FrameSubspace).Cast <GMacFrameSubspace>();
Structures =
ChildSymbolScope.Symbols(RoleNames.Structure).Cast <GMacStructure>();
Transforms =
ChildSymbolScope.Symbols(RoleNames.Transform).Cast <GMacMultivectorTransform>();
}
internal GMacNamespace(string namespaceName, LanguageScope parentScope)
: base(namespaceName, parentScope)
{
ChildNamespaces =
ChildSymbolScope.Symbols(RoleNames.Namespace).Cast <GMacNamespace>();
ChildFrames =
ChildSymbolScope.Symbols(RoleNames.Frame).Cast <GMacFrame>();
ChildConstants =
ChildSymbolScope.Symbols(RoleNames.Constant).Cast <GMacConstant>();
ChildMacros =
ChildSymbolScope.Symbols(RoleNames.Macro).Cast <GMacMacro>();
ChildMacroTemplates =
ChildSymbolScope.Symbols(RoleNames.MacroTemplate).Cast <GMacMacroTemplate>();
ChildTransforms =
ChildSymbolScope.Symbols(RoleNames.Transform).Cast <GMacMultivectorTransform>();
ChildStructures =
ChildSymbolScope.Symbols(RoleNames.Structure).Cast <GMacStructure>();
}
public void TestFixtureSetUp()
{
_emailFormatter = Given.AnInitializedEmailFormatter();
_languageScope = new LanguageScope("en-AU");
}
