public Parameter(Cursor cursor, SymbolDefinition name, DirectionKind direction, Type type)
: base(NodeKind.Parameter, cursor, name)
{
_direction = direction;
_type = type;
_type.Above = this;
}
public Routine(
NodeKind kind,
Cursor cursor,
SymbolDefinition name,
Profile profile,
Block block
)
: base(kind, cursor, name)
{
_profile = profile;
_profile.Above = this;
_block = block;
_block.Above = this;
}
public ScopeStatement(Cursor cursor, SymbolDefinition name, Block block)
: base(NodeKind.ScopeStatement, cursor, name)
{
_block = block;
_block.Above = this;
}
public override object Visit(SymbolDefinition that, object value)
{
_writer.Write(that.Symbol);
return null;
}
public override object Visit(SymbolDefinition that, object value = null)
{
PrintPrologue(that);
_writer.WriteLine("SymbolKind = {0}", that.SymbolKind.ToString());
_writer.WriteLine("Symbol = '{0}'", that.Symbol);
_writer.WriteLine("Path = {0}", (that.Path == null) ? "none" : that.Path);
PrintEpilogue(that);
return null;
}
public Definition(NodeKind kind, Cursor cursor, SymbolDefinition name)
: base(kind, cursor)
{
_name = name;
_name.Above = this;
}
public EntryStatement(Cursor cursor, SymbolDefinition name, Profile profile, Block block)
: base(NodeKind.EntryStatement, cursor, name, profile, block)
{
}
public override object Visit(SymbolDefinition that, object value = null)
{
switch (that.Above.Kind)
{
/** \note Exclude these kinds of nodes as they have been processed by earlier passes. */
case NodeKind.ClassStatement:
case NodeKind.ScopeStatement:
case NodeKind.ValueStatement:
return null;
}
_symbols.Insert(that.Symbol, (Definition) that.Above);
return null;
}
/** Parses an \c import definition.
*
* \note In Braceless0, everything foreign must be explicitly imported before it can be referenced!
* \note As a result, there are no implicit import features in Braceless0.
*
* \todo Implement the above in the compiler...
*/
private ImportStatement ParseImportStatement()
{
Token start = _matcher.Match(TokenKind.Keyword_Import);
Expression path = ParseExpression();
SymbolDefinition name;
#if false
if (_matcher.This.Kind == TokenKind.Space)
{
#endif
_matcher.Match(TokenKind.Space);
_matcher.Match(TokenKind.Keyword_Is);
_matcher.Match(TokenKind.Space);
Token token = _matcher.Match(TokenKind.Name);
name = new SymbolDefinition(token.Cursor, token.Text, SymbolKind.Import);
#if false
}
else
{
// locate the deepest node in the expression tree that denotes the import path
Expression found = null;
Expression next = path;
for (;;)
{
Node[] below = next.Below;
if (below.Length == 0)
{
found = next;
break;
}
else if (below.Length == 1)
next = below[0];
else
throw new System.Exception("Path contains multiple children: " + next.Id.ToString());
}
}
#endif
return new ImportStatement(start.Cursor, name, path);
}
/** Parses a \c create statement, which introduces a new symbol name in the current scope. */
private CreateStatement ParseCreateStatement()
{
Token start = _matcher.This;
_matcher.Match(TokenKind.Keyword_Create);
_matcher.Match(TokenKind.Space);
Token token = _matcher.Match(TokenKind.Name);
var name = new SymbolDefinition(token.Cursor, token.Text, SymbolKind.Variable);
Type type = null;
if (_matcher.This.Kind == TokenKind.Space && _matcher.Next.Kind == TokenKind.Keyword_Is)
{
_matcher.Match(TokenKind.Space);
_matcher.Match(TokenKind.Keyword_Is);
_matcher.Match(TokenKind.Space);
type = ParseType();
}
Expression initializer = null;
if (_matcher.This.Kind == TokenKind.Space && _matcher.Next.Kind == TokenKind.Assign_Identity)
{
_matcher.Match(TokenKind.Space);
_matcher.Match(TokenKind.Assign_Identity);
_matcher.Match(TokenKind.Space);
initializer = ParseExpression();
}
_matcher.Match(TokenKind.EndOfLine);
if (type == null && initializer == null)
throw new ParserError(name.Cursor, "Expected type and/or initalizer");
if (type == null)
type = new UnknownType(name.Cursor);
if (initializer == null)
initializer = new NoneLiteral(name.Cursor, new NoneType(name.Cursor));
return new CreateStatement(start.Cursor, name, type, initializer);
}