Suporte à Linguagem TPP

Extensão para VS Code que adiciona syntax highlighting e suporte à linguagem TPP (Teaching Programming Language), desenvolvida na disciplina de Compiladores.

A linguagem TPP é uma linguagem didática com tipos estáticos, vetores, funções, controle de fluxo (condicional e repetição) e expressões aritméticas/lógicas.

Funcionalidades

• Destaque de sintaxe para arquivos .tpp
• Reconhecimento de todos os tokens da linguagem:
  • Palavras‑chave: se, então, senão, fim, repita, até, leia, escreva, retorna, erro
  • Tipos primitivos: inteiro, flutuante
  • Operadores:
    • Atribuição: :=
    • Aritméticos: +, -, *, /
    • Relacionais: <, >, =, <>, <=, >=
    • Lógicos: && (E), || (OU), ! (NAO)
  • Pontuação: :, ,, (, ), [, ]
  • Números: inteiros (\d+), ponto flutuante (\d+\.?\d*) e notação científica (\d+\.?\d*e(+|-)?\d+)
  • Identificadores (ID) e chamadas de função
• Suporte à sintaxe completa definida pela EBNF (ver seção abaixo)

Exemplo de código TPP

flutuante: A[5]
flutuante: B[5]
flutuante: C[5]

{ isso é um comentário }
preencherVetores(inteiro: n, flutuante: X[], flutuante: Y[])
    inteiro: i
    i := 0
    repita
        X[i] := i + 1.5
        Y[i] := (i + 2) * 2.0
        i := i + 1
    até i = n
fim

multiplicaVetores(inteiro: n, flutuante: X[], flutuante: Y[], flutuante: Z[])
    inteiro: i
    i := 0
    repita
        Z[i] := X[i] * Y[i]
        i := i + 1
    até i = n
fim

troca(flutuante: V[], inteiro: i, inteiro: j)
    flutuante: temp
    temp := V[i]
    V[i] := V[j]
    V[j] := temp
fim

ordenaCrescente(inteiro: n, flutuante: V[])
    inteiro: i, j, menor
    i := 0
    repita
        menor := i
        j := i + 1
        repita
            se V[j] < V[menor] então
                menor := j
            fim
            j := j + 1
        até j = n

        se menor <> i então
            troca(V, i, menor)
        fim

        i := i + 1
    até i = n
fim

inteiro principal()
    inteiro: n, i
    n := 5

    preencherVetores(n, A, B)
    multiplicaVetores(n, A, B, C)
    ordenaCrescente(n, C)

    i := 0
    repita
        escreva(C[i])
        i := i + 1
    até i = n

    retorna(0)
fim

Gramática (resumo EBNF)

Abaixo estão as principais regras da linguagem. Para a especificação completa consulte os diagramas sintáticos.

programa                ::= declaracao+
declaracao              ::= declaracao_variaveis | inicializacao_variaveis | declaracao_funcao
declaracao_variaveis    ::= tipo ':' var ( ',' var )*
inicializacao_variaveis ::= atribuicao
var                     ::= ID ( '[' expressao ']' )*
tipo                    ::= INTEIRO | FLUTUANTE
declaracao_funcao       ::= tipo? cabecalho
cabecalho               ::= ID '(' ( parametro | vazio ) ( ',' parametro )* ')' corpo FIM
parametro               ::= tipo ':' ID ( '[' ']' )*
corpo                   ::= vazio acao*
acao                    ::= expressao | declaracao_variaveis | se | repita | leia | escreva | retorna | erro
se                      ::= SE expressao ENTAO corpo ( SENAO corpo )? FIM
repita                  ::= REPITA corpo ATE expressao
atribuicao              ::= var ':=' expressao
leia                    ::= LEIA '(' var ')'
escreva                 ::= ESCREVA '(' expressao ')'
retorna                 ::= RETORNA '(' expressao ')'
expressao               ::= expressao_simples ( operador_logico expressao_simples )* | atribuicao
expressao_simples       ::= expressao_aditiva ( operador_relacional expressao_aditiva )*
expressao_aditiva       ::= expressao_multiplicativa ( operador_soma expressao_multiplicativa )*
expressao_multiplicativa::= expressao_unaria ( operador_multiplicacao expressao_unaria )*
expressao_unaria        ::= ( operador_soma | '!' )? fator
fator                   ::= '(' expressao ')' | var | chamada_funcao | numero
chamada_funcao          ::= ID '(' ( expressao | vazio ) ( ',' expressao )* ')'
numero                  ::= NUM_INTEIRO | NUM_PONTO_FLUTUANTE | NUM_NOTACAO_CIENTIFICA

Tokens e Expressões Regulares

Como usar

1. Instale a extensão no VS Code.
2. Abra (ou crie) um arquivo com extensão .tpp.
3. O realce de sintaxe será aplicado automaticamente.

Observações sobre a semântica

• As declarações de variáveis podem conter uma lista de identificadores separados por vírgula, todos do mesmo tipo:

  inteiro: i, j, k[10]
  

• Vetores são indexados por expressões inteiras: A[expressao]
• Funções podem retornar um valor (se tiver tipo declarado) ou serem procedimentos (sem tipo).
• O corpo de uma função ou estrutura condicional pode ser vazio.
• A linguagem possui comentários entre chaves { ... } (não explicitamente na EBNF, mas presentes nos exemplos).

Autores

Desenvolvido por lucas marcao para fins acadêmicos – disciplina de Implementação de linguagens de programação.

Licença

Uso livre para fins educacionais.