public async Task <CompletionList> Handle(CompletionParams request, CancellationToken cancellationToken)
{
var text = _workspaceService.GetMarineFileBuffer(request.TextDocument.Uri.Path);
var tokens = new LexicalAnalyzer().GetTokens(text);
var result = new SyntaxAnalyzer().Parse(tokens);
var tasks = new List <Task <IEnumerable <CompletionItem> > >();
FuncDefinitionAst currentFuncDefAst = null;
if (result.programAst != null)
{
currentFuncDefAst = await Task.Run(() => GetCurrentFunctionAst(result.programAst, request.Position),
cancellationToken);
if (currentFuncDefAst != null)
{
tasks.Add(Task.Run(() => CreateFunctions(result.programAst), cancellationToken));
tasks.Add(Task.Run(() => CreateFunctionParamaters(currentFuncDefAst), cancellationToken));
tasks.Add(Task.Run(() => CreateVariables(currentFuncDefAst, request.Position), cancellationToken));
tasks.Add(Task.Run(CreateKeywords, cancellationToken));
}
}
tasks.Add(Task.Run(() => CreateSnippets(currentFuncDefAst), cancellationToken));
return(new CompletionList((await Task.WhenAll(tasks)).SelectMany(e => e)));
}
static void Main(string[] args)
{
//String text = "2*(2+4)";
String text = "/*my program*/" + "\n" +
"var mystring = \"some text\";" +
"var i = 1234;" +
"i = 0;" +
"while(i < 5) { print(i); i = i + 1; }";
//String text = "(2*(4+5)-(2*(2+1)))*2";
LexycalAnalyzer la = new LexycalAnalyzer();
SyntaxAnalyzer sa = new SyntaxAnalyzer();
List<Token> result = la.Parse(text);
//Console.WriteLine(sa.ParseExpressionDev(result).GetValue());
Console.WriteLine();
//Console.WriteLine(new SyntaxAnalyzer().FindClosingBracket(result, 24));
la.WriteTokens(result);
foreach (Token t in result)
{
Console.Write(t.data);
}
Command commands = new SyntaxAnalyzer().Analyze(result);
while (commands.nextCommand != null)
{
commands.execute();
commands = commands.nextCommand;
}
Console.Read();
}
public void GivenANewSyntaxComponent()
{
var lexer = ScenarioContext.Current.Get <ILexer>("newLexer");
var parser = new SyntaxAnalyzer(lexer);
ScenarioContext.Current.Add("parser", parser);
}
//REGEX; @"^(\'|\~)([a-zA-Z]+) ([a-zA-Z]+) (\d+)$"
void Start()
{
parser = FindObjectOfType <SyntaxAnalyzer>();
input = "";
dictionary = new Dictionary <int, string>();
}
public static void Analyze(
SyntaxNodeAnalysisContext context,
InvocationExpressionSyntax invocation,
MemberAccessExpressionSyntax memberAccess,
string methodName)
{
if (memberAccess.Expression?.IsKind(SyntaxKind.InvocationExpression) == true)
{
var invocation2 = (InvocationExpressionSyntax)memberAccess.Expression;
if (invocation2.ArgumentList?.Arguments.Count == 1 &&
invocation2.Expression?.IsKind(SyntaxKind.SimpleMemberAccessExpression) == true)
{
var memberAccess2 = (MemberAccessExpressionSyntax)invocation2.Expression;
if (memberAccess2.Name?.Identifier.ValueText == "Where" &&
SyntaxAnalyzer.IsEnumerableExtensionMethod(invocation, methodName, 1, context.SemanticModel, context.CancellationToken) &&
(SyntaxAnalyzer.IsEnumerableWhereOrImmutableArrayWhereMethod(invocation2, context.SemanticModel, context.CancellationToken)))
{
TextSpan span = TextSpan.FromBounds(memberAccess2.Name.Span.Start, invocation.Span.End);
if (!invocation.ContainsDirectives(span))
{
context.ReportDiagnostic(
DiagnosticDescriptors.SimplifyLinqMethodChain,
Location.Create(invocation.SyntaxTree, span));
}
}
}
}
}
internal static bool EvalExpression([MarshalAs(UnmanagedType.LPWStr)] string expr, IntPtr opaque, out IntPtr errorText, out int typeId, out int size, out IntPtr result)
{
SyntaxAnalyzer sa = new SyntaxAnalyzer(expr);
StringBuilder scriptText = new StringBuilder("#line hidden\n");
// Generate prefix with variables assignment to __context members
foreach (string us in sa.unresolvedSymbols)
{
scriptText.AppendFormat("var {0} = __context.{0};\n", us);
}
scriptText.Append("#line 1\n");
scriptText.Append(expr);
errorText = IntPtr.Zero;
result = IntPtr.Zero;
typeId = 0;
size = 0;
try
{
var scriptOptions = ScriptOptions.Default
.WithImports("System")
.WithReferences(typeof(Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo).Assembly);
var script = CSharpScript.Create(scriptText.ToString(), scriptOptions, globalsType: typeof(Globals));
script.Compile();
var returnValue = script.RunAsync(new Globals {
__context = new ContextVariable(opaque, IntPtr.Zero)
}).Result.ReturnValue;
if (returnValue is ContextVariable)
{
typeId = -1;
result = (returnValue as ContextVariable).m_corValue;
}
else
{
if (returnValue is null)
{
typeId = 0;
return(true);
}
for (int i = 1; i < basicTypes.Length; i++)
{
if (returnValue.GetType() == Type.GetType(basicTypes[i]))
{
typeId = i;
MarshalValue(returnValue, out size, out result);
return(true);
}
}
return(false);
}
}
catch (Exception e)
{
errorText = Marshal.StringToBSTR(e.ToString());
return(false);
}
return(true);
}
public TelemetryFilter()
{
List <TraceAggregationConfig> traceAggregationConfigs;
List <ParseResult> parseResults = SyntaxAnalyzer.Parse(ConfigFileName, new string[] { }, Utility.TraceSource.WriteError, false, out traceAggregationConfigs);
foreach (var telConfig in traceAggregationConfigs)
{
try
{
// including the aggregator to white-list
this.whiteListedEventsFromConfigFile.Add(new Tuple <string, string>(telConfig.TaskName, telConfig.EventName), telConfig);
}
catch (ArgumentNullException e)
{
Utility.TraceSource.WriteError(LogSourceId, "Unexpected null value parsed from config file: {0} - Exception: {1}.", ConfigFileName, e);
}
catch (ArgumentException e)
{
if (telConfig.DifferentiatorFieldName == this.whiteListedEventsFromConfigFile[new Tuple <string, string>(telConfig.TaskName, telConfig.EventName)].DifferentiatorFieldName)
{
Utility.TraceSource.WriteWarning(LogSourceId, "Conflicting trace white-listing (trace already white-listed) -Trace: {0} - Exception : {1}.", telConfig, e);
}
}
}
// Tracing any errors that may have occured during parsing
foreach (var parseRes in parseResults)
{
if (parseRes.ParseCode != ParseCode.Success)
{
Utility.TraceSource.WriteError(LogSourceId, "{0}({1},{2}) : Error : {3}", ConfigFileName, parseRes.LineNumber, parseRes.ColumnPos + 1, parseRes.ErrorMsg);
}
}
}
private void button1_Click(object sender, EventArgs e)
{
f = false;
richTextBox6.Text = null;
TokenList2 = new LinkList();
LineNo = 1;
BreakWordList = new LinkList();
BreakWordList_Clear = new LinkList();
// richTextBox2.Text = null;
// richTextBox3.Text = null;
allText = richTextBox1.Text;
StringLenght = allText.Length;
//BreakWordFunction(allText);
break_words(allText);
// richTextBox2.Text = BreakWordList_Clear.DisplayList();
AddItemsInToken();
// richTextBox3.Text = TokenList.DisplayTokens();
//SyntaxAnalyzer SA = new SyntaxAnalyzer(TokenList);
CurrentNode123 = TokenList.GetHead();
OutNextLine();
richTextBox5.Text = TokenList2.DisplayTokens();
SyntaxAnalyzer SA = new SyntaxAnalyzer(TokenList2);
Do pa = new Do();
pa = SA.ABS();
if (pa.cppp == "Valid Syntax")
{
richTextBox4.Text = pa.cppp;
}
else
{
richTextBox4.Text = pa.cppp + "\n" + "Syntax Error on Line" + pa.cpline;
}
int i = 1;
while (i < 100)
{
richTextBox6.Text += i + "\n";
i++;
}
//StreamWriter streamWriter = new StreamWriter(@"C:\Users\Mahad Khan\source\repos\BreakWord\BreakWord\TokensFile.txt");
//streamWriter.WriteLine(richTextBox3.Text);
//streamWriter.Close();
BreakWordList = null;
TokenList = null;
TokenList2 = null;
}
public AnalyzerLEDEER(string xsentences)
{
//Set sentencias
sentences = xsentences;
//Construir análisis
lexan = new LexicalAnalyzer(); //Analizador léxico
synan = new SyntaxAnalyzer(lexan.createTableSymbol(sentences)); //Crear tabla de símbolo
}
public static bool CanRefactor(
InvocationExpressionSyntax invocation,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
if (SyntaxAnalyzer.IsEnumerableExtensionOrImmutableArrayExtensionMethod(invocation, "Select", 2, semanticModel, cancellationToken))
{
ArgumentListSyntax argumentList = invocation.ArgumentList;
if (argumentList?.IsMissing == false)
{
SeparatedSyntaxList <ArgumentSyntax> arguments = argumentList.Arguments;
if (arguments.Count == 1)
{
ArgumentSyntax argument = arguments.First();
ExpressionSyntax expression = argument.Expression;
if (expression?.IsMissing == false)
{
SyntaxKind expressionKind = expression.Kind();
if (expressionKind == SyntaxKind.SimpleLambdaExpression)
{
var lambda = (SimpleLambdaExpressionSyntax)expression;
if (CanRefactor(lambda.Parameter, lambda.Body))
{
return(true);
}
}
else if (expressionKind == SyntaxKind.ParenthesizedLambdaExpression)
{
var lambda = (ParenthesizedLambdaExpressionSyntax)expression;
ParameterListSyntax parameterList = lambda.ParameterList;
if (parameterList != null)
{
SeparatedSyntaxList <ParameterSyntax> parameters = parameterList.Parameters;
if (parameters.Count == 1 &&
CanRefactor(parameters.First(), lambda.Body))
{
return(true);
}
}
}
}
}
}
}
return(false);
}
public Compiler(LexicalAnalyzer lexicalAnalyzer,
SyntaxAnalyzer syntaxAnalyer,
SemanticsAnalyzer semanticsAnalyzer,
ObjectCodeGenerator objCodeGenerator)
{
this._lexicalAnalyzer = lexicalAnalyzer;
this._syntaxAnalyer = syntaxAnalyer;
this._semanticsAnalyer = semanticsAnalyzer;
this._objCodeGenerator = objCodeGenerator;
}
private void buttonAnalyze_Click(object sender, EventArgs e)
{
// Очищаем поле сообщений и таблицу распознанных токенов.
richTextBoxMessages.Clear();
dataGridViewRecognizedTokens.Rows.Clear();
treeViewSyntaxTree.Nodes.Clear(); // Очищаем дерево.
try
{
lexAn = GetMethod(richTextBoxInput.Lines);
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
return;
}
try
{
if (comboBoxTypeAnalyzer.SelectedIndex == 1)
{
SyntaxAnalyzer syntaxAnalyzer = new SyntaxAnalyzer(lexAn);
syntaxAnalyzer.ParseText(out SyntaxTreeNode treeRoot);
richTextBoxMessages.AppendText("Текст правильный");
VisualizeSyntaxTree(treeRoot); // Визуализируем синтаксическое дерево в компоненте treeViewSyntaxTree.
Generator generator = new Generator(treeRoot);
generator.GenerateStructuredText();
ShowOutputText(generator.OutputText);
}
else
{
int k = 0; // Инициализируем счетчик распознанных токенов.
// Цикл чтения текста от начала до конца.
do
{
lexAn.RecognizeNextToken(); // Распознаем очередной токен в тексте.
k++;
dataGridViewRecognizedTokens.Rows.Add(k, lexAn.Token.Value, lexAn.Token.Type,
lexAn.Token.LineIndex + 1,
lexAn.Token.SymStartIndex + 1); // Добавляем распознанный токен в таблицу.
}while (lexAn.Token.Type != TokenKind.EndOfText); // Цикл работает до тех пор, пока не будет возвращен токен "Конец текста".
richTextBoxMessages.AppendText("Текст правильный");
}
}
catch (AnalyzerException analyzerException)
{
richTextBoxMessages.AppendText(analyzerException.ToString()); // Добавляем описание ошибки в поле сообщений.
LocateCursorAtErrorPosition(analyzerException.LineIndex, analyzerException.SymIndex); // Располагаем курсор в исходном тексте на позиции ошибки.
}
}
private void AnalizeText()
{
lexAnalyzer.Source = tbCondition.Text;
syntaxAnalyzer = new SyntaxAnalyzer(lexAnalyzer, tbCondition.Dictionary.Keys.ToList());
listLexic.Items.Clear();
foreach (SyntaxToken token in syntaxAnalyzer.Tokens)
{
listLexic.Items.Add(token.ToString());
}
lexFormater = new LexicalFormater(lexAnalyzer);
tbResult.Text = lexFormater.Text;
if (syntaxAnalyzer == null)
{
return;
}
if (listMessages.Items.Count > 0)
{
listMessages.Items.Clear();
}
errors = new List <SyntaxToken>();
foreach (SyntaxToken token in syntaxAnalyzer.Tokens)
{
if (token.Qualifier != SyntaxToken.Qualifiers.Correct)
{
listMessages.Items.Add(token.ToString());
errors.Add(token);
if (errors.Count == 1)
{
lbMsg.Text = token.ToString();
lbMsg.ForeColor = Color.Red;
}
}
}
if (errors.Count == 0)
{
if (syntaxAnalyzer.Tokens.Count == 0 || syntaxAnalyzer.Tokens.Last().Type == Token.Types.Id ||
(syntaxAnalyzer.Tokens.Last().Type == Token.Types.None && (syntaxAnalyzer.Tokens.Count == 1 || syntaxAnalyzer.Tokens[syntaxAnalyzer.Tokens.Count - 2].Type == Token.Types.Id)))
{
lbMsg.Text = "Ready.";
lbMsg.ForeColor = Color.Black;
}
else
{
lbMsg.Text = "Incomplete condition.";
lbMsg.ForeColor = Color.Red;
}
}
btOk.Enabled = lbMsg.ForeColor == Color.Black;
SyntaxTree syntaxTree = new SyntaxTree();
syntaxTree.CreateTree(syntaxAnalyzer);
}
private void CheckVariablesUsage()
{
LexicalAnalyzer lexAnalyzer = new LexicalAnalyzer();
SyntaxAnalyzer syntaxAnalyzer;
foreach (Transition trans in TransitionsList)
{
if (trans is SimpleTransition strans)
{
lexAnalyzer.Source = strans.Condition;
syntaxAnalyzer = new SyntaxAnalyzer(lexAnalyzer, VariableCollection.GetConditionDictionary(trans.OwnerDraw.OwnerSheet).Keys.ToList());
foreach (SyntaxToken token in syntaxAnalyzer.Tokens)
{
if (token.Qualifier != SyntaxToken.Qualifiers.Correct)
{
MessagesList.Add(new CheckMessage(CheckMessage.MessageTypes.Error, string.Format("{0}: {1}.", trans.Name, token.ToString()), trans));
}
}
foreach (string outputOperation in strans.OutputsList)
{
string outputName = LexicalRules.GetOutputId(outputOperation);
if (!trans.OwnerDraw.OwnerSheet.Variables.InternalOutputs.Exists(output => output.Name == outputName))
{
MessagesList.Add(new CheckMessage(CheckMessage.MessageTypes.Error, "Output " + outputName + " is not defined in variables list.", trans));
}
}
}
}
foreach (DrawableObject obj in ObjectsTable)
{
if (obj is State state)
{
//state.EnterOutputsList.RemoveAll(str => !state.OwnerDraw.OwnerSheet.Variables.InternalOutputs.Exists(var => var.Name == LexicalAnalyzer.GetId(str)));
foreach (string outputOperation in state.EnterOutputsList)
{
string outputName = LexicalRules.GetOutputId(outputOperation);
if (!state.OwnerDraw.OwnerSheet.Variables.InternalOutputs.Exists(var => var.Name == LexicalAnalyzer.GetId(outputName)))
{
MessagesList.Add(new CheckMessage(CheckMessage.MessageTypes.Error, "Output " + outputName + " is not defined in variables list.", state));
}
}
//state.ExitOutputsList.RemoveAll(str => !state.OwnerDraw.OwnerSheet.Variables.InternalOutputs.Exists(var => var.Name == LexicalAnalyzer.GetId(str)));
foreach (string outputOperation in state.ExitOutputsList)
{
string outputName = LexicalRules.GetOutputId(outputOperation);
if (!state.OwnerDraw.OwnerSheet.Variables.InternalOutputs.Exists(var => var.Name == LexicalAnalyzer.GetId(outputName)))
{
MessagesList.Add(new CheckMessage(CheckMessage.MessageTypes.Error, "Output " + outputName + " is not defined in variables list.", state));
}
}
}
}
}
public void TestCodeGenerated()
{
const string expression = "1+2+3";
var lexicalAnalyser = new LexicalAnalyzer(expression, 0);
var syntaxAnalyzer = new SyntaxAnalyzer(lexicalAnalyser);
var node = syntaxAnalyzer.Expression(0);
var fileWriter = new FileWriter("");
var semanticAnalyzer = new SemanticAnalyzer(syntaxAnalyzer);
var codeGenerator = new CodeGenerator(semanticAnalyzer, fileWriter);
codeGenerator.GenerateCode(node);
Assert.True(File.Exists(path) && new FileInfo(path).Length != 0);
}
/************************
* INTERPRET CODE!
*************************/
private void Interpret()
{
clearConsole();
List <Token> tokens = lexAnalyze();
if (tokens != null)
{
SyntaxAnalyzer.analyze(tokens, this);
}
else
{
print("Error!");
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, AssignmentExpressionSyntax assignment)
{
ExpressionSyntax right = assignment.Right;
if (right?.IsKind(SyntaxKind.ObjectCreationExpression) == true)
{
var objectCreation = (ObjectCreationExpressionSyntax)right;
SemanticModel semanticModel = context.SemanticModel;
CancellationToken cancellationToken = context.CancellationToken;
if (SyntaxAnalyzer.IsEventHandlerOrGenericEventHandler(objectCreation, semanticModel, cancellationToken))
{
ArgumentListSyntax argumentList = objectCreation.ArgumentList;
if (argumentList != null)
{
SeparatedSyntaxList <ArgumentSyntax> arguments = argumentList.Arguments;
if (arguments.Count == 1)
{
ArgumentSyntax argument = arguments.First();
ExpressionSyntax expression = argument.Expression;
if (expression != null)
{
IMethodSymbol methodSymbol = semanticModel.GetMethodSymbol(expression, cancellationToken);
if (methodSymbol != null)
{
ExpressionSyntax left = assignment.Left;
if (left?.IsMissing == false &&
SyntaxAnalyzer.IsEvent(left, semanticModel, cancellationToken) &&
!objectCreation.SpanContainsDirectives())
{
context.ReportDiagnostic(DiagnosticDescriptors.RemoveRedundantDelegateCreation, right.GetLocation());
context.FadeOutToken(DiagnosticDescriptors.RemoveRedundantDelegateCreationFadeOut, objectCreation.NewKeyword);
context.FadeOutNode(DiagnosticDescriptors.RemoveRedundantDelegateCreationFadeOut, objectCreation.Type);
context.FadeOutParentheses(DiagnosticDescriptors.RemoveRedundantDelegateCreationFadeOut, objectCreation.ArgumentList);
}
}
}
}
}
}
}
}
private bool Compile()
{
CompileStatus.Text = "Compiling...";
if (Parser.Parse(MyTextEditor.Text.ToCharArray()))
{
try
{
SyntaxTree syntaxtree = SyntaxAnalyzer.GetTree(Parser.Tokens);
ArrayList InstructionCode = new ArrayList();
NumberAndIdentifierTable nids = new NumberAndIdentifierTable();
CodeGenerator.GenerateCode(InstructionCode, nids, syntaxtree);
if (CurrentFile == "")
{
CodeGenerator.SaveFile(InstructionCode, nids, Application.StartupPath + "\\Tempfile.imc");
}
else
{
FileInfo finfo = new FileInfo(CurrentFile);
CodeGenerator.SaveFile(
InstructionCode, nids, Path.ChangeExtension(CurrentFile, "imc"));
}
CompileStatus.Text = "Compilation process completed successfully.";
return(true);
}
catch (Exception exc)
{
MyTextEditor.Select((int)SyntaxAnalyzer.CurrentToken.startpointer,
(int)(SyntaxAnalyzer.CurrentToken.endpointer - SyntaxAnalyzer.CurrentToken.startpointer));
CompileStatus.Text = "Error occured, compilation failed.";
}
}
else
{
foreach (Token tkn in Parser.Tokens)
{
if (tkn.TType == TokenType.ERROR)
{
MyTextEditor.Select((int)tkn.startpointer,
(int)(tkn.endpointer - tkn.startpointer));
CompileStatus.Text = "Error occured, compilation failed.";
break;
}
}
}
return(false);
}
public static void Load(string block, Canvas canvas, Point upperLeftCorner)
{
LexicalAnalyzer la = new LexicalAnalyzer(block);
SyntaxAnalyzer sa = new SyntaxAnalyzer(la);
if (sa.IsValid)
{
BlockCreator bc = new BlockCreator(sa, upperLeftCorner);
foreach (TextBlock tb in bc.Blocks)
{
canvas.Children.Add(tb);
}
}
}
static void Main(string[] args)
{
do
{
Console.Write("Введите выражение: ");
string str = Console.ReadLine();
bool flag = false;
string buf1 = str;
int k = 0;
for (int i = 0; i < buf1.Length; i++)
{
if (buf1[i] == ',' || buf1[i] == ' ')
{
string buf;
buf = buf1.Substring(0, i);
if (buf.EndsWith("."))
{
Console.WriteLine("Лексема не должна заканчиваться точкой, исправьте");
buf1 = "";
flag = true;
break;
}
buf = buf + str[i];
buf1 = buf1.Replace(buf, "");
i = -1;
}
k++;
if (k == str.Length)
{
break;
}
}
if (flag == false)
{
//Console.WriteLine("Lexer: ");
//foreach (var lexem in lexems) //Цикл по полученному списку
//{
// Console.WriteLine(lexem.TokType + " " + lexem.Value);
//}
var lexems = LexicalAnalyzer.getLex(str); //Запуск лексического анализатора
SyntaxAnalyzer.getParse(lexems);
}
} while (end_enter() != "Да");
}
public static void AnalyzeSyntax(Token root)
{
SyntaxAnalyzer analyzer = new SyntaxAnalyzer();
Token srcs = root.Find("Sources");
Token syntax = root.Find("Syntax");
List<Token> synflw = new List<Token>();
foreach (Token f in srcs.Follows)
{
if (f.Group == "SourcePath") { continue; }
if (f.Group == "SourceText") { synflw.Add(analyzer.Run(f.Value, f.First.Value)); }
}
syntax.Follows = synflw.ToArray();
}
public static void InterpretingInConsole(this SSScope scope)
{
var w = new Stopwatch();
var file = new CodeFile();
var syntax = new SyntaxAnalyzer();
while (true)
{
file.ReSet();
syntax.ReSet();
try
{
Console.ForegroundColor = ConsoleColor.White;
Console.Write(">>> ");
String code;
if ((code = Console.ReadLine()).NotEmpty())
{
file.SourceCode = code;
file.Parse();
if (file.ErrorList.NotEmpty())
{
file.PrintErrors(Console.Out);
}
syntax.Take(file.TokenList);
if (syntax.ErrorList.NotEmpty())
{
syntax.PrintErrors(Console.Out);
}
Console.ForegroundColor = ConsoleColor.Green;
w.Reset();
w.Start();
Console.WriteLine(">>> " + syntax.Expressions.First().Evaluate(scope));
w.Stop();
Console.WriteLine(w.ElapsedMilliseconds + "ms");
}
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
// ex.StackTrace.Split("at".ToCharArray()).Take(3).ForEach(a => scope.Output.WriteLine(a));
}
}
}
private Container <Diagnostic> Validate(string text)
{
var tokens = new LexicalAnalyzer().GetTokens(text);
var result = new SyntaxAnalyzer().Parse(tokens);
if (result.IsError)
{
return
(new Container <Diagnostic>(result.parseErrorInfos.Select(e => new Diagnostic()
{
Range = ToRange(e.ErrorRangePosition),
Message = e.FullErrorMessage,
})));
}
return(new Container <Diagnostic>());
}
/// <summary>
/// 执行更新命令
/// </summary>
/// <param name="cmd">Command对象</param>
/// <param name="oql">对象查询语句</param>
/// <param name="parameters">参数列表</param>
/// <returns>影响的记录行数</returns>
internal static int ExcuteUpdateCommand(SqlCommand cmd, string oql, ParameterList parameters)
{
//解析过滤部份Sql语句
string updateString = SyntaxAnalyzer.ParseSql(oql, new JCUserMap());
cmd.CommandText = "update JC_User set " + updateString;
cmd.Parameters.Clear();
//添加参数
if (parameters != null)
{
foreach (string key in parameters.Keys)
{
cmd.Parameters.Add(new SqlParameter(key, parameters[key]));
}
}
return(cmd.ExecuteNonQuery());
}
public BlockCreator(SyntaxAnalyzer syntaxAnalyzer, Point upperLeft)
{
this.syntaxAnalyzer = syntaxAnalyzer;
this.upperLeft = upperLeft;
x = upperLeft.X;
y = 0;
blocks = new List<TextBlock>();
tokens = new Stack<Token>();
rows = new List<List<TextBlock>>();
rows.Add(new List<TextBlock>());
toCenter = new List<BlockSpan>();
Start();
CenterBlocks();
}
public static void Analyze(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax invocation, MemberAccessExpressionSyntax memberAccess)
{
if (SyntaxAnalyzer.IsEnumerableExtensionMethod(invocation, "Count", 1, context.SemanticModel, context.CancellationToken))
{
string propertyName = SyntaxHelper.GetCountOrLengthPropertyName(memberAccess.Expression, context.SemanticModel, allowImmutableArray: true, cancellationToken: context.CancellationToken);
if (propertyName != null)
{
TextSpan span = TextSpan.FromBounds(memberAccess.Name.Span.Start, invocation.Span.End);
if (invocation
.DescendantTrivia(span)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
Diagnostic diagnostic = Diagnostic.Create(
DiagnosticDescriptors.ReplaceCountMethodWithCountOrLengthProperty,
Location.Create(context.Node.SyntaxTree, span),
ImmutableDictionary.CreateRange(new KeyValuePair <string, string>[] { new KeyValuePair <string, string>("PropertyName", propertyName) }),
propertyName);
context.ReportDiagnostic(diagnostic);
}
}
else if (invocation.Parent?.IsKind(
SyntaxKind.EqualsExpression,
SyntaxKind.GreaterThanExpression,
SyntaxKind.LessThanExpression) == true)
{
var binaryExpression = (BinaryExpressionSyntax)invocation.Parent;
if (IsFixableBinaryExpression(binaryExpression))
{
TextSpan span = TextSpan.FromBounds(invocation.Span.End, binaryExpression.Span.End);
if (binaryExpression
.DescendantTrivia(span)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.ReportDiagnostic(
DiagnosticDescriptors.ReplaceCountMethodWithAnyMethod,
binaryExpression.GetLocation());
}
}
}
}
}
/// <summary>
/// Revisa si la sintaxis del escenario es correcta, recibe como parámetro las sentencias
/// </summary>
/// <returns></returns>
public bool CheckSyntaxB(string xsentences)
{
if (xsentences.CompareTo(String.Empty) != 0)
{
sentences = xsentences;
lexan = new LexicalAnalyzer(); //Analizador léxico nuevo
synan = new SyntaxAnalyzer(lexan.createTableSymbol(sentences)); //Crear tabla de símbolo nueva
ResultAnalysis ra = synan.checkSyntax();
if (ra.Error.Count == 0)
{
return(true);
}
return(false);
}
return(true);
}
public static void Analyze(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax invocation, MemberAccessExpressionSyntax memberAccess)
{
if (invocation.Parent?.IsKind(SyntaxKind.SimpleMemberAccessExpression) == false &&
SyntaxAnalyzer.IsEnumerableExtensionMethod(invocation, "Any", 1, context.SemanticModel, context.CancellationToken))
{
string propertyName = SyntaxHelper.GetCountOrLengthPropertyName(memberAccess.Expression, context.SemanticModel, allowImmutableArray: false, cancellationToken: context.CancellationToken);
if (propertyName != null)
{
string messageArg = null;
TextSpan span = TextSpan.FromBounds(memberAccess.Name.Span.Start, invocation.Span.End);
if (invocation.DescendantTrivia(span).All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
if (invocation.Parent?.IsKind(SyntaxKind.LogicalNotExpression) == true)
{
var logicalNot = (PrefixUnaryExpressionSyntax)invocation.Parent;
if (logicalNot.OperatorToken.TrailingTrivia.All(f => f.IsWhitespaceOrEndOfLineTrivia()) &&
logicalNot.Operand.GetLeadingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
messageArg = $"{propertyName} == 0";
}
}
else
{
messageArg = $"{propertyName} > 0";
}
}
if (messageArg != null)
{
Diagnostic diagnostic = Diagnostic.Create(
DiagnosticDescriptors.ReplaceAnyMethodWithCountOrLengthProperty,
Location.Create(context.Node.SyntaxTree, span),
ImmutableDictionary.CreateRange(new KeyValuePair <string, string>[] { new KeyValuePair <string, string>("PropertyName", propertyName) }),
messageArg);
context.ReportDiagnostic(diagnostic);
}
}
}
}
private static bool IsEnumerableElementAtMethod(
InvocationExpressionSyntax invocation,
SemanticModel semanticModel)
{
var methodSymbol = semanticModel.GetSymbolInfo(invocation).Symbol as IMethodSymbol;
if (methodSymbol?.ReducedFrom != null)
{
methodSymbol = methodSymbol.ReducedFrom;
return(methodSymbol.MetadataName == "ElementAt" &&
methodSymbol.Parameters.Length == 2 &&
methodSymbol.ContainingType?.Equals(semanticModel.Compilation.GetTypeByMetadataName("System.Linq.Enumerable")) == true &&
SyntaxAnalyzer.IsGenericIEnumerable(methodSymbol.Parameters[0].Type) &&
methodSymbol.Parameters[1].Type.IsInt32());
}
return(false);
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, ThrowStatementSyntax throwStatement)
{
ExpressionSyntax expression = throwStatement.Expression;
if (expression?.IsMissing == false &&
context.Span.IsContainedInSpanOrBetweenSpans(throwStatement))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(expression, context.CancellationToken);
if (typeSymbol?.IsErrorType() == false &&
SyntaxAnalyzer.IsException(typeSymbol, semanticModel))
{
MemberDeclarationSyntax member = GetContainingMember(throwStatement);
if (member != null)
{
SyntaxTrivia trivia = member.GetSingleLineDocumentationComment();
if (trivia.IsSingleLineDocumentationCommentTrivia())
{
var comment = trivia.GetStructure() as DocumentationCommentTriviaSyntax;
if (comment?.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia) == true)
{
string exceptionName = typeSymbol
.ToMinimalDisplayString(semanticModel, trivia.FullSpan.End)
.Replace('<', '{')
.Replace('>', '}');
if (!ContainsException(comment, typeSymbol, semanticModel, context.CancellationToken))
{
context.RegisterRefactoring(
"Add exception to documentation comment",
cancellationToken => RefactorAsync(context.Document, trivia, exceptionName, cancellationToken));
}
}
}
}
}
}
}
private static string GetCountOrLengthPropertyName(
ExpressionSyntax expression,
SemanticModel semanticModel,
CancellationToken cancellationToken = default(CancellationToken))
{
ITypeSymbol typeSymbol = semanticModel
.GetTypeInfo(expression, cancellationToken)
.Type;
if (typeSymbol?.IsErrorType() == false &&
!SyntaxAnalyzer.IsGenericIEnumerable(typeSymbol))
{
if (typeSymbol.BaseType?.SpecialType == SpecialType.System_Array)
{
return("Length");
}
if (SyntaxAnalyzer.IsGenericImmutableArray(typeSymbol, semanticModel))
{
return("Length");
}
ImmutableArray <INamedTypeSymbol> allInterfaces = typeSymbol.AllInterfaces;
for (int i = 0; i < allInterfaces.Length; i++)
{
if (allInterfaces[i].ConstructedFrom.SpecialType == SpecialType.System_Collections_Generic_ICollection_T)
{
foreach (ISymbol members in typeSymbol.GetMembers("Count"))
{
if (members.IsProperty() &&
members.IsPublic())
{
return("Count");
}
}
}
}
}
return(null);
}
public static void BulkEval(this SSScope scope, string src)
{
if (!src.NotEmpty())
{
return;
}
var file = new CodeFile();
var syntax = new SyntaxAnalyzer();
file.SourceCode = src;
file.Parse();
if (file.ErrorList.Count > 0)
{
scope.Output.WriteLine("Errors:");
syntax.ErrorList.ForEach(a => scope.Output.WriteLine(a.ToString()));
return;
}
syntax.Take(file.TokenList);
if (syntax.ErrorList.NotEmpty())
{
scope.Output.WriteLine("Errors:");
syntax.ErrorList.ForEach(a => scope.Output.WriteLine(a.ToString()));
return;
}
try
{
// prevent lazy eval
foreach (var exp in syntax.Expressions)
{
exp.Evaluate(scope); //);
}
}//
catch (Exception ex)
{
scope.Output.WriteLine("Failed to evaluate");
scope.Output.WriteLine(ex);
ex.StackTrace.Split('\r').Take(3).ForEach(a => scope.Output.WriteLine(a));
}
// scope.VariableTable.ForEach(a => scope.Output.WriteLine(">>> Added {0} : {1} "
// .Fmt(a.Key, a.Value.GetType())));
}
static void Main(string[] args)
{
string sourcePath = "";
if (args.Any())
{
sourcePath = args[0];
}
else
{
Console.Write($"Paste source file need to compile:{Environment.NewLine}" +
"> ");
sourcePath = Console.ReadLine();
}
try
{
LexicalAnalyzer.Parse(sourcePath);
SyntaxAnalyzer.Parse();
Console.WriteLine("Синтаксический анализ окончен");
SemanticAnalyzer.Parse();
Console.WriteLine("Семантический анализ окончен");
if (!(IsSyntaxCorrect && Root.IsSemanticCorrect))
{
Console.WriteLine("Возникли ошибки сборки. Ассемблерный код не будет сгенерирован");
}
else
{
Root.GenerateIntermediateCode();
GeneratingAssembleCode.Generate();
Console.WriteLine("Ассемблерный код сгенерирован");
}
}
catch (CompilerException e)
{
Console.WriteLine(e.Message);
}
Console.WriteLine("Press any key to finish...");
Console.ReadLine();
}
private static bool IsImmutableArrayExtensionMethod(
InvocationExpressionSyntax invocation,
string methodName,
SemanticModel semanticModel)
{
var methodSymbol = semanticModel
.GetSymbolInfo(invocation)
.Symbol as IMethodSymbol;
if (methodSymbol?.ReducedFrom != null)
{
methodSymbol = methodSymbol.ReducedFrom;
return(methodSymbol.MetadataName == methodName &&
methodSymbol.Parameters.Length == 1 &&
methodSymbol.ContainingType?.Equals(semanticModel.Compilation.GetTypeByMetadataName("System.Linq.ImmutableArrayExtensions")) == true &&
SyntaxAnalyzer.IsGenericImmutableArray(methodSymbol.Parameters[0].Type, semanticModel));
}
return(false);
}
public SyntaxAnalyzerFxt()
{
Analyzer = new SyntaxAnalyzer();
}
public static void Tokenize(string[] args, Box<bool> quit, LineEditMode lem)
{
string src;
src = Cty.ToText(lem.Lines);
SyntaxAnalyzer p = new SyntaxAnalyzer();
p.Init(src, "");
ITokenEnumerator tkz = p.Tokens;
while (tkz.EOF == false)
{
lem.CW.WN(tkz.Cur.ToString());
tkz.Next();
}
}