CompoundSyntax(Statement[] statements, Syntax syntax, Value cleanupSection = null)
: base(_nextObjectId++, syntax)
{
_statements = statements;
_data = GetData;
CleanupSection = cleanupSection;
}
internal static Result<Value> Create
(Result<Statement[]> left, Result<Value> right, Syntax syntax)
=> new Result<Value>
(
new CompoundSyntax(left.Target, syntax, right?.Target),
left.Issues.plus(right?.Issues)
);
CondSyntax(Value condSyntax, Value thenSyntax, Value elseSyntax, Syntax syntax)
: base(syntax)
{
Cond = condSyntax;
Then = thenSyntax;
Else = elseSyntax;
}
internal static Syntax CreateSourceSyntax
(
Syntax left,
ITokenClass tokenClass,
IToken token,
Syntax right)
=> new Syntax(left, tokenClass, token, right);
Result<Value> IValueProvider.Get(Syntax syntax)
{
var statements = syntax.Left?.ForceStatements;
if(statements == null)
statements = new Statement[0];
var cleanup = syntax.Right?.Value;
return CompoundSyntax.Create(statements, cleanup, syntax);
}
internal static Result<Parser.Value> Create
(Syntax left, bool isImplicit, bool isMetaFunction, Syntax right, Syntax syntax)
{
var leftvalue = left?.Value;
var rightvalue = right?.Value;
var target = new FunctionSyntax
(leftvalue?.Target, isImplicit, isMetaFunction, rightvalue?.Target,syntax);
var issues = leftvalue?.Issues.plus(rightvalue?.Issues);
return new Result<Parser.Value>(target, issues);
}
internal CodeContainer
(string moduleName, Root root, Syntax syntax, string description)
{
ModuleName = moduleName;
Root = root;
MainCache = new ValueCache<Container>
(() => root.MainContainer(syntax, description));
CSharpStringCache = new ValueCache<string>(GetCSharpStringForCache);
_functions = new FunctionCache<int, FunctionContainer>(Root.FunctionContainer);
}
Result<Value> IValueProvider.Get(Syntax syntax)
{
if(syntax.Left != null && syntax.Right != null)
return InfixSyntax.Create(syntax.Left.Value, this, syntax.Right.Value, syntax);
if(syntax.Left == null && syntax.Right != null)
return PrefixSyntax.Create(this, syntax.Right.Value, syntax);
NotImplementedMethod(syntax);
return null;
}
internal static Result<Value> Create
(Syntax condition, Syntax thenSyntax, Syntax elseSyntax, Syntax syntax)
{
var conditionValue = condition.Value;
var thenValue = thenSyntax?.Value;
var elseValue = elseSyntax?.Value;
var result = new CondSyntax
(conditionValue.Target, thenValue?.Target, elseValue?.Target, syntax);
var issues = conditionValue.Issues.plus(thenValue?.Issues).plus(elseValue?.Issues);
return new Result<Value>(result, issues);
}
Result<Statement[]> IStatementsProvider.Get
(List type, Syntax syntax, IDefaultScopeProvider container)
{
if(type != null && type != this)
return null;
var leftStatements = CreateStatements(syntax.Left, syntax, container);
var rightStatements = CreateStatements(syntax.Right, syntax, container);
var target = leftStatements?.Target.plus(rightStatements?.Target);
var issues = leftStatements?.Issues.plus(rightStatements?.Issues);
return new Result<Statement[]>(target, issues);
}
Frame(Syntax target, Frame parent = null, HierachicalFormatter formatter = null)
{
Parent = parent;
Formatter = parent?.Formatter ?? formatter;
Target = target;
LeftCache = new ValueCache<Frame>(() => new Frame(Target.Left, this));
RightCache = new ValueCache<Frame>(() => new Frame(Target.Right, this));
ItemsWithoutLeadingBreaksCache = new ValueCache<ResultItems>
(GetItemsWithoutLeadingBreaks);
LeadingLineBreaksCache = new ValueCache<int>(GetLeadingLineBreaksForCache);
HasInnerLineBreaksCache = new ValueCache<bool>(GetHasInnerLineBreaksForCache);
}
FunctionSyntax
(
Parser.Value setter,
bool isImplicit,
bool isMetaFunction,
Parser.Value getter, Syntax syntax)
: base(syntax)
{
Getter = getter;
Setter = setter;
IsImplicit = isImplicit;
IsMetaFunction = isMetaFunction;
}
Result<Declarator> IDeclaratorTokenClass.Get(Syntax syntax)
{
if(syntax.Right == null)
{
if(syntax.Left == null)
return new Declarator(null, this,syntax.SourcePart);
return syntax.Left.Declarator?.Target.WithName(this,syntax.SourcePart);
}
Tracer.FlaggedLine(nameof(syntax) + "=" + syntax);
return null;
}
Result<Value> IValueProvider.Get(Syntax syntax)
{
if(syntax.Left == null && syntax.Right == null)
return new TerminalSyntax(this, syntax);
if(syntax.Left != null && syntax.Right == null)
{
return new TerminalSyntax(this, syntax)
.Issues<Value>
(
IssueId.TerminalUsedAsSuffix
.Create(syntax.Left.SourcePart));
}
NotImplementedMethod(syntax);
return null;
}
static IEnumerable<IItem1> GetItems
(Syntax target)
{
var whiteSpaceParts = target.Token.PrecededWith.ToArray();
for(var index = 0; index < whiteSpaceParts.Length; index++)
{
var lines = whiteSpaceParts[index].SourcePart.Id.Count(c => c == '\n');
for(var lineIndex = 0; lineIndex < lines; lineIndex++)
{
IItem1 item = new WhiteSpaceItem(index, lineIndex, target);
yield return item;
}
yield return new WhiteSpaceItem(index, lines, target);
}
yield return new TokenItem(target);
}
Syntax
(
Syntax left,
ITokenClass tokenClass,
IToken token,
Syntax right)
: base(NextObjectId++)
{
Left = left;
TokenClass = tokenClass;
Token = token;
Right = right;
Option = new SyntaxOption(this);
LocatePositionCache = new FunctionCache<int, Syntax>(LocatePositionForCache);
if(Left != null)
Left.Parent = this;
if(Right != null)
Right.Parent = this;
}
bool IDeclarationItem.IsDeclarationPart(Syntax syntax)
{
var token = syntax.Token.SourcePart();
var parentTokenClass = syntax.Parent.TokenClass;
if(parentTokenClass is Colon)
return syntax.Parent.Left == syntax;
if(parentTokenClass is LeftParenthesis ||
parentTokenClass is Definable ||
parentTokenClass is ThenToken ||
parentTokenClass is List ||
parentTokenClass is Function ||
parentTokenClass is TypeOperator ||
parentTokenClass is ElseToken ||
parentTokenClass is ScannerSyntaxError)
return false;
Tracer.FlaggedLine(nameof(syntax) + "=" + syntax);
return false;
}
internal Result Execute
(
Category category,
ResultCache left,
Syntax token,
ContextBase context,
Parser.Value right)
{
var trace = ObjectId.In(34) && category.HasCode;
StartMethodDump(trace, category, left, token, context, right);
try
{
var metaFeature = ((IMetaImplementation) Feature).Function;
if(metaFeature != null)
return metaFeature.Result(category, left, context, right);
BreakExecution();
var result = Feature.Result(category.Typed, token, context, right);
Dump(nameof(result), result);
Dump("ConverterPath.Destination.CheckedReference", ConverterPath.Destination.CheckedReference);
Dump("ConverterPath.Execute", ConverterPath.Execute(Category.Code));
BreakExecution();
var replaceAbsolute = result
.ReplaceAbsolute
(ConverterPath.Destination.CheckedReference, ConverterPath.Execute);
Dump(nameof(replaceAbsolute), replaceAbsolute);
if(trace)
Dump(nameof(left), left.Code);
BreakExecution();
return ReturnMethodDump(replaceAbsolute.ReplaceArg(left));
}
finally
{
EndMethodDump();
}
}
string IFormatter.Reformat(Syntax target, SourcePart part)
{
var rawLines = target
.Chain(item => item.Parent)
.Last()
.Items
.OrderBy(item => item.Token.SourcePart().Position)
.SelectMany(GetItems)
.NullableToArray()
.Select(CreateLine)
;
while(rawLines.Any(IsTooLongLine))
rawLines = rawLines.SelectMany(LineBreaker);
var result = rawLines.Filter(part);
if(rawLines.Any(IsTooLongLine))
NotImplementedMethod(result, part);
return result;
}
internal SyntaxToken(Syntax syntax) { Syntax = syntax; }
Result<Value> IValueProvider.Get(Syntax syntax)
=>
FunctionSyntax.Create(syntax.Left, _isImplicit, _isMetaFunction, syntax.Right, syntax);
protected override Result Result
(ContextBase context, Category category, Value right, Syntax token)
=> context.FunctionalArgResult(category, right, token);
protected override Result Result
(ContextBase context, Category category, Value right, Syntax token)
{
NotImplementedMethod(context, category, token, right);
return null;
}
protected abstract Result Result
(ContextBase callContext, Category category, Value right, Syntax token);
Result IPrefix.Result
(ContextBase context, Category category, Value right, Syntax token)
=> Result(context, category, right, token);
Result<Value> GetValue(Syntax syntax)
{
var value = Option.Value;
if(value != null)
return value;
var statement = Option.Statement;
if(statement != null)
return CompoundSyntax.Create(statement, syntax);
var statements = Option.Statements;
if(statements != null)
return CompoundSyntax.Create(statements, syntax);
return IssueId.InvalidExpression.Value(syntax);
}
Result<Value> IValueProvider.Get(Syntax syntax)
=> InfixSyntax.Create(syntax.Left.Value, this, syntax.Right.Value, syntax);
Result<Value> IValueProvider.Get(Syntax syntax)
{
if(syntax.Right == null)
return SuffixSyntax.Create(syntax.Left.Value, this, syntax);
NotImplementedMethod(syntax);
return null;
}
Result<Value> IValueProvider.Get(Syntax syntax)
{
if(syntax.Left == null)
{
if(syntax.Right == null)
return new TerminalSyntax(this, syntax);
return PrefixSyntax.Create(this, syntax.Right.Value, syntax);
}
NotImplementedMethod(syntax);
return null;
}
internal Result<Syntax> GetBracketKernel(int level, Syntax parent)
{
Tracer.Assert(parent.Right == null);
var leftParenthesis = TokenClass as LeftParenthesis;
if(leftParenthesis == null)
return new Result<Syntax>(this, IssueId.ExtraRightBracket.Create(parent.SourcePart));
Tracer.Assert(Left == null);
var levelDelta = leftParenthesis.Level - level;
if(levelDelta == 0)
return Right;
if(levelDelta > 0)
return new Result<Syntax>
(Right, IssueId.ExtraLeftBracket.Create(this.SourcePart));
NotImplementedMethod(level, parent);
return null;
}
