private TreeElement ParseLoop(TreeBuilder builder, TreeReader reader)
{
if (Value == "while" || Value == "do")
{
var cond = ParseToBracket(reader);
reader.Next();
var block = builder.ParseInBrackets('{', '}')[0];
if (Value == "while")
{
return(new WhileElement(this, cond, block));
}
return(new DoWhileElement(this, cond, block));
}
else if (Value == "for")
{
var cond = ParseToBracket(reader);
reader.Next();
VariableLexeme variable = null;
List <TreeElement> startValue = new List <TreeElement>();
List <TreeElement> endValue = new List <TreeElement>();
var block = builder.ParseInBrackets('{', '}')[0];
var dotCount = 0;
var toStartValue = true;
for (int i = 0; i < cond.Count; i++)
{
if (cond[i] is VariableLexeme variableLexeme && toStartValue)
{
variable = variableLexeme;
if (variableLexeme.Args.Count > 0)
{
Exception("Wrong for construction!");
}
}
else if (i == 0)
{
Exception("Wrong for construction!");
}
else if (cond[i] is SpecialLexeme specialLexeme && toStartValue && specialLexeme.Value == ".")
{
dotCount++;
if (dotCount == 3)
{
toStartValue = false;
}
}
public TreeElement ParseElement(TreeBuilder builder, TreeReader reader)
{
if (reader.Read(1) is SpecialLexeme specialLexeme && specialLexeme.Value == "{" && IsFuncBrackets)
{
reader.Next(2);
var args = new List <List <TreeElement> >()
{
new List <TreeElement>()
};
foreach (var treeElement in Block)
{
if (treeElement is SpecialLexeme special && special.Value == ",")
{
args.Add(new List <TreeElement>());
}
private TreeElement GetTreeElement(TreeElement element)
{
_reader.Next();
if (element is ILexeme lexeme)
{
var response = lexeme.ParseElement(this, _reader);
if (response == null)
{
return(GetTreeElement(_reader.Read()));
}
return(response);
}
return(element);
}
public string GetPart(TreeElement element)
{
_reader.Next();
if (element is IElement treeElement)
{
var response = treeElement.ParseCode(this, _reader);
if (response == null)
{
return(GetPart(_reader.Read()));
}
return(response);
}
return("");
}
public TreeElement ParseElement(TreeBuilder builder, TreeReader reader)
{
switch (Value)
{
case "@":
if (reader.Read() is VariableLexeme variableLexeme)
{
if (!builder.AvailableAttributes.Split(' ').Contains(variableLexeme.Value))
{
variableLexeme.Exception($"Unknown attribute \"{variableLexeme.Value}\"");
}
reader.Next();
return(new AttributeElement(variableLexeme));
}
return(null);
case "{":
var blockClass = new BlockElement(this, builder.ParseInBrackets('{', '}')[0]);
return(blockClass.ParseElement(builder, reader));
case "[":
return(ParseArray(builder, reader));
case ",": return(this);
case "(":
var block = new BlockElement(this, builder.ParseInBrackets('(', ')')[0])
{
IsFuncBrackets = true
};
return(block.ParseElement(builder, reader));
default: return(null);
}
}
public TreeElement ParseElement(TreeBuilder builder, TreeReader reader)
{
if (reader.Read() is SpecialLexeme specialLexeme)
{
if (specialLexeme.Value == "." || specialLexeme.Value == "[")
{
Args = ParseArrayBrackets(builder, reader);
}
}
// Этот иф нужен, так как в прошлом могли оказаться скобки от массива
if (reader.Read() is SpecialLexeme newSpecialLexeme)
{
if (newSpecialLexeme.Value == "{")
{
reader.Next();
var block = builder.ParseInBrackets('{', '}');
reader.Next();
return(new InvokeElement("it", this, block[0]));
}
if (newSpecialLexeme.Value == ":")
{
if (reader.Read(1) is VariableLexeme variableLexeme && reader.Read(2) is SpecialLexeme special &&
special.Value == "{")
{
if (variableLexeme.Args.Count > 0)
{
Exception("Wrong var name");
}
reader.Next(3);
var block = builder.ParseInBrackets('{', '}');
reader.Read();
return(new InvokeElement(variableLexeme.Value, this, block[0]));
}
else
{
FuncType type = builder.GetType(Value, builder.ParseAttributes());
reader.Next();
var body = builder.ParseToNewLine();
var declareField = new DeclareFieldElement(this, body, type);
var response = declareField.ParseElement(builder, reader);
return(response ?? declareField);
}
}
if (newSpecialLexeme.Value == "(")
{
reader.Next();
var args = builder.ParseInBrackets('(', ')', ',');
reader.Next();
var callFunction = new CallFunctionElement(this, args);
var response = callFunction.ParseElement(builder, reader);
return(response ?? callFunction);
}
}
public TreeElement ParseElement(TreeBuilder builder, TreeReader reader)
{
switch (Value)
{
case "for":
case "while":
case "do":
return(ParseLoop(builder, reader));
case "if":
return(ParseIf(builder, reader));
case "return":
return(new ReturnElement(this, builder.ParseToNewLine()));
case "try":
reader.Next();
var tryBlock = builder.ParseInBrackets('{', '}')[0];
reader.Next();
List <TreeElement> catchBlock = new List <TreeElement>();
List <TreeElement> finallyBlock = new List <TreeElement>();
VariableLexeme variableLexeme = null;
if (reader.Read() is KeywordLexeme keywordLexeme && keywordLexeme.Value == "catch")
{
reader.Next();
if (reader.Read() is SpecialLexeme specialLexeme && specialLexeme.Value == ":" &&
reader.Read(1) is VariableLexeme variable)
{
if (variable.Args.Count > 0)
{
Exception("Wrong name var in catch block");
}
variableLexeme = variable;
}
reader.Next(2);
catchBlock = builder.ParseInBrackets('{', '}')[0];
reader.Next();
}
if (reader.Read() is KeywordLexeme finallyKeyword && finallyKeyword.Value == "finally")
{
reader.Next();
finallyBlock = builder.ParseInBrackets('{', '}')[0];
reader.Next();
}
return(new TryElement(this, variableLexeme, tryBlock, catchBlock, finallyBlock));
case "import":
{
var block = builder.ParseToNewLine();
if (block.Count != 1)
{
Exception("Wrong import!");
}
if (block[0] is StringLexeme lexeme)
{
return(new ImportElement(this, lexeme.Value));
}
Exception("Wrong import!");
break;
}
case "export":
return(new ExportElement(this, builder.ParseToNewLine()));
case "fun" when reader.Read() is VariableLexeme name:
return(ParseFun(name, builder, reader));
}
return(this);
}
