public CallExpression(TextPosition tp, Element acs, TupleLiteral args) : base(tp) { Access = acs; Arguments = args; AppendChild(Access); AppendChild(Arguments); }
public TemplateInstanceExpression(TextPosition tp, Element acs, TupleLiteral args) : base(tp) { Access = acs; DecParameters = args; AppendChild(Access); AppendChild(DecParameters); }
public VariantDeclaration(TextPosition tp, VariantType type, string name, TupleLiteral attr, Element expli, Element def = null) : base(tp, type, def) { Name = name; AttributeAccess = attr; ExplicitType = expli; AppendChild(AttributeAccess); AppendChild(ExplicitType); }
public EnumDeclaration(TextPosition tp, string name, TupleLiteral attr, TupleLiteral generic, Element expli, ProgramContext block) : base(tp, name, block) { AttributeAccess = attr; DecGenerics = generic; ExplicitBaseType = expli; AppendChild(AttributeAccess); AppendChild(DecGenerics); AppendChild(ExplicitBaseType); }
public ClassDeclaration(TextPosition tp, string name, ClassType type, TupleLiteral attr, TupleLiteral generic, TupleLiteral inherit, ProgramContext block) : base(tp, name, type, block) { AttributeAccess = attr; DecGenerics = generic; InheritAccess = inherit; AppendChild(AttributeAccess); AppendChild(DecGenerics); AppendChild(InheritAccess); }
public RoutineDeclaration(TextPosition tp, string name, RoutineType type, TokenType opType, TupleLiteral attr, TupleLiteral generic, TupleLiteral args, Element expli, ProgramContext block) : base(tp, name, type, opType, block) { AttributeAccess = attr; DecGenerics = generic; DecArguments = args; ExplicitType = expli; AppendChild(AttributeAccess); AppendChild(DecGenerics); AppendChild(DecArguments); AppendChild(ExplicitType); }
protected CallExpression(TextPosition tp, Element acs, Element arg) : base(tp) { Access = acs; if (arg is TupleLiteral) { Arguments = (TupleLiteral)arg; } else { Arguments = new TupleLiteral(arg.Position, arg); } AppendChild(Access); AppendChild(Arguments); }
private static void ArgumentPart(SlimChainParser cp, out VariantType type, out string name, out TupleLiteral attr, out Element expli) { var ty = VariantType.Var; var n = string.Empty; TupleLiteral a = null; Element ex = null; cp.Transfer(e => a = e, AttributeList) .Opt.Any( icp => icp.Text("var").Self(() => ty = VariantType.Var), icp => icp.Text("let").Self(() => ty = VariantType.Let), icp => icp.Text("const").Self(() => ty = VariantType.Const) ).Lt() .Type(t => n = t.Text, TokenType.LetterStartString).Lt() .If(icp => icp.Type(TokenType.Pair).Lt()) .Then(icp => icp.Transfer(e => ex = e, Prefix)); type = ty; name = n; attr = a; expli = ex; }
private static Element TemplateInstance(Element current, SlimChainParser cp) { TupleLiteral args = null; var ret = cp.Begin .Type(TokenType.Template) .Not.Transfer(null, RangeLiteral) .If(icp => icp.Type(TokenType.LeftParenthesis).Lt()) .Then(icp => { icp.Transfer(e => args = e, TupleLiteral) .Type(TokenType.RightParenthesis).Lt(); }) .ElseIf(icp => icp.Type(TokenType.LeftBracket).Lt()) .Then(icp => { icp.Transfer(e => args = e, TupleLiteral) .Type(TokenType.RightBracket).Lt(); }) .Else(icp => icp.Transfer(e => args = new TupleLiteral(e.Position, e), Identifier)) .End(tp => new TemplateInstanceExpression(tp, current, args)); return ret == null ? current : Postfix(ret, cp); }
public LambdaLiteral(TextPosition tp, string name, RoutineType type, TokenType op, TupleLiteral attr, TupleLiteral generic, TupleLiteral args, Element expli, ProgramContext block) : base(tp, name, type, op, attr, generic, args, expli, block) { }
private static void EnumFieldPart(SlimChainParser cp, out string name, out TupleLiteral attr) { var n = string.Empty; TupleLiteral a = null; cp.Transfer(e => a = e, AttributeList) .Type(t => n = t.Text, TokenType.LetterStartString).Lt(); name = n; attr = a; }
private static ClassDeclaration ClassDeclaration(SlimChainParser cp) { var type = ClassType.Unknown; var name = string.Empty; TupleLiteral attr = null; TupleLiteral generic = null; TupleLiteral inherit = new TupleLiteral(); ProgramContext block = null; return cp.Begin .Transfer(e => attr = e, AttributeList) .Any( icp => icp.Text("class").Self(() => type = ClassType.Class), icp => icp.Text("trait").Self(() => type = ClassType.Trait), icp => icp.Text("extend").Self(() => type = ClassType.Extend) ).Lt() .Type(t => name = t.Text, TokenType.LetterStartString).Lt() .Transfer(e => generic = e, GenericList) .If(icp => icp.Type(TokenType.Pair).Lt()) .Then(icp => icp.Transfer(e => inherit = e, c => ParseTuple(c, Identifier))) .Transfer(e => block = e, InlineContext) .End(tp => new ClassDeclaration(tp, name, type, attr, generic, inherit, block)); }