Livro para criação de uma linguagem [RESOLVIDO]

SamL
(usa XUbuntu)

Enviado em 01/08/2015 - 18:35h

Olá, eu queria criar uma linguagem de programação estilo C mas interpretada. Eu conheço alguns livros em português mas o conteúdo deles tem pouca explicação sobre como realmente fazer uma linguagem. Digo, lá tem teoria demasiadamente com pouca prática, esta vem em um deles de forma de pseudo código em ptBR.
Então, alguém conhece um bom livro em inglês ou até mesmo tutorial sobre implementação de uma linguagem de programação?

EnzoFerber
(usa FreeBSD)

Enviado em 03/08/2015 - 08:00h

Bom dia, Sam.

No C Completo e Total do Herbert Schildt tem um pequeno interpretador C que você poderá utilizar como base.
É um dos últimos capítos. Acho que mais simples e melhor que isso não há.

Se isso não bastar, você vai ter que começar a entender como funcionam as árvores de parsing, analisadores de expressão, lógica aplicada a interpretação, etc.
Ah, o capítulo sobre o analisador recursivo descendente (um analisador de expressões) é interessantíssimo e o LittleC utiliza esse analisador (little C é o nome do interpretador que ele faz).

Qualquer coisa posta denovo,
[]'s
Enzo Ferber

$ cat codigo.c | indent -kr -i8
$ man indent

"(...)all right-thinking people know that (a) K&R are _right_ and (b) K&R are right." - linux/Documentation/CodingStyle - TORVALDS, Linus. 
 

igormorais
(usa Gentoo)

Enviado em 03/08/2015 - 12:29h

Se criar um compilador ou interpretador pra uma linguagem já é muito difícil, imagina criar a linguagem. Você acha realmente necessário ? Isso é trabalho pra alguns anos e muitas pessoas.

---
"Nós não sabemos o sistema operacional que Deus usa, mas o Vaticano usa Linux." - Judith Zoebelein

gokernel
(usa Linux Mint)

Enviado em 03/08/2015 - 19:15h

Olá !

Qual seria o motivo de querer tipo interpretada ?

Basicamente uma implementação de uma linguagem similar a C seria assim:

/*
**-------------------------------------------------------------------
**
** "Exemplo/esqueleto" de modelo de uma linguagem:
**
**-------------------------------------------------------------------
*/

static char *str;
static int  token [1024];
static char prog [10000];
static int  tok;
static int  erro;

enum {
    TOK_INT = 255,
    TOK_IF,
    TOK_FOR,
    //------------
    TOK_ID,
    TOK_NUMBER,
    TOK_STRING
};

int lex (void)
{

    switch (*str) {

    // ... aqui:
    // 01: ler/incrementa str:
    // 02: modifica token[]
    // 03: retorna ( TOK_INT, TOK_IF, TOK_FOR, TOK_MUMERO, TOK_STRING ... )
    //
    // ou:

    case 0: return 0;

    default:
        return *str++;
    }

    return 0;
}

int stmt (VM *a)
{
    switch (tok) {
    case '{'
        tok = lex();
        while (tok && tok != '}') stmt(a); // processa um BLOCO
        tok = lex();
        break;

    case TOK_INT:
        // processa int ... usando lex();
        break;

    case TOK_IF:
        // processa if ... usando lex();
        break;

    case TOK_FOR:
        // processa for ... usando lex();
        break;

    default:
        expression (a);
    }
    return tok;
}

void expression (VM *a)
{
    // aqui pode ser typo:
    // 01: variavel
    // 02: funcao
    // 03: ou ERRO ;)
    //
    if (tok == TOK_ID) {

        expr0(a);

        // ....

    }
    tok = lex();
}

int Parse (VM *a, char *text)
{
    str = text;
    erro = 0;

    while (stmt(a)) { } // SIM: um loop vazio para ser mais claro

    return erro;
}

int main (int argc, char *argv[])
{
    VM *fe;

    // ABRE UM ARQUIVO E ARMAZENA EM ( prog ):
    // ...

    // CRIA/INICIA O FRONTEND:
    // ...

    if (!Parse(fe, prog)) {

        // executa o "FRONTEND"
    }

    return 0;
}
 

Modelo de analisador de expressão baseado na dica do colega acima:

// +, - : soma
void expr0 (ASM *a) {
    int op;

    expr1(a);
    while ((op=tok) == '+' || (op=tok) == '-') {
        tok=lex();
        expr1(a);
        switch (op) {
        case '+':
            asm_add_eax_esp (a);
            break;
        case '-':
            asm_sub_eax_esp (a);
            break;
        }
    }
}
// *, / : multiplica
void expr1 (ASM *a) {
    int op;

    expr2(a);
    while ((op=tok) == '*' || (op=tok) == '/') {
        tok=lex();
        expr2(a);
        switch (op) {
        case '*':
            asm_imul_eax_esp(a);
            break;
        case '/':

            break;
        }
    }
}

// (
void expr2 (ASM *a) {
    if(tok=='('){
        tok=lex();
        expr0(a);
        if(tok != ')'){
            printf ("ERRO )\n");
            erro_line (" ");
        }
        tok=lex();
    }
    else expr3(a); // atom:
}
// atom:
void expr3 (ASM *a) {
    if(tok==TOK_ID){
        VAR *v = csVarFind(token);
        if (v) {
            asm_pushl_var (a, &v->value);
            tok=lex();
        }
        else erro_line("Expression var not found");
    }
    else if(tok==TOK_NUMBER){
        asm_push_number (a, atoi(token));
        tok=lex();
    }
    else erro_line("Expression");
}
 

Veja algo aqui:
http://www.t3x.org/subc/

T+.

gokernel
(usa Linux Mint)

Enviado em 09/08/2015 - 11:29h

Olá Sam. L.

Te convido para juntos desenvolver uma Linguagem ...

O a ideia do nome "seria" SAMGO (abreviação do teu nome(Sam) com abreviação do meu E-mail(gokenel) ).

OBS:
Já existe algo(somente o nome) similar:
https://en.wikipedia.org/wiki/Sango_language

OBS:
Não tenho interesse em linguagem tipo interpretada ... pois já tive a experiência de perceber que eh algo lento e assim não "Vamos Conquistar o Mundo" . ;)

Se preferir responda-me via E-mail ou aqui mesmo .

T+.

Thihup
(usa Manjaro Linux)

Enviado em 09/08/2015 - 19:46h

Opa, tudo certo?

Eu quis responder esse tópico antes, mas tive uns imprevistos com minha placa de video =\

Já ví que está resolvido. Mas, eu poderia participar dessa linguagem? Esses dias eu estava pensando em fazer isso, mas o meu horário não bateu com o do SamL, dai nem pude falar com ele (Malz ae mano =\)

O nome poderia ser esse aí mesmo, eu não me importaria. E, caso fosse feito, o que acham de uma linguagem de alto nível, mais fácil que Python ainda.

Mas caso não possa participar, tudo bem, tô com uma ideia de fazer um jogo em 3d estilo DOOM. (Ah, e se alguem quiser participar, posta aí =D)

[]'s

T+

--

body@human: $ sudo su
brain@human: # apt-get purge -y windows* && echo "Windows removed successfully"

removido
(usa Nenhuma)

Enviado em 10/08/2015 - 01:21h

Eu lhe apresento o "Livro do Dragão"

http://www.buscape.com.br/compiladores-principios-tecnicas-e-ferramentas-alfred-v-aho-ravi-sethi-858...

Se for comprar, escolha a opção mais em conta.

--
http://s.glbimg.com/po/tt/f/original/2011/10/20/a97264_w8.jpg

Encryption works. Properly implemented strong crypto systems are one of the few things that you can rely on. Unfortunately, endpoint security is so terrifically weak that NSA can frequently find ways around it. — Edward Snowden

removido
(usa Nenhuma)

Enviado em 10/08/2015 - 10:47h

Já existe, o nome dela é Shell script. Qualquer Shell (csh, kshell, bash).

removido
(usa Nenhuma)

Enviado em 11/08/2015 - 02:54h

Pelo que me disseram a primeira edição do Livro do Dragão em português é incompleta.
E que a segunda está bem melhor no todo e atualizada.
Procure também um livro da Editora Artmed, que é parte de uma série de livros de informática da UFRGS que trata sobre compiladores.
Aliás a série é boa. Tem livro de autômatos, matemática discreta, complexidade de algoritmos etc.
--
http://s.glbimg.com/po/tt/f/original/2011/10/20/a97264_w8.jpg

Encryption works. Properly implemented strong crypto systems are one of the few things that you can rely on. Unfortunately, endpoint security is so terrifically weak that NSA can frequently find ways around it. — Edward Snowden