/// <summary>
/// Adds a name to the item. This defines the left-hand-side of the
/// statement.
/// </summary>
/// <param name="name">The parse item that defines the name.</param>
/// <exception cref="System.ArgumentNullException">If name is null.</exception>
public void AddName(IParseVariable name)
{
if (name == null)
throw new ArgumentNullException("name");
names.Add(name);
}
/// <summary>
/// Adds a name to the item. This defines the left-hand-side of the
/// statement.
/// </summary>
/// <param name="name">The parse item that defines the name.</param>
/// <exception cref="System.ArgumentNullException">If name is null.</exception>
public void AddName(IParseVariable name)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
names.Add(name);
}
/// <summary>
/// Reads an assignment statement from the input. The input is currently after the first name,
/// on the comma or equal sign. The debug token contains the name.
/// </summary>
/// <param name="input">Where to read input from.</param>
/// <param name="debug">The first name.</param>
/// <param name="local">True if this is a local definition, otherwise false.</param>
/// <param name="variable">The first variable that was read.</param>
/// <returns>The statement that was read.</returns>
protected virtual AssignmentItem _readAssignment(Lexer input, Token debug, bool local,
IParseVariable variable)
{
var names = new List <IParseVariable>()
{
variable
};
while (input.ReadIfType(TokenType.Comma))
{
var curDebug = input.Peek();
var exp = _readExp(input, out _);
if ((local && !(exp is NameItem)) || (!local && !(exp is IParseVariable)))
{
throw new SyntaxException(Resources.NameOrExpForVar, input.Name, curDebug);
}
names.Add((IParseVariable)exp);
}
bool isParentheses = false;
var exps = new List <IParseExp>();
if (input.ReadIfType(TokenType.Assign))
{
exps.Add(_readExp(input, out isParentheses));
while (input.ReadIfType(TokenType.Comma))
{
exps.Add(_readExp(input, out isParentheses));
}
}
else if (!local)
{
throw input.SyntaxError(string.Format(Resources.InvalidDefinition, "assignment"));
}
return(new AssignmentItem(names.ToArray(), exps.ToArray())
{
Debug = debug,
Local = local,
IsLastExpressionSingle = isParentheses,
});
}
/// <summary>
/// Creates a new FuncDefItem with the given name.
/// </summary>
/// <param name="name">The name of the method, must be a NameItem
/// or IndexerItem.</param>
/// <param name="local">True if this is a local definition, otherwise false.</param>
public FuncDefItem(IParseVariable name, bool local)
{
this.Prefix = name;
this.args = new List<NameItem>();
this.Local = local;
}
/// <summary>
/// Creates a new FuncDefItem with the given name.
/// </summary>
/// <param name="name">The name of the method, must be a NameItem or
/// IndexerItem.</param>
public FuncDefItem(IParseVariable name)
: this(name, false) { }
/// <summary>
/// Reads a function from the input. Input must be on the word 'function'. If canName is true,
/// it will give the function the read name; otherwise it will give it a null name.
/// </summary>
/// <param name="input">Where to read input from.</param>
/// <param name="canName">True if the function can have a name, otherwise false.</param>
/// <param name="local">True if this function is a local definition, otherwise false.</param>
/// <returns>The function definition that was read.</returns>
protected virtual FuncDefItem _readFunctionHelper(Lexer input, bool canName, bool local)
{
Token debug = input.Expect(TokenType.Function);
IParseVariable name = null;
string instName = null;
if (input.PeekType(TokenType.Identifier))
{
Token temp = input.Expect(TokenType.Identifier);
name = new NameItem(temp.Value)
{
Debug = temp
};
while (input.ReadIfType(TokenType.Indexer))
{
temp = input.Expect(TokenType.Identifier);
var literal = new LiteralItem(temp.Value)
{
Debug = temp
};
name = new IndexerItem(name, literal)
{
Debug = name.Debug
};
}
if (input.ReadIfType(TokenType.Colon))
{
instName = input.Expect(TokenType.Identifier).Value;
}
}
if (name != null && !canName)
{
throw new SyntaxException(Resources.FunctionCantHaveName, input.Name, debug);
}
if (name == null && canName)
{
throw new SyntaxException("Function statements must provide name", input.Name, debug);
}
var args = new List <NameItem>();
input.Expect(TokenType.BeginParen);
if (!input.PeekType(TokenType.EndParen))
{
do
{
Token temp = input.PeekType(TokenType.Elipsis) ?
input.Expect(TokenType.Elipsis) :
input.Expect(TokenType.Identifier);
args.Add(new NameItem(temp.Value)
{
Debug = temp
});
if (temp.Value == "...")
{
break;
}
} while (input.ReadIfType(TokenType.Comma));
}
input.Expect(TokenType.EndParen);
BlockItem chunk = _readBlock(input);
input.Expect(TokenType.End);
chunk.Return ??= new ReturnItem();
return(new FuncDefItem(args.ToArray(), chunk)
{
Debug = debug,
InstanceName = instName,
Prefix = name,
Local = local,
});
}
/// <summary>
/// Creates a new FuncDefItem with the given name.
/// </summary>
/// <param name="name">The name of the method, must be a NameItem
/// or IndexerItem.</param>
/// <param name="local">True if this is a local definition, otherwise false.</param>
public FuncDefItem(IParseVariable name, bool local)
{
this.Prefix = name;
this.args = new List <NameItem>();
this.Local = local;
}
/// <summary>
/// Creates a new FuncDefItem with the given name.
/// </summary>
/// <param name="name">The name of the method, must be a NameItem or
/// IndexerItem.</param>
public FuncDefItem(IParseVariable name)
: this(name, false)
{
}
/// <summary>
/// Reads an assignment statement from the input. The input is currently
/// after the first name, on the comma or equal sign. The debug token
/// contains the name and should contain the entire statement.
/// </summary>
/// <param name="input">Where to read input from.</param>
/// <param name="debug">Currently contains the first name, and after
/// should contain the entire statement.</param>
/// <param name="local">True if this is a local definition, otherwise false.</param>
/// <param name="variable">The first variable that was read.</param>
/// <returns>The statement that was read.</returns>
protected virtual AssignmentItem ReadAssignment(ITokenizer input, ref Token debug, bool local, IParseVariable variable)
{
// read each of the variable names
AssignmentItem assign = new AssignmentItem(local);
assign.AddName(variable);
while (input.Peek().Value == ",")
{
Read(input, ref debug); // read ','
// read the left-hand-expression
var exp = ReadExp(input, ref debug);
if ((local && !(exp is NameItem)) || (!local && !(exp is IParseVariable)))
throw new SyntaxException(Resources.NameOrExpForVar, input.Name, debug);
assign.AddName((IParseVariable)exp);
}
// read the initial values
if (input.Peek().Value == "=")
{
Read(input, ref debug); // read '='
assign.AddItem(ReadExp(input, ref debug));
while (input.Peek().Value == ",")
{
Read(input, ref debug); // read ','
assign.AddItem(ReadExp(input, ref debug));
}
}
else if (!local)
throw new SyntaxException(
string.Format(Resources.InvalidDefinition, "assignment"),
input.Name, debug);
assign.Debug = debug;
return assign;
}