public bool ValidateSingleDecl(List <DeclReference> decls, Name origName, Diagnostics.Span span) { if (decls.Count == 0) { this.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.Unknown, "unknown '" + origName.GetString() + "'", span); return(false); } else if (decls.Count > 1) { this.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.AmbiguousDeclaration, "ambiguous '" + origName.GetString() + "' between " + "'" + this.GetDeclName(decls[0]).GetString() + "'" + (decls.Count == 2 ? " and " : ", ") + "'" + this.GetDeclName(decls[1]).GetString() + "'" + (decls.Count > 2 ? ", and other " + (decls.Count - 2) : ""), span); return(false); } else { return(true); } }
public int CreateSegment(Diagnostics.Span span) { this.segments.Add(new InstructionSegment { span = span }); return(this.segments.Count - 1); }
private bool ValidateName(Core.Name name, Diagnostics.Span span) { int duplicateIndex; if (this.session.TryGetDecl(name, out duplicateIndex)) { var duplicateSpan = this.structWorkData.Find(st => st.name.Compare(name))?.declNode.name.GetSpan() ?? this.functWorkData.Find(st => st.name.Compare(name))?.declNode.name.GetSpan() ?? new Diagnostics.Span(); this.session.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.DuplicateDeclaration, "duplicate declaration of '" + name.GetString() + "'", span); this.session.AddInnerMessageToLast( Diagnostics.MessageKind.Info, Diagnostics.MessageCode.DuplicateDeclaration, "first declaration here", duplicateSpan); return(false); } return(true); }
public int CreateBinding(Core.Name name, int registerIndex, Diagnostics.Span span) { var binding = new LocalBinding(); binding.name = name; binding.registerIndex = registerIndex; binding.declSpan = span; this.localBindings.Add(binding); return(this.localBindings.Count - 1); }
public static InstructionMoveLiteralStruct Of( Diagnostics.Span span, DataAccess destination, int structIndex, DataAccess[] fieldSources, Diagnostics.Span[] fieldDestSpans) { return(new InstructionMoveLiteralStruct { span = span, destination = destination, structIndex = structIndex, fieldSources = fieldSources, fieldDestSpans = fieldDestSpans }); }
public bool ValidateAsFunct(DeclReference decl, Name origName, Diagnostics.Span span) { if (decl.kind != Core.Session.DeclReference.Kind.Funct) { this.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.WrongDeclarationKind, "'" + this.GetDeclName(decl).GetString() + "' is not a funct", span); return(false); } return(true); }
public static InstructionMoveCallResult For( Diagnostics.Span span, DataAccess destination, DataAccess callTarget, DataAccess[] arguments) { return(new InstructionMoveCallResult { span = span, destination = destination, callTargetSource = callTarget, argumentSources = arguments }); }
private void PrintPosition(Diagnostics.Span span) { Console.ForegroundColor = ConsoleColor.White; if (span.unit != null) { Console.Write(span.unit.GetFullName() + ":"); Console.Write((span.unit.GetLineIndexAtSpanStart(span) + 1) + ":"); Console.Write((span.unit.GetColumnAtSpanStart(span) + 1) + ": "); } else { Console.Write("<unknown location>: "); } Console.ResetColor(); }
private void CheckMove(Core.DataAccess destination, Core.Type srcType, Diagnostics.Span srcSpan) { if (!TypeResolver.ValidateDataAccess(this.session, this.funct, destination)) { this.foundErrors = true; return; } var destType = TypeResolver.GetDataAccessType(this.session, this.funct, destination); if (destType == null) { return; } if (!srcType.IsConvertibleTo(destType) && ShouldDiagnose(srcType) && ShouldDiagnose(destType)) { this.foundErrors = true; var destReg = destination as Core.DataAccessRegister; if (destReg != null && destReg.registerIndex == 0) { this.session.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.IncompatibleTypes, "returning '" + srcType.GetString(this.session) + "' " + "but expecting '" + destType.GetString(this.session) + "'", srcSpan, destination.span); } else { this.session.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.IncompatibleTypes, "moving '" + srcType.GetString(this.session) + "' " + "into '" + destType.GetString(this.session) + "'", srcSpan, destination.span); } } }
public static InstructionMoveLiteralTuple Empty(Diagnostics.Span span, DataAccess destination) { return(new InstructionMoveLiteralTuple { span = span, destination = destination }); }
private void ResolveExprLiteralStruct(Grammar.ASTNodeExprLiteralStruct exprLiteralStruct, ref int curSegment, Core.DataAccess output) { var type = TypeResolver.ResolveStruct(session, exprLiteralStruct.name, useDirectives, true); if (!type.IsResolved()) { return; } var typeStruct = type as Core.TypeStruct; var fieldNum = TypeResolver.GetFieldNum(this.session, typeStruct); var fieldDestSpans = new Diagnostics.Span?[fieldNum]; var fieldRegs = new int[fieldNum]; for (var i = 0; i < fieldNum; i++) { fieldRegs[i] = funct.CreateRegister( TypeResolver.GetFieldType(this.session, typeStruct, i), false); } var fieldRegAccesses = new Core.DataAccess[fieldNum]; for (var i = 0; i < fieldNum; i++) { fieldRegAccesses[i] = Core.DataAccessRegister.ForRegister(exprLiteralStruct.name.GetSpan(), fieldRegs[i]); } foreach (var fieldInit in exprLiteralStruct.fields) { var name = NameResolver.Resolve(fieldInit.name); int fieldIndex; if (!this.session.GetStruct(typeStruct.structIndex).fieldNames.FindByName(name, out fieldIndex)) { this.foundErrors = true; session.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.Unknown, "unknown field '" + name.GetString() + "' in '" + type.GetString(this.session) + "'", fieldInit.name.GetSpan()); continue; } if (fieldDestSpans[fieldIndex].HasValue) { this.foundErrors = true; session.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.Unknown, "duplicate field '" + name.GetString() + "' initialization", fieldInit.name.GetSpan(), fieldDestSpans[fieldIndex].Value); continue; } fieldRegAccesses[fieldIndex].span = fieldInit.name.GetSpan(); fieldDestSpans[fieldIndex] = fieldInit.name.GetSpan(); this.ResolveExpr(fieldInit.expr, ref curSegment, fieldRegAccesses[fieldIndex]); } var missingFields = new List <int>(); for (var i = 0; i < fieldNum; i++) { if (!fieldDestSpans[i].HasValue) { missingFields.Add(i); } } if (missingFields.Count > 0) { Core.Name fieldName; session.GetStruct(typeStruct.structIndex).fieldNames.FindByValue(missingFields[0], out fieldName); this.foundErrors = true; session.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.Unknown, "missing initializer" + (missingFields.Count > 1 ? "s" : "") + " for field '" + fieldName.GetString() + "'" + (missingFields.Count > 1 ? " and other " + (missingFields.Count - 1) : ""), exprLiteralStruct.GetSpan()); } else { var finalFieldDestSpans = new Diagnostics.Span[fieldNum]; for (var i = 0; i < fieldNum; i++) { finalFieldDestSpans[i] = fieldDestSpans[i].Value; } funct.AddInstruction(curSegment, Core.InstructionMoveLiteralStruct.Of( exprLiteralStruct.GetSpan(), output, typeStruct.structIndex, fieldRegAccesses, finalFieldDestSpans)); } }
public void SetSpan(Diagnostics.Span span) { this.span = span; }
public void PushContext(string text, Diagnostics.Span span) { this.contextStack.Push(new Diagnostics.MessageContext(text, span)); }
public void AddSpan(Diagnostics.Span span) { this.span = this.span.Merge(span); }
private void ResolveExprLiteralStruct(Grammar.ASTNodeExprLiteralStruct exprLiteralStruct, ref int curSegment, Core.DataAccess output) { var type = TypeResolver.ResolveStruct(session, exprLiteralStruct.name, useDirectives, true); if (!type.IsResolved()) return; var typeStruct = type as Core.TypeStruct; var fieldNum = TypeResolver.GetFieldNum(this.session, typeStruct); var fieldDestSpans = new Diagnostics.Span?[fieldNum]; var fieldRegs = new int[fieldNum]; for (var i = 0; i < fieldNum; i++) { fieldRegs[i] = funct.CreateRegister( TypeResolver.GetFieldType(this.session, typeStruct, i), false); } var fieldRegAccesses = new Core.DataAccess[fieldNum]; for (var i = 0; i < fieldNum; i++) { fieldRegAccesses[i] = Core.DataAccessRegister.ForRegister(exprLiteralStruct.name.GetSpan(), fieldRegs[i]); } foreach (var fieldInit in exprLiteralStruct.fields) { var name = NameResolver.Resolve(fieldInit.name); int fieldIndex; if (!this.session.GetStruct(typeStruct.structIndex).fieldNames.FindByName(name, out fieldIndex)) { this.foundErrors = true; session.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.Unknown, "unknown field '" + name.GetString() + "' in '" + type.GetString(this.session) + "'", fieldInit.name.GetSpan()); continue; } if (fieldDestSpans[fieldIndex].HasValue) { this.foundErrors = true; session.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.Unknown, "duplicate field '" + name.GetString() + "' initialization", fieldInit.name.GetSpan(), fieldDestSpans[fieldIndex].Value); continue; } fieldRegAccesses[fieldIndex].span = fieldInit.name.GetSpan(); fieldDestSpans[fieldIndex] = fieldInit.name.GetSpan(); this.ResolveExpr(fieldInit.expr, ref curSegment, fieldRegAccesses[fieldIndex]); } var missingFields = new List<int>(); for (var i = 0; i < fieldNum; i++) { if (!fieldDestSpans[i].HasValue) missingFields.Add(i); } if (missingFields.Count > 0) { Core.Name fieldName; session.GetStruct(typeStruct.structIndex).fieldNames.FindByValue(missingFields[0], out fieldName); this.foundErrors = true; session.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.Unknown, "missing initializer" + (missingFields.Count > 1 ? "s" : "") + " for field '" + fieldName.GetString() + "'" + (missingFields.Count > 1 ? " and other " + (missingFields.Count - 1) : ""), exprLiteralStruct.GetSpan()); } else { var finalFieldDestSpans = new Diagnostics.Span[fieldNum]; for (var i = 0; i < fieldNum; i++) { finalFieldDestSpans[i] = fieldDestSpans[i].Value; } funct.AddInstruction(curSegment, Core.InstructionMoveLiteralStruct.Of( exprLiteralStruct.GetSpan(), output, typeStruct.structIndex, fieldRegAccesses, finalFieldDestSpans)); } }
public static InstructionMoveData Of(Diagnostics.Span span, DataAccess destination, DataAccess source) { return(new InstructionMoveData { span = span, destination = destination, source = source }); }
public static DataAccessField Of(Diagnostics.Span span, DataAccess baseAccess, int fieldIndex) { return(new DataAccessField { span = span, baseAccess = baseAccess, fieldIndex = fieldIndex }); }
public static DataAccessDereference Of(Diagnostics.Span span, DataAccess innerAccess) { return(new DataAccessDereference { span = span, innerAccess = innerAccess }); }
public static DataAccessRegister ForRegister(Diagnostics.Span span, int registerIndex) { return(new DataAccessRegister { span = span, registerIndex = registerIndex }); }
public static InstructionMoveLiteralBool Of(Diagnostics.Span span, DataAccess destination, bool value) { return(new InstructionMoveLiteralBool { span = span, destination = destination, value = value }); }
public int GetColumnAtSpanStart(Diagnostics.Span span) { return(this.GetColumnAtPos(span.start)); }
public int GetColumnAtSpanEnd(Diagnostics.Span span) { return(this.GetColumnAtPos(span.end)); }
public static InstructionMoveLiteralFunct With(Diagnostics.Span span, DataAccess destination, int functIndex) { return(new InstructionMoveLiteralFunct { span = span, destination = destination, functIndex = functIndex }); }
public int GetLineIndexAtSpanEnd(Diagnostics.Span span) { return(this.GetLineAtPos(span.end)); }
public MessageContext(string text, Diagnostics.Span span) { this.text = text; this.span = span; }
public Token(TokenKind kind, Diagnostics.Span span) { this.kind = kind; this.span = span; }
public static InstructionMoveLiteralInt Of(Diagnostics.Span span, DataAccess destination, Core.Type type, long value) { return(new InstructionMoveLiteralInt { span = span, destination = destination, type = type, value = value }); }
public static InstructionMoveAddr Of(Diagnostics.Span span, DataAccess destination, DataAccess source, bool mutable) { return(new InstructionMoveAddr { span = span, destination = destination, source = source, mutable = mutable }); }
public int GetLineIndexAtSpanStart(Diagnostics.Span span) { return(this.GetLineAtPos(span.start)); }