private void AddUsages(SemanticOperator @operator)
{
if (@operator is INameable nameable)
{
SemanticItem.AddUsages(nameable, RightOperand.Token);
}
}
internal void MakeLast()
{
SemanticItem last = _items.Last();
_items.Remove(last);
IsLast = true;
}
public override string PrettyPrinter(EPrettyPrinterMode mode = EPrettyPrinterMode.WithBody, bool printNext = false, int tabLevel = 0)
{
SemanticItem bodyItem = _items.LastOrDefault(x => HasType(EItemType.Body)) ?? _items.Last();
string firstLine = "";
for (var i = 0; i < tabLevel; ++i)
{
firstLine += SystemNames.Tab;
}
for (var i = 0; i < _items.Count && _items[i] != bodyItem; ++i)
{
firstLine += _items[i].PrettyPrinter();
}
firstLine += bodyItem.PrettyPrinter();
string childText = "";
if (Child != null)
{
childText = "\n" + Child.PrettyPrinter(mode, true, tabLevel + 1);
}
string lastLine = "";
if (bodyItem != _items.Last())
{
lastLine += "\n";
for (var i = 0; i < tabLevel; ++i)
{
lastLine += SystemNames.Tab;
}
var index = _items.IndexOf(bodyItem);
for (var i = index + 1; i < _items.Count; ++i)
{
lastLine += _items[i].PrettyPrinter();
}
}
string nextLine = "";
if (printNext && Next != null)
{
nextLine = "\n" + Next.PrettyPrinter(mode, true, tabLevel);
}
return(mode switch
{
EPrettyPrinterMode.FirstLine => firstLine,
EPrettyPrinterMode.LastLine => lastLine,
EPrettyPrinterMode.WithoutBody => firstLine + lastLine,
EPrettyPrinterMode.WithBody => firstLine + childText + lastLine + nextLine,
_ => null,
});
public TypeParameter(SemanticItem parameters, string mode, bool isLast)
: base(parameters)
{
_items = new Grammar().CreateItems(this);
ModeWord = (Word)_items.First(x => x.HasType(EItemType.ModeModifier));
TypeWord = _items.First(x => x.HasType(EItemType.Type));
ModeWord.SetText(mode);
_items.Add(new Word(this, ", ", EItemType.Body));
}
public void Focus(SemanticItem item, bool isInterrupted = false, bool isTextBody = false)
{
OldItem = CurrentItem;
CurrentItem = item;
if (CurrentItem is SemanticOperator)
{
CurrentOperator = (SemanticOperator)CurrentItem;
}
else
{
CurrentOperator = CurrentItem.Operator;
}
}
internal override void CopyFrom(SemanticItem item)
{
var parameter = (TypeParameter)item;
IsLast = parameter.IsLast;
_items.Clear();
for (var i = 0; i < parameter._items.Count; ++i)
{
_items.Add(parameter._items[i] is SimpleType
? new SimpleType(this, "", EItemType.General)
: new Word(this, "", EItemType.General));
_items[i].CopyFrom(parameter._items[i]);
}
ModeWord = (Word)_items.First(x => x.HasType(EItemType.ModeModifier));
TypeWord = _items.First(x => x.HasType(EItemType.Type));
}
public ClassParameter(SemanticItem item)
: base(item)
{
}
public List <SemanticItem> CreateItems(SemanticItem semanticItem)
{
_result = new List <SemanticItem>();
return(_result);
}
internal override void CopyFrom(SemanticItem item)
{
throw new NotImplementedException();
}
public ProcedureType(SemanticItem parent)
: base(parent)
{
}
internal override void InsertItem(int index, SemanticItem item)
{
throw new NotImplementedException();
}
public ArrayType(SemanticItem parent)
: base(parent)
{
}
public Expression(SemanticItem item) : base(item)
{
_items.Add(new Token(this, "", ETokenType.Operand));
BuildTree();
}
private SemanticOperator GetOperatorFromSimpleType(SimpleType leftType)
{
if (StringAnalyzer.IsClassOrModuleMember(leftType.Text))
{
var classOrModuleName = StringAnalyzer.GetClassOrModuleName(leftType.Text);
var memberName = StringAnalyzer.GetMemberName(leftType.Text);
if (Token.Tree.Project.HasModuleWithName(classOrModuleName))
{
var tree = Token.Tree.Project.GetModuleByName(classOrModuleName);
var record = tree.GetDeclaredTypes().FirstOrDefault(x => x.NameWord.Text == memberName);
// record?.
if (record != null)
{
var member = record.GetMembers()
.FirstOrDefault(x => ((INameable)x).NameWord.Text.Equals(Name));
if (member != null)
{
return(member);
}
SemanticError error = null;
if (Parent is FunctionToken)
{
error = new ClassMissingMethod(Token.Operator, RightOperand.Words, record, Name);
}
else if (Parent is ArrayToken)
{
error = new ClassMissingArray(Token.Operator, RightOperand.Words, record, Name);
}
else
{
error = new ClassMissingField(Token.Operator, RightOperand.Words, record, Name);
}
GenerateFind(error);
}
}
}
else
{
var record = Token.Tree.GetDeclaredTypes()
.FirstOrDefault(x => x.NameWord.Text.Equals(leftType.Text));
if (record != null)
{
var member = record.GetMembers()
.FirstOrDefault(x => ((INameable)x).NameWord.Text.Equals(Name));
if (member != null)
{
return(member);
}
SemanticError error = null;
if (Parent is FunctionToken)
{
error = new ClassMissingMethod(Token.Operator, RightOperand.Words, record, Name);
}
else if (Parent is ArrayToken)
{
error = new ClassMissingArray(Token.Operator, RightOperand.Words, record, Name);
}
else
{
error = new ClassMissingField(Token.Operator, RightOperand.Words, record, Name);
}
GenerateFind(error);
}
else
{
var import = Token.Tree.GetImports()
.FirstOrDefault(x => x.NameWord.Text.Equals(leftType.Text));
if (import != null)
{
if (!Token.Tree.Project.HasModuleWithName(import.NameWord.Text))
{
GenerateFind(new UndeclaredModule(Token.Operator, LeftOperand.Words, import.NameWord.Text));
}
else
{
var tree = Token.Tree.Project.GetModuleByName(import.NameWord.Text);
var module = tree.FindModule();
if (module != null)
{
SemanticItem.AddUsages(module, LeftOperand.Token);
var member = tree.GetMembers()
.FirstOrDefault(x => ((INameable)x).NameWord.Text.Equals(Name));
if (member != null)
{
return(member);
}
SemanticError error = null;
if (Parent is FunctionToken)
{
error = new ModuleMissingFunction(Token.Operator, RightOperand.Words, tree.FindModule(), Name);
}
else if (Parent is ArrayToken)
{
error = new ModuleMissingArray(Token.Operator, RightOperand.Words, tree.FindModule(), Name);
}
else
{
error = new ModuleMissingVariable(Token.Operator, RightOperand.Words, tree.FindModule(), Name);
}
GenerateFind(error);
}
}
}
}
}
return(null);
}
public override SemanticItem GetPreviousItem(SemanticItem currentItem) => throw new NotImplementedException();
public override ISemanticType GetSemanticType()
{
if (Function is DotToken dotToken)
{
dotToken.GetSemanticType();
if (dotToken.LeftType is ArrayType && SystemNames.ArraySizes.Contains(dotToken.Name))
{
return(SimpleType.Integer);
}
var subprogram = dotToken.GetSubprogram();
if (subprogram != null)
{
ValidateParameters(subprogram.ParametersWord);
return(GetSubprogramType(subprogram));
}
GenerateFind(new ObjectIsNotSubprogram(
dotToken.RightOperand.Token.Operator,
dotToken.RightOperand.Token.Words,
dotToken.RightOperand.Token.Text));
}
if (Function is OperandToken operandToken)
{
if (operandToken.Name.Equals(SyntaxNames.New))
{
const int formalCount = 1;
var actualCount = Arguments.Count;
for (var i = 0; i < actualCount; ++i)
{
var actualType = Arguments[i].GetSemanticType();
if (i < formalCount)
{
if (!actualType.IsUserType)
{
GenerateFind(new ArgumentHasIncorrectType(Token.Operator, Arguments[i].Words));
}
}
}
if (actualCount != formalCount)
{
GenerateFind(new IncorrectArgumentCount(Token.Operator, Function.Words, actualCount, formalCount));
return(SimpleType.Undefined);
}
return(new PointerType(null)
{
TypeWord = (SemanticItem)Arguments[0].GetSemanticType()
});
}
if (operandToken.Name.StartsWith(SystemNames.SystemFuncDog))
{
foreach (var token in Arguments)
{
token.GetSemanticType();
}
return(SimpleType.SystemType);
}
var name = Token.GetNameInSameScope(operandToken.Name);
if (name is Subprogram subNameable)
{
SemanticItem.AddUsages(name, Function.Token);
ValidateParameters(subNameable.ParametersWord);
return(GetSubprogramType(subNameable));
}
if (name is TypeParameter {
TypeWord : ProcedureType type
})
protected SimpleItem(SemanticItem parent)
: base(parent)
{
}
public override SemanticItem GetNextItem(SemanticItem currentItem)
{
return(null);
}
public TextBody(SemanticItem parent)
: base(parent)
{
}
public PointerType(SemanticItem parent)
: base(parent)
{
}
public override SemanticItem GetPreviousItem(SemanticItem currentItem)
{
return(null);
}
protected static void GenerateFind(SemanticFind find) => SemanticItem.GenerateFind(find);
public override SemanticItem GetNextItem(SemanticItem currentItem)
{
throw new NotImplementedException();
}
