diff --git a/src/main/scala/comb.scala b/src/main/scala/comb.scala
deleted file mode 100644
index 8819899d39dec47640e0c11c8a3a1fa9f707c72a..0000000000000000000000000000000000000000
--- a/src/main/scala/comb.scala
+++ /dev/null
@@ -1,48 +0,0 @@
-package CombParse
-
-import scala.util.parsing.combinator._
-
-
-class Arith extends JavaTokenParsers {
-
- def program : Parser[String] = {
- def programInOut: Parser[Any] = "(" ~ opt( ident ~ opt(rep("," ~ ident)) ) ~ ")"
- "program" ~> ident <~ opt(programInOut) ~ ";"
- }
-
- def vars:Parser[List[String]] =
- "var" ~ ident ~ opt(rep("," ~> ident)) ~ ":"~"integer"~";" ^^
- {
- case "var" ~ id ~ optlstId ~ ":" ~ "integer"~";" =>
- optlstId match {
- case Some(s) =>
- id :: s
- case None =>
- List(id)
- }
- }
- lazy val page = getpage(i.link)
- lazy val metadata = i.toMetadata ++ getter.getMetadata(page)
- lazy val downLink = metadata.find(_.key == "DownloadLink").get.value
- lazy val filename = metadata.find(_.key == "NomeArquivo" ).get.value
- def param:Parser[String] =
- ident ~ opt(rep("," ~> ident)) ~ ":"~"integer"~";"
-// def params:Parser[List[String]] =
-// opt("(" ~ param ~ opt(rep("," ~ param)) ~ ")")
-// def procedure:Parser[List[String]] =
-// "procedure" ~ ident ~ params
-
-}
-
-object MyParser extends Arith {
- val input = Seq(
- "program lala23(adkwopadw23, faw4ea,aduwh28 ) ;",
- "var a,v,b23,sd :integer;"
- )
-
- def main(args: Array[String]) {
- println(
- parseAll(program, input(0)).get
- )
- }
-}
\ No newline at end of file
diff --git a/src/main/scala/lexer/Definicoes.scala b/src/main/scala/lexer/Definicoes.scala
deleted file mode 100644
index 1bd969fc31dcdcb6a5a2efbc6092144c2ce797d4..0000000000000000000000000000000000000000
--- a/src/main/scala/lexer/Definicoes.scala
+++ /dev/null
@@ -1,26 +0,0 @@
-
-package lexer
-
-trait Definicoes {
- //Conjuntos
- val palavrasReservadas = List("begin", "end", "function", "procedure", "var", "program",
- "label","goto","if","then","else","read","write",
- "while","do")
- val tipos = List("integer")
- val letras = List.concat('a' to 'z', 'A' to 'Z', "_")
- val numeros = ('0' to '9').toList
- val separadores = List(' ', '\t', '\n', ';',',',':')
- val operadores =
- "+ - * / += -= *= /= ++ -- = < > <= >= <> :=".split(" ").toList
- val operadoresArit = "+-*/".sliding(1).toList
-
- //Funcoes booleanas
- val operadorValido = (s: String) => operadores.contains(s)
- val ehNum = (c: Char) => numeros.contains(c)
- val ehOp = (c: Char) => "+-*/=:><".contains(c)
- val ehLetra = (c: Char) => letras.contains(c)
- val ehEspacoLinTab = (c: Char) => c == ' ' || c == '\t' || c == '\n' || c == 13
- val ehSeparador = (c: Char) => separadores.contains(c)
- val ehPalavraReservada = (s: String) => palavrasReservadas.contains(s)
- val ehTipo = (s: String) => tipos.contains(s)
-}
\ No newline at end of file
diff --git a/src/main/scala/lexer/Lexer.scala b/src/main/scala/lexer/Lexer.scala
deleted file mode 100644
index 733b10b4b27a5ec61d5e09d75c69412b8e2ea148..0000000000000000000000000000000000000000
--- a/src/main/scala/lexer/Lexer.scala
+++ /dev/null
@@ -1,45 +0,0 @@
-
-package lexer
-
-import scala.annotation.tailrec
-
-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[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)
-
- case op :: _ if h.ehOp(op) =>
- val token = h.casoOp(input)
- getTokens(input.drop(token.valor.size), token :: acc)
-
- case escape :: _ if h.ehEspacoLinTab(escape) =>
- if (escape == '\n') linhaAtual+=1
- getTokens( input.dropWhile{h.ehEspacoLinTab}, acc )
-
- case comment :: rest if comment=='(' && rest.head == '*' =>
- val index = rest.tail.indexOfSlice("*)")
- if (index == -1) h.erro("Comentário não foi fechado")
- getTokens( rest.tail.drop(index+2), acc )
-
- case num :: _ if h.ehNum(num) =>
- val token = h.caseNum(input)
- getTokens(input.drop(token.valor.size), token :: acc)
-
- case other :: _ if "(),;.".contains(other) =>
- val token = Atomo(""+other, "controle")
- getTokens(input.tail, token :: acc)
-
- case Nil =>
- acc.reverse
-
- case _ =>
- println("EMPTY? "+input.head.toInt + '\n'.toInt)
- sys.exit()
- }
-}
\ No newline at end of file
diff --git a/src/main/scala/lexer/LexerHelper.scala b/src/main/scala/lexer/LexerHelper.scala
deleted file mode 100644
index a97cf8d8d3fc1b160b3e6e7baa90877c3eacfc28..0000000000000000000000000000000000000000
--- a/src/main/scala/lexer/LexerHelper.scala
+++ /dev/null
@@ -1,64 +0,0 @@
-
-package lexer
-
-import scala.annotation.tailrec
-
-class LexerHelper extends Definicoes {
-
- //Acoes
- def erro(msg: String) = { println("Erro: " + msg +" (linha:"+Lexer.linhaAtual+")"); sys.exit(1) }
-
- //TAKES
- @tailrec final def takeOp(input:List[Char],acc:String = ""):String = input match {
- case Nil => acc
- case op :: rest if ehOp(op) =>
- takeOp(rest,acc+op)
- 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 {
- case in :: _ if ehLetra(in) || ehNum(in) =>
- take(input.tail, acc + in)
- case _ =>
- 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)
- case letra if ehLetra(input.head) => erro("número inválido")
- case sep if ehSeparador(input.head) || ehOp(input.head) => acc
- }
-
- //CASOS
- def casoLetra(input: List[Char]):Atomo = {
- val palavra = take(input)
- val forwardInput = input.drop(palavra.size)
- val valido = palavra.forall
- { ch => ehLetra(ch) || ehNum(ch) }
- val tipo = if (ehPalavraReservada(palavra)) "reservada"
- else if (ehTipo(palavra)) "tipo"
- else "identificador"
- Atomo(palavra, tipo)
- }
-
- def casoOp(input: List[Char]):Atomo = {
- val fullOp = takeOp(input)
- fullOp match {
- case ":" => Atomo(":","dois pontos")
- case op if operadorValido(fullOp) => Atomo(fullOp,"operador")
- case _ => erro("operador invalido" + fullOp)
- }
- }
-
- def caseNum(input: List[Char]):Atomo = {
- val num = takeNum(input)
- Atomo(num,"numero")
- }
-
-
-}
\ No newline at end of file
diff --git a/src/main/scala/lexer/TestLexer.scala b/src/main/scala/lexer/TestLexer.scala
deleted file mode 100644
index 504805d1db279b0db16f5917b0629ba451d34472..0000000000000000000000000000000000000000
--- a/src/main/scala/lexer/TestLexer.scala
+++ /dev/null
@@ -1,93 +0,0 @@
-
-package lexer
-
-import scala.annotation.tailrec
-
-object Test {
- def main(args:Array[String]) {
- test1
- test2
- }
-
- def test1 = {
- val lex = Lexer
- val testString = "lala:=la22=l34++l44".toList
- 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"))
- }
-
- def test2 = {
- val lex = Lexer
- val testString = simplePascalProgram.toList
- val answer = List(
- 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"))
- }
-
-val words = "Hello my nice words"
-val simplePascalProgram =
-"""program exemplo12 (input,output);
- var x: integer;
- procedure p(var t: integer);
- label 100,200;
- begin
- read(x);
- 200: x:= x + 20 ; (* sdfs *)
- t := x
- end;
-begin
- p(x);
- write(x)
-end.
-"""
-val complexPascalProgram =
-"""program exemplo12 (input,output);
- var x: integer;
- procedure p(var t: integer);
- label 100,200;
- var s : integer;
- function f(z:integer):integer;
- begin (* f *)
- if z<0 then goto 200
- else if z=0 then f:=2
- else f:=f(z-2)*z+1
- end; (* f *)
- begin (* p *)
- 100: s:=f(t); t:=s
- if t<x then goto 100;
- 200: x:=x-1
- end;
- procedure r;
- procedure q;
- var y:integer;
- begin read(y); p(y); write(y) end; (* q *)
- begin q end; (* r *)
- begin read(x); r end.
-"""
-
-
-}
\ No newline at end of file
diff --git a/src/main/scala/sintatico/Casos.scala b/src/main/scala/sintatico/Casos.scala
deleted file mode 100644
index 813f34970db27e87a16dfa3fa5b8aac1816bf1ee..0000000000000000000000000000000000000000
--- a/src/main/scala/sintatico/Casos.scala
+++ /dev/null
@@ -1,75 +0,0 @@
-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
diff --git a/src/main/scala/sintatico/Expr.scala b/src/main/scala/sintatico/Expr.scala
deleted file mode 100644
index 5dfefa63717d84ac5b3fc6b4e89d90bd465ce1c2..0000000000000000000000000000000000000000
--- a/src/main/scala/sintatico/Expr.scala
+++ /dev/null
@@ -1,25 +0,0 @@
-package sintatico
-
-abstract trait Molecula
-case class Program(name:String, inOut:String*) extends Molecula
-case class Variavel(id:String,tipo:String) extends Molecula
-case class DecVariaveis(vars:Variavel*) extends Molecula
-
-abstract class DecFunPro extends Molecula
-case class DecProcedimento(id:String,params:Parametros*) extends DecFunPro
-case class DecFuncao(id:String,tipoRet:String,params:Parametros*) extends DecFunPro
-case class Parametros(id:String,modo:String,tipo:String) extends Molecula
-
-
-abstract trait Comando extends Molecula
-case class Bloco(comandos:Comando*) extends Comando
-case class Atribuicao(id:String,op:String,expr:ExprInt) extends Comando
-
-abstract trait Chamada extends Comando
-case class ChamadaFuncao(id:String,Args:Argumento*) extends Chamada
-case class ChamadaProcedimento(id:String,Args:Argumento*) extends Chamada
-class Argumento()
-
-class Expr extends Comando
-class ExprInt extends Expr
-class ExprBool extends Expr
\ No newline at end of file
diff --git a/src/main/scala/sintatico/TestCasos.scala b/src/main/scala/sintatico/TestCasos.scala
deleted file mode 100644
index 80d2b6db8e1713266b6d34c7a3d6994b32cf76e1..0000000000000000000000000000000000000000
--- a/src/main/scala/sintatico/TestCasos.scala
+++ /dev/null
@@ -1,31 +0,0 @@
-package sintatico
-
-object TestCasos {
-
- def main(args:Array[String]) {
- println("Test 1(program): " + test1)
- println("Test 2(var): " + test2)
- }
-
- def test1:Boolean = {
- val casos = new AnyRef with Casos
- val input = lexer.Lexer.getTokens("program myProgram23(input,output);".toList);
- val parseResult = casos._program(input)
- parseResult.aceita
- }
-
- def test2:Boolean = {
- val casos = new AnyRef with Casos
- val input = lexer.Lexer.getTokens(
-"""
-var
- a,b:integer;
- c33:integer; c1,c2,c3,c4 ,v4,b5:integer;
- c33 , a23 :integer;
-begin
- lala
-end.""".toList);
- val parseResult = casos._var(input)
- parseResult.aceita
- }
-}
\ No newline at end of file