///
public static Node ParseTrailingExpression(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
var operand = parser.ParseOperand(start);
///
if (operand.IsNewlineDelimited(threshold: 2))
{
return(operand);
}
///
switch (parser.Tokenizer.MatchPostfixOperator())
{
case true:
return(parser.ParsePostfixExpression(start, operand));
///
default:
return(operand);
}
}
public static NeuIdentifierPattern ParseIdentifierPattern(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
var children = new List <Node>();
///
var id = parser.Tokenizer.MaybeNextIdentifier();
if (id == null)
{
throw new Exception();
}
children.Add(id);
///
return(new NeuIdentifierPattern(
children: children,
start: start,
end: parser.Tokenizer.GetLocation()));
}
public static IEnumerable <NeuCodeBlockItem> ParseCodeBlockItems(
this NeuParser parser)
{
var items = new List <NeuCodeBlockItem>();
///
while (!parser.Tokenizer.IsEof())
{
if (parser.Tokenizer.MatchPunc(NeuPuncType.RightBrace))
{
break;
}
///
var item = parser.ParseCodeBlockItem();
if (item == null)
{
break;
}
items.Add(item);
}
///
return(items);
}
public static IEnumerable <NeuPatternBinding> ParsePatternBindings(
this NeuParser parser)
{
var patternBindings = new List <NeuPatternBinding>();
///
while (!parser.Tokenizer.IsEof())
{
if (parser.Tokenizer.MatchSemicolonOrRightBrace())
{
break;
}
///
var patternBinding = parser.ParsePatternBinding();
patternBindings.Add(patternBinding);
///
if (patternBinding.EndsWithNewline())
{
break;
}
}
///
return(patternBindings);
}
public static NeuTypeAnnotation ParseTypeAnnotation(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
var children = new List <Node>();
///
var colon = parser.Tokenizer.MaybeNextColon();
if (colon == null)
{
throw new Exception();
}
children.Add(colon);
///
var typeId = parser.ParseTypeIdentifier();
children.Add(typeId);
///
return(new NeuTypeAnnotation(
children: children,
start: start,
end: parser.Tokenizer.GetLocation()));
}
public static NeuInfixExpression ParseInfixExpression(
this NeuParser parser,
ISourceLocation start,
Node lhs,
NeuInfixOperator op,
Node rhs)
{
switch (op)
{
case NeuAssignOperator assignOp:
return(parser.ParseAssignExpression(start, lhs, assignOp, rhs));
///
case NeuBinaryOperator binaryOp:
return(parser.ParseBinaryExpression(start, lhs, binaryOp, rhs));
///
default:
throw new Exception();
}
}
public static NeuVarDecl ParseVarDecl(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
var children = new List <Node>();
///
var varKeyword = parser.Tokenizer.MaybeNextLetOrVar();
if (varKeyword == null)
{
throw new Exception();
}
children.Add(varKeyword);
///
var patternBindingList = parser.ParsePatternBindingList();
children.Add(patternBindingList);
///
return(new NeuVarDecl(
children: children,
start: start,
end: parser.Tokenizer.GetLocation()));
}
///
public static NeuFuncSignature ParseFuncSignature(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
var children = new List <Node>();
///
var paramClause = parser.ParseParamClause();
children.Add(paramClause);
///
if (parser.Tokenizer.MatchArrow())
{
var returnClause = parser.ParseReturnClause();
children.Add(returnClause);
}
///
return(new NeuFuncSignature(
children: children,
start: start,
end: parser.Tokenizer.GetLocation()));
}
public static NeuUnaryExpression ParseUnaryExpression(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
var op = parser.Tokenizer.MaybeNextUnaryOperator();
if (op == null)
{
throw new Exception();
}
///
switch (op.OperatorType)
{
case NeuUnaryOperatorType.SizeOf:
return(parser.ParseSizeOfExpression(start, op));
///
default:
throw new Exception();
}
}
public static NeuReturnClause ParseReturnClause(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
var children = new List <Node>();
///
var arrow = parser.Tokenizer.MaybeNextArrow();
if (arrow == null)
{
throw new Exception();
}
children.Add(arrow);
///
var retType = parser.ParseTypeIdentifier();
children.Add(retType);
///
return(new NeuReturnClause(
children: children,
start: start,
end: parser.Tokenizer.GetLocation()));
}
public static IEnumerable <NeuFuncParam> ParseFuncParams(
this NeuParser parser)
{
var parameters = new List <NeuFuncParam>();
///
while (!parser.Tokenizer.IsEof())
{
if (parser.Tokenizer.MatchRightParen())
{
break;
}
///
var param = parser.ParseFuncParam();
parameters.Add(param);
}
///
return(parameters);
}
public static NeuPrefixExpression ParsePrefixExpression(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
var op = parser.Tokenizer.MaybeNextPrefixOperator();
if (op == null)
{
throw new Exception();
}
///
var operand = parser.ParseOperand();
///
return(new NeuPrefixExpression(
children: new Node[] { op, operand },
start: start,
end: parser.Tokenizer.GetLocation()));
}
public static NeuExpressionStatement ParseExpressionStatement(
this NeuParser parser,
ISourceLocation start,
Node node)
{
var children = new List <Node>();
///
children.Add(node);
///
if (parser.Tokenizer.MatchSemicolon())
{
var semicolon = parser.Tokenizer.MaybeNextSemicolon();
if (semicolon == null)
{
throw new Exception();
}
children.Add(semicolon);
}
///
return(new NeuExpressionStatement(
children: children,
start: start,
end: parser.Tokenizer.GetLocation()));
}
public static NeuFuncParam ParseFuncParam(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
var children = new List <Node>();
///
var name = parser.Tokenizer.MaybeNextIdentifier();
if (name == null)
{
throw new Exception();
}
children.Add(name);
///
var colon = parser.Tokenizer.MaybeNextColon();
if (colon == null)
{
throw new Exception();
}
children.Add(colon);
///
var paramType = parser.ParseTypeIdentifier();
children.Add(paramType);
///
if (parser.Tokenizer.MatchComma())
{
var comma = parser.Tokenizer.MaybeNextComma();
if (comma == null)
{
throw new Exception();
}
children.Add(comma);
}
///
return(new NeuFuncParam(
children: children,
start: start,
end: parser.Tokenizer.GetLocation()));
}
public static Node ParseOperand(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
return(parser.ParseOperand(start));
}
public static NeuStatement ParseStatementAfterDroppingComments(
this NeuParser parser)
{
parser.DropComments();
///
return(parser.ParseStatement());
}
public static Node ParseExpression(
this NeuParser parser)
{
// var start = parser.Tokenizer.GetLocation();
///
Node?expr;
///
switch (true)
{
case var _ when parser.Tokenizer.MatchUnaryOperator():
expr = parser.ParseUnaryExpression();
break;
///
case var _ when parser.Tokenizer.MatchPrefixOperator():
expr = parser.ParsePrefixExpression();
break;
///
default:
expr = parser.ParseTrailingExpression();
break;
}
///
if (expr == null)
{
throw new Exception();
}
///
if (parser.Tokenizer.MatchComma())
{
/// TODO
throw new Exception();
}
///
return(expr);
}
public static NeuIdentifierExpression ParseIdentifierExpression(
this NeuParser parser,
ISourceLocation start,
NeuIdentifier id)
{
return(new NeuIdentifierExpression(
children: new Node[] { id },
start: start,
end: parser.Tokenizer.GetLocation()));
}
public static NeuNumberLiteralExpression ParseNumberLiteralExpression(
this NeuParser parser,
ISourceLocation start,
NeuNumberLiteral lit)
{
return(new NeuNumberLiteralExpression(
children: new Node[] { lit },
start: start,
end: parser.Tokenizer.GetLocation()));
}
public static NeuBoolLiteralExpression ParseBoolLiteralExpression(
this NeuParser parser,
ISourceLocation start,
NeuKeyword boolKeyword)
{
return(new NeuBoolLiteralExpression(
children: new Node[] { boolKeyword },
start: start,
end: parser.Tokenizer.GetLocation()));
}
public static NeuBinaryExpression ParseBinaryExpression(
this NeuParser parser,
ISourceLocation start,
Node lhs,
NeuBinaryOperator op,
Node rhs)
{
return(new NeuBinaryExpression(
children: new Node[] { lhs, op, rhs },
start: start,
end: parser.Tokenizer.GetLocation()));
}
public static Node ParseLeftHandSideAllowCall(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
Node expr;
///
switch (parser.Tokenizer.Peek())
{
///
default:
expr = parser.ParsePrimary();
break;
}
///
var done = false;
while (!parser.Tokenizer.IsEof() && !done)
{
switch (parser.Tokenizer.Peek())
{
case NeuPunc p when p.PuncType == NeuPuncType.LeftParen:
var arguments = parser.ParseCallArguments();
expr = parser.ParseCallExpression(start, expr, arguments);
break;
///
default:
done = true;
break;
}
}
///
return(expr);
}
public static NeuStatement ParseLabeledStatement(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
var node = parser.ParseExpression();
///
return(parser.ParseExpressionStatement(start, node));
}
public static Node ParseUnary(
this NeuParser parser)
{
switch (parser.Tokenizer.Peek())
{
case NeuPunc p when p.PuncType == NeuPuncType.Plus:
throw new Exception();
///
default:
return(parser.ParseUpdate());
}
}
public static NeuPatternBindingList ParsePatternBindingList(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
var patternBindings = parser.ParsePatternBindings();
///
return(new NeuPatternBindingList(
children: patternBindings,
start: start,
end: parser.Tokenizer.GetLocation()));
}
public static NeuCodeBlockItem?ParseCodeBlockItem(
this NeuParser parser)
{
switch (parser.Tokenizer.Peek())
{
case NeuComment _:
return(parser.ParseStatementAfterDroppingComments());
///
default:
return(parser.ParseStatement());
}
}
public static NeuCodeBlockItemList ParseCodeBlockItemList(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
var items = parser.ParseCodeBlockItems();
///
return(new NeuCodeBlockItemList(
children: items,
start: start,
end: parser.Tokenizer.GetLocation()));
}
public static NeuPattern ParsePattern(
this NeuParser parser)
{
switch (parser.Tokenizer.Peek())
{
case NeuIdentifier _:
return(parser.ParseIdentifierPattern());
///
default:
throw new Exception();
}
}
public static NeuFuncParamList ParseFuncParamList(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
var parameters = parser.ParseFuncParams();
///
return(new NeuFuncParamList(
children: parameters,
start: start,
end: parser.Tokenizer.GetLocation()));
}
public static NeuCodeBlock ParseCodeBlock(
this NeuParser parser)
{
var start = parser.Tokenizer.GetLocation();
///
var children = new List <Node>();
///
var leftBrace = parser.Tokenizer.MaybeNextLeftBrace();
if (leftBrace == null)
{
throw new Exception();
}
children.Add(leftBrace);
///
var list = parser.ParseCodeBlockItemList();
children.Add(list);
///
var rightBrace = parser.Tokenizer.MaybeNextRightBrace();
if (rightBrace == null)
{
throw new Exception();
}
children.Add(rightBrace);
///
return(new NeuCodeBlock(
children: children,
start: start,
end: parser.Tokenizer.GetLocation()));
}
