Remove old files

src/main/scala/comb.scala

-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

src/main/scala/lexer/Definicoes.scala

-
-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

src/main/scala/lexer/Lexer.scala

-
-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

src/main/scala/lexer/LexerHelper.scala

-
-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

src/main/scala/lexer/TestLexer.scala

-
-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

src/main/scala/sintatico/Casos.scala

-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

src/main/scala/sintatico/Expr.scala

-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

src/main/scala/sintatico/TestCasos.scala

-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