Skip to content
Snippets Groups Projects
Commit c77ca8a3 authored by Lior Spach's avatar Lior Spach
Browse files

lala

parent f5323224
No related branches found
No related tags found
No related merge requests found
Source diff could not be displayed: it is too large. Options to address this: view the blob.
......@@ -3,13 +3,13 @@ package lexer
import scala.annotation.tailrec
case class Token(val valor: String, val func: String)
case class Atomo(val valor: String, val func: String)
object Lexer {
val h = new LexerHelper
var linhaAtual = 1
@tailrec
final def getTokens(input: List[Char], acc:List[Token] = Nil): List[Token] = input match {
final def getTokens(input: List[Char], acc:List[Atomo] = Nil): List[Atomo] = input match {
case letra :: _ if h.ehLetra(letra) =>
val token = h.casoLetra(input)
getTokens(input.drop(token.valor.size), token :: acc)
......@@ -32,7 +32,7 @@ object Lexer {
getTokens(input.drop(token.valor.size), token :: acc)
case other :: _ if "(),;.".contains(other) =>
val token = Token(""+other, "controle")
val token = Atomo(""+other, "controle")
getTokens(input.tail, token :: acc)
case Nil =>
......
......@@ -16,6 +16,7 @@ class LexerHelper extends Definicoes {
case notOp :: rest if !ehOp(notOp) =>
acc
}
@tailrec final def take(input: List[Char], acc: String = ""): String = {
def isNotASeparatorNorOperator: Boolean = ! (ehSeparador(input.head) || ehOp(input.head))
input match {
......@@ -25,6 +26,7 @@ class LexerHelper extends Definicoes {
acc
}
}
@tailrec final def takeNum(input: List[Char], acc:String = ""):String = input match {
case Nil => acc
case num if ehNum(input.head) => takeNum(input.tail, acc+input.head)
......@@ -33,7 +35,7 @@ class LexerHelper extends Definicoes {
}
//CASOS
def casoLetra(input: List[Char]):Token = {
def casoLetra(input: List[Char]):Atomo = {
val palavra = take(input)
val forwardInput = input.drop(palavra.size)
val valido = palavra.forall
......@@ -41,20 +43,21 @@ class LexerHelper extends Definicoes {
val tipo = if (ehPalavraReservada(palavra)) "reservada"
else if (ehTipo(palavra)) "tipo"
else "identificador"
Token(palavra, tipo)
Atomo(palavra, tipo)
}
def casoOp(input: List[Char]):Token = {
def casoOp(input: List[Char]):Atomo = {
val fullOp = takeOp(input)
fullOp match {
case ":" => Token(":","dois pontos")
case op if operadorValido(fullOp) => Token(fullOp,"operador")
case ":" => Atomo(":","dois pontos")
case op if operadorValido(fullOp) => Atomo(fullOp,"operador")
case _ => erro("operador invalido" + fullOp)
}
}
def caseNum(input: List[Char]):Token = {
def caseNum(input: List[Char]):Atomo = {
val num = takeNum(input)
Token(num,"numero")
Atomo(num,"numero")
}
......
......@@ -12,13 +12,13 @@ object Test {
def test1 = {
val lex = Lexer
val testString = "lala:=la22=l34++l44".toList
val answer = List(Token("lala","identificador"),
Token(":=","operador"),
Token("la22","identificador"),
Token("=","operador"),
Token("l34","identificador"),
Token("++","operador"),
Token("l44","identificador")
val answer = List(Atomo("lala","identificador"),
Atomo(":=","operador"),
Atomo("la22","identificador"),
Atomo("=","operador"),
Atomo("l34","identificador"),
Atomo("++","operador"),
Atomo("l44","identificador")
)
val result = answer.corresponds(lex.getTokens(testString)) { _==_ }
println("Test 1: "+(if (result) "Success" else "Fail"))
......@@ -28,22 +28,22 @@ object Test {
val lex = Lexer
val testString = simplePascalProgram.toList
val answer = List(
Token("program","reservada"),Token("exemplo12","identificador"),Token("(","controle"),Token("input","identificador"),Token(",","controle"),Token("output","identificador"),Token(")","controle"),Token(";","controle"),
Token("var","reservada"),Token("x","identificador"),Token(":","dois pontos"),Token("integer","tipo"),
Token(";","controle"),Token("procedure","reservada"),Token("p","identificador"),
Token("(","controle"),Token("var","reservada"),Token("t","identificador"),Token(":","dois pontos"),Token("integer","tipo"),Token(")","controle"),
Token(";","controle"),
Token("label","reservada"), Token("100","numero"), Token(",","controle"), Token("200","numero"),Token(";","controle"),
Token("begin","reservada"),Token("read","reservada"),
Token("(","controle"),Token("x","identificador"),Token(")","controle"),Token(";","controle"),
Token("200","numero"),Token(":","dois pontos"),
Token("x","identificador"),Token(":=","operador"),Token("x","identificador"),Token("+","operador"),
Token("20","numero"),Token(";","controle"),
Token("t","identificador"),Token(":=","operador"),
Token("x","identificador"),Token("end","reservada"),Token(";","controle"),Token("begin","reservada"),
Token("p","identificador"),Token("(","controle"),Token("x","identificador"),Token(")","controle"),
Token(";","controle"),Token("write","reservada"),Token("(","controle"),Token("x","identificador"),
Token(")","controle"),Token("end","reservada"),Token(".","controle"))
Atomo("program","reservada"),Atomo("exemplo12","identificador"),Atomo("(","controle"),Atomo("input","identificador"),Atomo(",","controle"),Atomo("output","identificador"),Atomo(")","controle"),Atomo(";","controle"),
Atomo("var","reservada"),Atomo("x","identificador"),Atomo(":","dois pontos"),Atomo("integer","tipo"),
Atomo(";","controle"),Atomo("procedure","reservada"),Atomo("p","identificador"),
Atomo("(","controle"),Atomo("var","reservada"),Atomo("t","identificador"),Atomo(":","dois pontos"),Atomo("integer","tipo"),Atomo(")","controle"),
Atomo(";","controle"),
Atomo("label","reservada"), Atomo("100","numero"), Atomo(",","controle"), Atomo("200","numero"),Atomo(";","controle"),
Atomo("begin","reservada"),Atomo("read","reservada"),
Atomo("(","controle"),Atomo("x","identificador"),Atomo(")","controle"),Atomo(";","controle"),
Atomo("200","numero"),Atomo(":","dois pontos"),
Atomo("x","identificador"),Atomo(":=","operador"),Atomo("x","identificador"),Atomo("+","operador"),
Atomo("20","numero"),Atomo(";","controle"),
Atomo("t","identificador"),Atomo(":=","operador"),
Atomo("x","identificador"),Atomo("end","reservada"),Atomo(";","controle"),Atomo("begin","reservada"),
Atomo("p","identificador"),Atomo("(","controle"),Atomo("x","identificador"),Atomo(")","controle"),
Atomo(";","controle"),Atomo("write","reservada"),Atomo("(","controle"),Atomo("x","identificador"),
Atomo(")","controle"),Atomo("end","reservada"),Atomo(".","controle"))
val result = answer.corresponds(lex.getTokens(testString)) { _==_ }
println("Test 2: "+(if (result) "Success" else "Fail"))
}
......@@ -56,14 +56,7 @@ val simplePascalProgram =
label 100,200;
begin
read(x);
200: x:= x + 20 ; (*
Big comentary with alot of junk to test it well
[awdfkaw op wadk p203 43 4 3 42iojio3j awdfkaw op wadk p203 43 4 3 42iojio3j ]
[awdfkaw op wadk p203 43 4 3 42iojio3j ]
[dwopkda0)))* ]
[345634523)))) ]
[=40=-=2=-=13=230 (*** ]
*)
200: x:= x + 20 ; (* sdfs *)
t := x
end;
begin
......
package semantico
import lexer.Token
case class ParseResult(novoInput:List[Token], aceita:Boolean)
trait Casos {
var linhaAtual = 0 //TODO: how to keep track of newline on semantic parser?
def parseError(msg:String) = {
println("[Erro] linha:"+linhaAtual+" => "+ msg)
sys.exit(1)
}
def _program (input: List[Token]):ParseResult = input match {
case Token("program","reservada") :: Token(_,"identificador") :: resto =>
resto match {
case Token(";","controle") :: rest => ParseResult(rest,true)
case Token("(","controle") :: Token(_,"identificador") :: Token(",","controle") :: Token(_,"identificador") ::
Token(")","controle") :: Token(";","controle") :: rest
=> ParseResult(rest,true)
case _ => ParseResult(Nil,false)
}
case _ => ParseResult(Nil,false)
}
def _var(input:List[Token]):ParseResult = input match {
case Token("var","reservada") :: declaracoes => _vars(declaracoes)
case _ => ParseResult(Nil,false)
}
def _vars(input:List[Token]):ParseResult = input match {
case Token(_,"identificador") :: Token(":",_) :: Token(_,"tipo") ::
Token(";","controle") :: rest =>
rest match {
case Token(_,"identificador") :: continua => _vars(rest)
case _ => ParseResult(rest,true)
}
case Token(_,"identificador") :: Token(",","controle") :: rest=> _vars(rest)
case Nil =>
parseError("Declaração de variável")
case rest =>
parseError("Declaração de variável incorreta em \""+
rest.take(3).foldLeft(""){ (acc,t) => t match {case Token(v,_) => acc+v }}
+"\"")
}
}
\ No newline at end of file
package semantico
package sintatico
import lexer.Atomo
abstract trait molecula
case class Program(id:String,inOut:String*) extends molecula
case class Atribuicao(id:String, op:String, expr:Expr) extends molecula
case class ChamadaFuncao(id:String,param:Parametro*) extends molecula
case class Parametro(id:String,tipo:String)
case class Numero(valor:Int) extends molecula
case class Expr() extends molecula
case class Label(id:String) extends molecula
case class ParseResult(novoInput:List[Atomo], aceita:Boolean)
trait Casos {
var linhaAtual = 0 //TODO: how to keep track of newline on semantic parser?
def parseError(msg:String) = {
println("[Erro] linha:"+linhaAtual+" => "+ msg)
sys.exit(1)
}
def _program (input: List[Atomo]):ParseResult = input match { //Pode ter lista de identificadores em (imput,output)
case Atomo("program","reservada") :: Atomo(_,"identificador") :: resto =>
resto match {
case Atomo(";","controle") :: rest => ParseResult(rest,true)
case Atomo("(","controle") :: Atomo(_,"identificador") :: Atomo(",","controle") :: Atomo(_,"identificador") ::
Atomo(")","controle") :: Atomo(";","controle") :: rest
=> ParseResult(rest,true)
case _ => ParseResult(Nil,false)
}
case _ => ParseResult(Nil,false)
}
def _var(input:List[Atomo]):ParseResult = input match {
case Atomo("var","reservada") :: declaracoes => _vars(declaracoes)
case _ => ParseResult(Nil,false)
}
def _vars(input:List[Atomo]):ParseResult = input match {
case Atomo(_,"identificador") :: Atomo(":",_) :: Atomo(_,"tipo") ::
Atomo(";","controle") :: rest =>
rest match {
case Atomo(_,"identificador") :: continua => _vars(rest)
case _ => ParseResult(rest,true)
}
case Atomo(_,"identificador") :: Atomo(",","controle") :: rest=> _vars(rest)
case Nil =>
parseError("Declaração de variável")
case rest =>
parseError("Declaração de variável incorreta em \""+
rest.take(3).foldLeft(""){ (acc,t) => t match {case Atomo(v,_) => acc+v }}
+"\"")
}
// type T = Token
// def _expressao(input:List[Token]):ParseResult = input match {
//
// case T(_,"identificador") :: T(_,"(") :: _ => //function call
//
// case T(_,"identificador") :: _ => //variable
//
// case T(op,"operador") :: _ =>
// if (op=="+" || op=="-") {
//
// } else {
// parseError("Operador encontrado em local inválido.")
// }
// }
}
\ No newline at end of file
package sintatico
package semantico
package sintatico
object TestCasos {
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment