public override Tree VisitFuncDeclaration(FuncDeclarationContext context)
{
String name = context.name.Text;
ResultContext resultContext = context.result();
IList <FormalParameterContext> parameterContexts = context._params;
bool isPrivate = context.isPrivate;
TypeContext resType = resultContext.type();
TypeTree type;
if (resType != null)
{
type = (TypeTree)VisitType(resType);
}
else
{
//void
IToken voidToken = resultContext.Start;
int len = voidToken.StopIndex - voidToken.StartIndex;
type = new PrimitiveTypeNode(voidToken.Line, voidToken.Column, voidToken.Line, voidToken.Column + len,
TypeTag.VOID);
}
VariableDeclaration[] parameters = new VariableDeclaration[parameterContexts.Count];
for (int i = 0; i < parameterContexts.Count; i++)
{
parameters[i] = (VariableDeclaration)VisitFormalParameter(parameterContexts[i]);
}
Block block = (Block)VisitBlock(context.funcBody().block());
return(new FuncDef(type.beginLine, type.beginCol, block.endLine, block.endCol, name, type, parameters,
block, isPrivate));
}
private PrimitiveTypeNode ConnectPrimitiveTypeToInputTerminal(Terminal inputTerminal, NIType type)
{
var primitive = new PrimitiveTypeNode(inputTerminal.ParentDiagram, type);
Wire.Create(inputTerminal.ParentDiagram, primitive.OutputTerminal, inputTerminal);
return(primitive);
}
public void VisitPrimitiveType(PrimitiveTypeNode node)
{
var typeToken = node.TypeToken;
var knownTypeCode = KnownType.GetTypeCode(typeToken.Tag);
_type = KnownType.GetType(knownTypeCode);
}
public PrimitiveTypeExpressionNode(PrimitiveTypeNode primitiveType, Token name, AccesorExpressionNode accessor, string posId)
{
PrimitiveType = primitiveType;
IdToken = name;
Accessor = accessor;
PostId = posId;
}
public override Tree VisitType(TypeContext context)
{
TypeTag type;
TypeTree tree;
IToken token = context.primitive;
if (token != null)
{
switch (token.Type)
{
case INT:
type = TypeTag.INT;
break;
case LONG:
type = TypeTag.LONG;
break;
case FLOAT:
type = TypeTag.FLOAT;
break;
case DOUBLE:
type = TypeTag.DOUBLE;
break;
case BOOLEAN:
type = TypeTag.BOOLEAN;
break;
case CHAR:
type = TypeTag.CHAR;
break;
case CSTRING:
type = TypeTag.C_STRING;
break;
default:
throw new ArgumentException();
}
int endCol = token.Column + token.StopIndex - token.StopIndex;
tree = new PrimitiveTypeNode(token.Line, token.Column, token.Line, endCol, type);
}
else
{
tree = new DeclaredType(context.Start.Line, context.Start.Column, context.Stop.Line,
context.Stop.Column, context.structName.Text);
}
for (int i = 0; i < context.arrays; i++)
{
tree = new ArrayTypeTree(context.Start.Line, context.Start.Column, context.Stop.Line,
context.Stop.Column, tree);
}
return(tree);
}
public static Either <ParseException, Pair <List <IToken>, TypeNode> > Parse(List <IToken> tokens, SymT symT, IScopedTable <IEntityType, string> parentTypeTable)
{
Console.WriteLine("TypeNode");
var maybePrimitiveType = PrimitiveTypeNode.Parse(tokens);
if (maybePrimitiveType.IsLeft)
{
var maybeArrayType = ArrayTypeNode.Parse(tokens, symT, parentTypeTable);
if (maybeArrayType.IsLeft)
{
SymT NewSymT = new SymT(symT);
var maybeRecordType = RecordTypeNode.Parse(tokens, NewSymT, parentTypeTable);
if (maybeRecordType.IsLeft)
{
if (tokens.Count < 1)
{
return(NotATypeException);
}
if (!(tokens[0] is IdentifierToken))
{
return(NotATypeException);
}
IdentifierToken identifier = (IdentifierToken)tokens[0];
if (!(symT.ContainRec(identifier)))
{
// TODO: return an exception instead
Console.Write("No such identifier");
}
tokens = tokens.Skip(1).ToList();
return(new Pair <List <IToken>, TypeNode> (tokens, new TypeNode(identifier)));
}
tokens = maybeRecordType.RightToList()[0].First;
return(new Pair <List <IToken>, TypeNode> (tokens, new TypeNode(
maybeRecordType.RightToList()[0].Second)));
}
tokens = maybeArrayType.RightToList()[0].First;
return(new Pair <List <IToken>, TypeNode> (tokens, new TypeNode(
maybeArrayType.RightToList()[0].Second)));
}
tokens = maybePrimitiveType.RightToList()[0].First;
return(new Pair <List <IToken>, TypeNode> (tokens, new TypeNode(
maybePrimitiveType.RightToList()[0].Second)));
}
public TypeNode(PrimitiveTypeNode primitiveType)
{
PrimitiveType = primitiveType;
}
public override Type visitPrimitiveType(PrimitiveTypeNode prim, Environment env)
{
return(symtab.typeForTag(prim.type));
}
public virtual T visitPrimitiveType(PrimitiveTypeNode prim, A arg) => visit(prim, arg);
public PrimitiveTypeRepresentation(PrimitiveTypeNode typeNode)
{
TypeNode = typeNode;
}
public override object visitPrimitiveType(PrimitiveTypeNode prim, WritableScope scope)
{
return(symtab.typeForTag(prim.type));
}
