private void compilar() { this.setTextoAreaMensagem(""); Lexico lexico = new Lexico(this.areaEditor.Text); Sintatico sintatico = new Sintatico(); Semantico semantico = new Semantico(); try { lexico.analisar(); sintatico.analisar(lexico, semantico); this.setTextoAreaMensagem("programa compilado com sucesso"); } catch (LexicalError e) { this.setTextoAreaMensagem(e.Message); } catch (SyntaticError e) { this.setTextoAreaMensagem(e.Message); } catch (SemanticError e) { this.setTextoAreaMensagem(string.Format("Erro: {0}", e.Message)); } }
public void CanUseConcreteTypeForUserObject() { var myUserObject = 3.14f; var obj = Lexico.Parse <ClassWithConcreteUserObject>("5", userObject: myUserObject); Assert.Equal(myUserObject, obj.UserObject); }
public void CanRetrieveUserObject() { var myUserObject = new object(); var obj = Lexico.Parse <ClassWithUserObject>("5", userObject: myUserObject); Assert.Equal(myUserObject, obj.UserObject); }
public void CanRetrieveUserObjectValueType() { var myUserObject = 3.14f; var obj = Lexico.Parse <ClassWithUserObject>("5", userObject: myUserObject); Assert.Equal(myUserObject, obj.UserObject); }
public static void Main(String[] args) { SCG.IComparer <Rec <string, int> > lexico1 = new Lexico(); SCG.IComparer <Rec <string, int> > lexico2 = new DelegateComparer <Rec <string, int> >( delegate(Rec <string, int> item1, Rec <string, int> item2) { int major = item1.X1.CompareTo(item2.X1); return(major != 0 ? major : item1.X2.CompareTo(item2.X2)); }); Rec <String, int> r1 = new Rec <String, int>("Carsten", 1962); Rec <String, int> r2 = new Rec <String, int>("Carsten", 1964); Rec <String, int> r3 = new Rec <String, int>("Christian", 1932); Console.WriteLine(lexico1.Compare(r1, r1) == 0); Console.WriteLine(lexico1.Compare(r1, r2) < 0); Console.WriteLine(lexico1.Compare(r2, r3) < 0); Console.WriteLine(lexico2.Compare(r1, r1) == 0); Console.WriteLine(lexico2.Compare(r1, r2) < 0); Console.WriteLine(lexico2.Compare(r2, r3) < 0); SCG.IComparer <String> rev = ReverseComparer <String>(Comparer <String> .Default); Console.WriteLine(rev.Compare("A", "A") == 0); Console.WriteLine(rev.Compare("A", "B") > 0); Console.WriteLine(rev.Compare("B", "A") < 0); }
public void executa(string comandos) { try { tabResultado.SelectedIndex = 0; clearMensagem(); Stopwatch sw = new Stopwatch(); sw.Start(); addMensagem("Executando..."); Semantico semantico = new Semantico(this); Lexico lexico = new Lexico(comandos); Sintatico sintatico = new Sintatico(); sintatico.parse(lexico, semantico); semantico.Dispose(); semantico = null; sw.Stop(); Base.getInstance().commit(); TimeSpan tempo = sw.Elapsed; addMensagem(String.Format("Sucesso!!! Tempo de Execução: {0}min {1}s {2}ms", tempo.Minutes, tempo.Seconds, tempo.Milliseconds)); } catch (Exception ex) { addMensagem("#ERROR: " + ex.ToString()); //Console.WriteLine(ex.StackTrace); } }
private TestTrace <TParserToCheck> TestParse <TTopParser, TParserToCheck>(string parseString) { var rtn = new TestTrace <TParserToCheck>(); var result = Lexico.Parse <TTopParser>(parseString, rtn); return(rtn); }
public void LexicoJsonWithNoOpTrace() { var result = Lexico.Parse <JsonDocument>(JsonString, new NoTrace()); if (result.value == null) { throw new Exception("Parsing failed"); } }
private void ProcessarPrograma(Lexico lexico) { Token t = lexico.NextToken(); while (t != null) { t = lexico.NextToken(); } }
public void IndirectAlternative(Type parseType, string expression, bool passes) { if (passes) { Assert.True(Lexico.TryParse(expression, parseType, out _, new ConsoleDeveloperTrace())); } else { Assert.False(Lexico.TryParse(expression, parseType, out _, new ConsoleDeveloperTrace())); } }
public void ExplicitAlternative(string expression, bool passes) { if (passes) { Assert.True(Lexico.TryParse(expression, out Truthy _, new ConsoleDeveloperTrace())); } else { Assert.False(Lexico.TryParse(expression, out Truthy _, new ConsoleDeveloperTrace())); } }
private void compilar() { if (arquivo == "") { salvarArquivo(); } richTextBox2.Clear(); Lexico lexico = new Lexico(); Sintatico sintatico = new Sintatico(); Semantico semantico = null; semantico = Semantico.GetInstance(); lexico.setInput(richTextBox1.Text); string arq = Path.GetFileNameWithoutExtension(statusStrip1.Items[1].ToString()); semantico.NomeArq = arq; try { sintatico.parse(lexico, semantico); richTextBox2.AppendText("programa compilado com sucesso"); this.compilado = true; Token t = null; /* richTextBox2.AppendText("linha\t\tclasse\t\t\tlexema"+Environment.NewLine); * while ( (t = lexico.nextToken()) != null ) * { * richTextBox2.AppendText(t.Position + "\t\t"+ t.getTipoToken() +"\t\t" +t.Lexeme +Environment.NewLine); * * }*/ } catch (LexicalError e) { richTextBox2.Clear(); richTextBox2.AppendText(" Erro na linha " + e.getPosition() + " - " + e.Message + Environment.NewLine); } catch (SyntaticError e) { richTextBox2.Clear(); richTextBox2.AppendText(" Erro na linha " + e.getPosition() + " - " + e.Message + Environment.NewLine); } catch (SemanticError e) { richTextBox2.Clear(); richTextBox2.AppendText(" Erro na linha " + e.getPosition() + " - " + e.Message + Environment.NewLine); } catch (Exception e) { richTextBox2.Clear(); richTextBox2.AppendText(" Erro não tratado/previsto: - " + e.Message + Environment.NewLine + e.StackTrace); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void parse(Lexico scanner, Semantico semanticAnalyser) throws LexicalError, SyntaticError, SemanticError public virtual void parse(Lexico scanner, Semantico semanticAnalyser) { this.scanner = scanner; this.semanticAnalyser = semanticAnalyser; stack.Clear(); stack.Push(new int?(Constants_Fields.DOLLAR)); stack.Push(new int?(ParserConstants_Fields.START_SYMBOL)); currentToken = scanner.nextToken(); while (!step()) { ; } }
public void parse(Lexico scanner, Semantico semanticAnalyser) { this.scanner = scanner; this.semanticAnalyser = semanticAnalyser; stack.Clear(); stack.Push(DOLLAR); stack.Push((parserConst.START_SYMBOL)); currentToken = scanner.nextToken(); while (!step()) { ; } }
private void analizarToolStripMenuItem_Click(object sender, EventArgs e) { salida.Text = ""; seleccion.Items.Clear(); documentos.Items.Clear(); img.Image = null; TabPage n = entrada.SelectedTab; RichTextBox t = (RichTextBox)n.Controls[0]; if (t.Text != "") { Lexico temp = new Lexico(t.Text, salida, seleccion, documentos); temp.Analizar(); } }
private void button1_Click(object sender, EventArgs e) { scanner = new Lexico(); if (txtInput.Text.Length != 0) { scanner.autamataFinitoDeterministico(txtInput.Text); if (!scanner.tablaErrores.Any()) { Console.WriteLine("No hay errores"); } else Console.WriteLine("Exiten errores"); } else Console.WriteLine("No hay nada para analizar"); }
public bool Compile(string programa) { Sintatico sintatico = new Sintatico(); programa = programa.Trim(); if (string.IsNullOrWhiteSpace(programa)) { return(false); } try { Lexico lexico = new Lexico(programa); Semantico semantico = new Semantico(); sintatico.Parse(lexico, semantico); ProcessarPrograma(lexico); Assembly = string.Join(Environment.NewLine, semantico.Codigo); return(true); } catch (LexicalException ex) { throw new LexicalException(string.Format("Erro na linha {0}: {1}", GetLine(programa, ex.Position), ex.Message)); } catch (SyntaticException ex) { throw new SyntaticException(string.Format("Erro na linha {0}: encontrado {1} esperado {2}", GetLine(programa, ex.Position), sintatico.CurrentToken.Lexeme, ex.Message)); } catch (SemanticException ex) { throw new SemanticException(string.Format("Erro na linha {0}: {1}", GetLine(programa, ex.Position), ex.Message)); } catch (Exception ex) { throw new Exception(string.Format("Erro desconhecido: {0} {1}{1}{2}", ex.Message, Environment.NewLine, ex.StackTrace)); } }
private void BtnCompilar_Click(object sender, RoutedEventArgs e) { var sourceCode = new TextRange(CodigoFonte.Document.ContentStart, CodigoFonte.Document.ContentEnd).Text; if (sourceCode == "" || sourceCode == "\r\n") { MessageBox.Show("Não há nada para ser compilado!\nPor favor digite um código fonte.", "Atenção!", MessageBoxButton.OK, MessageBoxImage.Information); return; } Lexico.ScanText(sourceCode); if (Lexico.ContemErroLexico) { var erros = Lexico.Tokens.Where(t => t.Tag == SimpleCompilerService.Suporte.Tag.ERRO_LEXICO).ToList(); Console.Text = ErroLexico(erros); } else { try { Sintatico.Analyze(); var sucesso = "Análise Léxica ✓\r\nAnálise Sintática ✓\r\nAnálise Semântica ✓\r\n\r\nHora: " + DateTime.Now.ToLongTimeString(); Console.Text = sucesso; } catch (Exception ex) { if (ex.Message.Contains("#sintatico#")) { Console.Text = ErroSintatico(ex.Message); } else { Console.Text = ErroSemantico(ex.Message); } } } }
static int Main(string[] args) { /* * if (args.Length == 0) { * Console.WriteLine("Digite o nome do arquivo de entrada!"); * return 1; * }*/ //var path = System.IO.Path.Combine(Environment.CurrentDirectory, args[0]); var path = "Teste.c"; if (System.IO.File.Exists(path)) { io = new ModuloIO(path); analisadorLexico = new Lexico(); analisadorLexico.Executa(io); io.SalvaTokens(analisadorLexico.ListaTokens); foreach (Token tk in analisadorLexico.ListaTokens) { Console.WriteLine(tk.ToString()); } if (analisadorLexico.Status) { analisadorSintatico = new Sintatico(analisadorLexico.ListaTokens); analisadorSintatico.Programa(); Debuga(); } return(0); } else { Console.WriteLine("Arquivo não existe!"); return(1); } }
public void WritePrivateSetProperty() => Assert.Equal(5, Lexico.Parse <GetOnlyPropWithPrivateSet>("5").Value);
public void CannotWriteGetOnlyProperty() => Assert.NotEqual(5, Lexico.Parse <GetOnlyProp>("5").Value);
public void EmptyUserTraceDoesntBlowUp() { var result = Lexico.TryParse("5", out int i, new UserTrace(Console.WriteLine)); }
public void SeperatorWithinRepeatedRecursive() => Lexico.Parse <List <RecBase> >("foobar,bar") .Should() .ContainEquivalentOf(new Recursive { RecBase = { new LiteralCase(), new LiteralCase() } });
public Parser(Lexico.Lexico lexer) { lex = lexer; currentToken = lex.NextToken(); }
public void OrderOfGenericSequenceCorrect() => Lexico.Parse <GenericWrapper>(" 5 ", new ConsoleDeveloperTrace());
public void OrderOfSequenceCorrect() { Assert.True(Lexico.TryParse(" 5 ", out NonGenericSequence _, new ConsoleDeveloperTrace())); }
regexPattern, config, flags); // TODO: Don't pass in regexPattern, retrieve it by unparsing public static IParser Parse(string pattern, IConfig config, ParserFlags flags) => Lexico.Parse <Regex>(pattern).Create(pattern, config, flags);
public void BadExplicitAlternativeType() { Assert.Throws <ArgumentException>(() => Lexico.Parse <TruthyWithInvalidAlternative>("true", new ConsoleDeveloperTrace())); }
public void CannotWriteReadonlyField() => Assert.NotEqual(5, Lexico.Parse <ReadonlyField>("5").Value);
public cParser(Lexico.Lexico lexer) : base(lexer) { }
public parserC(Lexico.Lexico lexer) : base(lexer) { }
public void WriteProtectedField() => Assert.Equal(5, Lexico.Parse <ProtectedField>("5").Val);
public void WrongUserObjectTypeThrowsCastException() { var myUserObject = 3; Assert.Throws <InvalidCastException>(() => Lexico.Parse <ClassWithConcreteUserObject>("5", userObject: myUserObject)); }