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

Token	Expressão Regular
MAIS	`\+`
MENOS	`-`
VEZES	`\*`
DIVIDE	`/`
DOIS_PONTOS	`:`
VIRGULA	`,`
MENOR	`<`
MAIOR	`>`
IGUAL	`=`
DIFERENTE	`<>`
MENOR_IGUAL	`<=`
MAIOR_IGUAL	`>=`
E (lógico)	`&&`
OU	`\|\|`
NAO	`!`
ABRE_PARENTESE	`\(`
FECHA_PARENTESE	`\)`
ABRE_COLCHETE	`\[`
FECHA_COLCHETE	`\]`
SE	`se`
ENTAO	`então`
SENAO	`senão`
FIM	`fim`
REPITA	`repita`
ATE	`até`
ATRIBUICAO	`:=`
LEIA	`leia`
ESCREVA	`escreva`
RETORNA	`retorna`
INTEIRO	`inteiro`
FLUTUANTE	`flutuante`
NUM_INTEIRO	`\d+`
NUM_PONTO_FLUTUANTE	`\d+\.?\d*`
NUM_NOTACAO_CIENTIFICA	`\d+.?\d*e(+
ID	`[a-zA-Z_][a-zA-Z0-9_]*`

Como usar

Instale a extensão no VS Code.
Abra (ou crie) um arquivo com extensão .tpp.
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.

TPP Lang