Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.


Mensagens - luizvd

Páginas: [1]
1
Programação e Scripts / Re: Interpretador - Máquina von Neumann - C++
« Online: 25 de Maio de 2007, 08:33 »
Olá Diego... opa obrigado.

É verdade, em situações onde o parâmetro passado é diferente da propriedade da classe, não é necessário o uso do this.

Isso é mais um vício que eu tenho de programar em PHP, onde você só consegue acessar as propriedades/membros da clase com o "$this->", senão não acessa.

Particularmente, apesar de ter que digitar um pouco mais, eu acho mais fácil e rápida a compreensão de quando uma variável é uma propriedade da classe e quando é uma variável temporária e/ou parâmetro :)

Mesmo assim valeu pela dica ;)

Abraços

2
Programação e Scripts / Re: IDE para C e C++ . Como programar C C++ no linux?
« Online: 23 de Maio de 2007, 09:54 »
Ainda sobre as IDEs, tente o Geany (tem nos repositórios, só não lembro se precisa habilitar o universe e o multiverse).

Foi a que achei mais parecida com o DevC++ do Windows.

O Anjuta na hora de compilar cria os arquivos make, makefile, etc... não entendo muito disso (até agora uso o C++ mais para trabalhos de faculdade).

Com o Geany, basta dar F9 para compilar e F5 para executar. Sem muita configuração.

[ ]'s
Luiz

3
Programação e Scripts / Re: Interpretador - Máquina von Neumann - C++
« Online: 23 de Maio de 2007, 09:50 »
Olá pessoal, desculpem a demora em reaparecer aqui, mas estive meio ocupado com algumas coisas.

E desculpem se não fui muito claro no que precisava, às vezes na pressa eu posso ter me confundido (e confundido vocês) hehehehe.

Eu entreguei o trabalho ontem, e após quebrar muito a cabeça, consegui fazer o que precisava. Segue o código para quem quiser dar uma olhada. Se tiverem sugestões ou críticas ao código, sintam-se livres para fazê-los. Assim aprendo um pouco mais e vamos discutindo o assunto ;)

Código a ser interpretado:
Código: [Selecionar]
leia_A
ate (a_zero)
faca (subtrai_A, adiciona_B, adiciona_B)
mostra_B


main()
Código: [Selecionar]
/*
 *  interpretador.cpp
 *
 *  Projeto: Interpretador
 *  Interpretador em C++ para máquina de von Neumann
 *  com 2 registradores
 *
 *  Compilado com:
 *  $ gcc --version
 *  gcc (GCC) 4.1.2 (Ubuntu 4.1.2-0ubuntu4)
 *
 *  Em:
 *  Ubuntu 7.04 Feisty Fawn
 *  Linux pc-luiz 2.6.20-15-generic #2 SMP i686
 *
 *  Luiz Vitor Damim
 *  cod: xxxxxxxx
 *  2007/05/22 17:36:35
 */
#include <iostream>
#include <string>
#include <vector>
#include <map>
using namespace std;

/*
 * Definindo a macro _clrscr()
 * Alterar conforme necessário se for compilar
 * em outro sistema operacional
 */
#define _clrscr() system("clear");


#include "maquina.h"
/*
 * Criando um tipo ponteiro-para-função-membro usado para mapear
 * um map no formato {comando da máquina} => {comando da classe Maquina}
 *
 * Pesquisado em:
 * http://www.parashift.com/c++-faq-lite/pointers-to-members.html#faq-33.5
 */
typedef void (Maquina::*MaquinaMemberFn)();
#define CALL_MEMBER_FN(object, ptrToMember) ((object).*(ptrToMember))

#include "parser.h"
#include "interpretador.h"

int main()
{
    Interpretador interpret = Interpretador();
    interpret.run();

    return 0;
}


interpretador.h
Código: [Selecionar]
/**
 * Class: Interpretador
 * Recebe o nome do arquivo, abre e manda cada linha para o Parser
 * para execução
 *
 * @see Parser::parse()
 */
class Interpretador
{
    private:
        int _arquivoNaoEncontradoCounter; /* contador de tentativas de abertura
                                             do arquivo */
        char _buffer[100];                /* buffer de leitura do arquivo */
        string _arquivo;                  /* nome do arquivo */
        vector<string> _programa;         /* vetor contendo as linhas de
                                             execução */
        FILE* _fp;                        /* ponteiro para o arquivo */
        Parser* _parser;

        /**
         * Pergunta o nome do arquivo para o usuário e tenta abrí-lo por 3 vezes
         * (somente se já não foi informado durante o construtor)
         *
         * Se não conseguir (porque não foi encontrado ou por não ter
         * permissão), termina a execução do programa
         *
         * @return void
         */
        void _abrirArquivo();

        /**
         * Método proxy para Parser::parse()
         * Itera sobre o vetor contendo o código da máquina
         * e manda cada linha para o analisador
         *
         * @see Parser::parse()
         * @return void
         */
        void _parse();


    public:
        Interpretador();
        Interpretador(char* arquivo);

        ~Interpretador();


        /**
         * Executa o interpretador
         *
         * @return void
         */
        void run();
};



/* ********************************************* */

inline Interpretador::Interpretador()
    : _arquivoNaoEncontradoCounter(3)
{ }


inline Interpretador::Interpretador(char* arquivo)
    : _arquivoNaoEncontradoCounter(3),
      _arquivo                        (arquivo)
{ }


inline Interpretador::~Interpretador() { this->_programa.clear(); }


inline void Interpretador::_abrirArquivo()
{
    do {
        if (this->_arquivo.empty()) {
            cout<< "Digite o nome do arquivo: " << endl;
            cin>> _arquivo;
        }

        this->_fp = fopen(this->_arquivo.c_str(), "r");

        if (this->_fp == false) {
            this->_arquivoNaoEncontradoCounter--;
            this->_arquivo.clear();
            _clrscr();

            if (this->_arquivoNaoEncontradoCounter == 0) {
                cout<< "Terminando execução do aplicativo." << endl << endl;
                exit (0);
            }

            cout<< "Arquivo nao existe. ";
            cout<< "Tentativas restantes: "
                << this->_arquivoNaoEncontradoCounter << endl;
        }
    }
    while (this->_fp == false);

    /*
     * OK, arquivo aberto
     * agora vamos ler e armazenar o conteúdo no vetor
     */
    while (!feof(this->_fp)) {
        fgets(this->_buffer, 100, this->_fp);
        this->_programa.push_back(this->_buffer);
    }
    /*
     * Por algum mistério misterioso do oculto desconhecido,
     * a última linha está sendo duplicada... vamos removê-la
     */
    this->_programa.pop_back();

    fclose(this->_fp);
    _clrscr();
}


inline void Interpretador::_parse()
{
    this->_parser = new Parser();
    vector<string>::iterator iter;

    for (iter  = this->_programa.begin();
         iter != this->_programa.end();
         iter++)
    {
        this->_parser->parse(*iter);
    }
}


inline void Interpretador::run()
{
    this->_abrirArquivo();
    this->_parse();
}

parser.h
Código: [Selecionar]
/**
 * Class: Parser
 * Identifica e analisa as instruções da máquina de 2 registradores, e
 * as executa adequadamente
 */
class Parser
{
    private:
        bool _loop;                      /* flag indicando o estado de loop */
        string _condicaoLoop;            /* condição de teste do loop */
        vector<string> _comandosLoop;    /* vetor contendo os comandos
                                            executados enquanto em loop */

        Maquina* _maquina;                        /* instância da Máquina */
        string _instrucao;                        /* próxima instrução a ser
                                                     executada */
        map<string, MaquinaMemberFn> _mapFuncoes; /* mapeamento das funções da
                                                     máquina de 2 registradores
                                                     com a classe Máquina */


        /**
         * Executa a próxima função identificada e armazenada em
         * Maquina::_instrucao
         *
         * @return void
         */
        void _execute();


    public:
        Parser();

        ~Parser();


        /**
         * Esta função recebe linha a linha as instruções da máquina de
         * 2 registradores, analisa a linha, separa as instruções e
         * as executa
         *
         * @param string linha
         * @return void
         */
        void parse(string linha);
};



/* ********************************************* */

inline Parser::Parser()
    : _loop(false),
      _maquina(new Maquina())
{
    /*
     * Mapeando as instruções da máquina de 2 registradores
     * com o endereço de memória das funções reais
     * da classe Máquina
     *
     * Apesar de passar o endereço de memória da classe
     * e não da instância, os métodos são executados corretamente
     * pois quando CALL_MEMBER_FN é chamado, o primeiro parâmetro
     * é a instância real da classe
     */
    this->_mapFuncoes["leiaa"]     = &Maquina::leiaA;
    this->_mapFuncoes["subtraia"]  = &Maquina::subtraiA;
    this->_mapFuncoes["adicionab"] = &Maquina::adicionaB;
    this->_mapFuncoes["mostrab"]   = &Maquina::mostraB;
}

inline Parser::~Parser()
{
    this->_comandosLoop.clear();
    this->_mapFuncoes.clear();
}


inline void Parser::_execute()
{
    /*
     * Removendo o último caractere (provavelmente um \0)
     * porque com ele não estava funcionando
     */
    string instrucao = this->_instrucao.substr(0, this->_instrucao.length()-1);

    /*
     * verifica se a instrução está vazia
     * se não estiver, a executa
     */
    if (!instrucao.empty()) {
        CALL_MEMBER_FN(*this->_maquina, this->_mapFuncoes[instrucao])();
    }

    /*
     * Verifica se estamos em modo de loop e se o vetor contendo os
     * comandos não está vazio
     */
    if ((this->_loop == true) && (this->_comandosLoop.empty() == false)) {
        while (!this->_maquina->testaA()) { // até (a_zero)
            vector<string>::iterator iter;
            for (iter  = this->_comandosLoop.begin();
                 iter != this->_comandosLoop.end();
                 iter++)
            {
                // Executando a instrução
                CALL_MEMBER_FN(*this->_maquina, this->_mapFuncoes[*iter])();
            }
        }

        /*
         * Após tudo executado, limpa o vetor e sai
         * do modo de loop
         */
        this->_comandosLoop.clear();
        this->_loop = false;
    }
}


inline void Parser::parse(string linha)
{
    // Limpa a instrução caso ela ainda tenha algo armazenado
    this->_instrucao.clear();

    unsigned int tamanho = linha.size()-1;
    for (unsigned int i = 0; i <= tamanho; i++)
    {
        char ch = linha[i];

        /*
         * Ignora os caracteres "_" [underline] e " " [espaço]
         *
         * [underline]: para evitar erros na hora da "programação"
         *              da máquina. Dessa forma, os comandos leia_A,
         *              leiaA, leia_a e leiaa são todos interpretados
         *              corretamente.
         *
         * [espaço]: já ignoro e removo os espaços aqui para
         *           não precisar identificá-los e tratá-los
         *           mais para frente
         */
        if (ch == '_' || ch == ' ')
            continue;


        if (this->_instrucao == "ate")
        {
            if (ch == '(')
                continue;

            if (ch == ')') {
                this->_loop = true; // entrando em modo loop
                this->_instrucao.clear();
                continue;
            }

            this->_condicaoLoop += ch; // armazenando a condição
                                       // do loop: a_zero
            continue;
        }


        if (this->_loop == true) {
            if (this->_instrucao == "faca")
                this->_instrucao.clear();

            if (ch == '(')
                continue;

            if (ch == ')' || ch == ',') {
                // adicionando os comandos do loop no vetor
                // para execução
                this->_comandosLoop.push_back(this->_instrucao);
                this->_instrucao.clear();
                continue;
            }
        }

        /*
         * transformando os caracteres em minúsculo para
         * facilitar a identificação e corrigir as variações
         * da máquina de 2 registradores
         */
        this->_instrucao += tolower(ch);
    }

    // Execta a instrução
    this->_execute();
}

maquina.h
Código: [Selecionar]
/**
 * Class: Maquina
 * Máquina de 2 registradores de von Neumann
 * (é esse o nome do tizão né?)
 *
 * contém as funções leiaA(), testaA(), subtraiA(), adicionaB(), mostraB()
 */
class Maquina
{
    private:
        int A, B; // registradores


    public:
        Maquina();

        /**
         * leia_A
         * Recebe o valor de A
         *
         * @return void
         */
        void leiaA();

        /**
         * a_zero
         * Testa se A <= 0
         *
         * @return true
         */
        bool testaA();

        /**
         * subtrai_A
         * Subtrai A uma vez enquanto Maquina::testaA() for verdadeiro
         *
         * @see Maquina::testaA()
         * @return void
         */
        void subtraiA();

        /**
         * adiciona_B
         * Adiciona B uma vez enquanto Maquina::testaA() for verdadeiro
         *
         * @see Maquina::adicionaB()
         * @return void
         */
        void adicionaB();

        /**
         * mostra_B
         * Mostra o valor de B
         *
         * @return void
         */
        void mostraB();
};



/* ********************************************* */

inline Maquina::Maquina() { }

inline void Maquina::leiaA()
{
    string frase = "Digite o valor de A (número inteiro): ";
    cout<< frase;

    while (!(cin>> this->A)) {
        string buffer;
        cin.clear();
        _clrscr();
        cout<< "Hmmmmm! Você não digitou um número inteiro." << endl;
        cin>> buffer;
        cout<< frase;
    }

    // define B = 0
    this->B = 0;
}


inline bool Maquina::testaA()    { return this->A <= 0; }

inline void Maquina::subtraiA()  { this->A--; }

inline void Maquina::adicionaB() { this->B++; }

inline void Maquina::mostraB()   { cout<< "O valor de B é: "
                                       << this->B << endl; }

4
Programação e Scripts / Interpretador - Máquina von Neumann - C++
« Online: 18 de Maio de 2007, 09:45 »
Olá pessoal, tudo bem?

Por favor, veja se alguém de vocês pode me ajudar.

É o seguinte, preciso implementar uma máquina de von Neumann para 2 registradores em C++. Para isso preciso criar um pequeno interpretador que leia o código da máquina, identifique e execute as funções corretamente e me dê o resultado final.

O código da máquina de von Neumann é basicamente isso:

Código: [Selecionar]
leiaA
ate (azero)
faca (subtraiA, adicionaB, adicionaB)
mostraB

Esse código fica em um arquivo separado. Toda a estrutura do programa básica (abrir o arquivo, ler o arquivo, armazenar cada linha em um vetor, etc) está pronta. Estou perdido mesmo em como identificar e executar cada uma das funções.

Não estou pedindo nenhum script pronto, apenas um auxílio (ou melhor, uma luz) para como fazer isso.

Muito obrigado desde já.

[ ]'s

5
Hardware e Periféricos / Re: Dúvidas: Ubuntu + Pentium D
« Online: 16 de MAR?O de 2007, 13:12 »
Olá Ieshua

Eu imaginei mesmo que fosse o kernel que desse suporte à múltiplos processadores, mas eu me enrolei na hora de postar a dúvida acabei perguntando sobre a distruibuição.

Muito obrigado pela respsota.

[ ]'s
Luiz

6
Hardware e Periféricos / Dúvidas: Ubuntu + Pentium D
« Online: 15 de MAR?O de 2007, 08:53 »
Olá pessoal, tudo bem?

Vi no tópico Em que Hardware o Ubuntu está rodando? que algumas pessoas estão rodando o Ubuntu em processadores multiprocessados.

Estamos trocando as máquinas da empresa por equpamentos Dell Optiflex com processadores Pentium D e, seguindo a cronologia, a minha está dentro das que serão trocadas agora.

Minhas dúvidas são:
- o Ubuntu trabalha normalmente com processadores multiprocessados como o Pentium D? Digo, ele aproveita todos os recursos que o processador oferece? Basicamente, ele reconhece e trabalha com os "dois processadores" normalmente?
- a instalação é normal, ou seja, instala-se como em qualquer outro computador ou é preciso fazer configurações diferentes para funcionar?

Desde já muito obrigado. :-)

7
Aplicativos / Erro ao gravar... .mkv?
« Online: 30 de Janeiro de 2007, 09:17 »
Olá pessoal

Está acontecendo algo que tem me deixado intrigado.

Tenho vários arquivos em MKV (Matroska video) que estou tentando gravar em um DVD (como dados mesmo, sem conversão). Acontece que  chega em um determinado ponto e dá erro na gravação.

Na primeira vez que isso aconteceu, pensei que os arquivos podiam estar corrompidos, ou algo assim, e excluí tudo (aproximadamente 4gb). Baixei outros arquivos (outros vídeos, nada a ver com os primeiros) também em Matroska e, quando fui gravar, deu na mesma.

O problema não é no gravador, já que consigo gravar/ler qualquer outro DVD, seja de dados ou autorado.

Já aconteceu isso com alguém? Alguém sabe o que fazer? Já perdi 4 DVDs com isso, testando com o GnomeBaker, com o Brasero e com o k3b, todos dão o mesmo problema.

Desde já agradeço pela ajuda =)

8
Servidores / Monitoramento de tráfego no servidor
« Online: 10 de Novembro de 2006, 15:34 »
Olá pessoal, tudo bem?

Montamos um servidor aqui na empresa com firewall/NAT/DHCP, responsável pelo compartilhamento de Internet na empresa (aproximadamente 25 máquinas).

Aqui a coisa é liberada: aMule, Gaim, Internet, todo mundo pode usar a vontade, a única recomendação é para usar, principalmente o aMule (e programa de transferências de arquivos) depois do expediente ou final de semana.

Tudo funciona muito bem, mas tem uns cabeças de bagres que não respeitam e deixam ligado o dia todo. Ficar indo de mesa em mesa verificando o que cada um tem aberto é inviável e ineficaz, porque após ver um dos pc's e ir para outro, esse primeiro poderia abrir o programa novamente.

Preciso de algum monitor de conexões/transferência no servidor, on-the-fly que me dê o IP, a porta de conexão, o tráfego gerado e, se possível, o programa que usa esse protocolo e o nome da máquina que está usando o recurso.

Assim poderíamos ser mais efetivos e mais discretos na "bronca".

Atualmente estamos usando o ntop, mas queria saber se existe algum outro melhor, mais eficaz.

De antemão já agradeço a ajuda de vocês.

[ ]'s

9
Aplicativos / Re: Programa para torrents leve como o µTorrent, tem como?
« Online: 31 de Outubro de 2006, 17:23 »
Tem também o Deluge - link: http://zachtib.googlepages.com/deluge

Não lembro se achei ele no Vivaolinux ou se foi no www.getdeb.com, mas ele é feito em GTK2 e é muito leve.

Só não posso falar muito dos recursos dele pois não testei ainda, mas fica a dica aí para vocês.

[ ]'s

10
Programação e Scripts / Re: Subistituto do Front Page e envio de ftp
« Online: 27 de Outubro de 2006, 16:54 »
Um ótimo cliente FTP é o FileZilla:

.deb http://www.getdeb.net/getdeb.php?file=filezilla_3.0.0beta2-getdeb1%7Edapper_i386.deb
Projeto: http://filezilla.sourceforge.net (apesar de poder baixar o binário só para Windows, pode baixar o fonte e compilar no Linux)

Abraços.

11
Áudio e Vídeo / Re: Audacity
« Online: 27 de Outubro de 2006, 16:36 »
Olá

Isso acontece quando você tem algum outro programa usando sua placa de som, provavelmente por estar ouvindo música. Feche o programa e tente abrir o Audacity novamente.

Em todo caso, pode digitar no terminal também:
$ sudo killall esd

Abraços

12
Hardware e Periféricos / Gravador de DVD voltou a funcionar?
« Online: 20 de Outubro de 2006, 10:48 »
Olá pessoal, tudo bem?

Tenho um combo LG GSA-4120B já há uns 2 anos. Usava o WindowsXP e um dia ele parou de funcionar para DVD, virou apenas um gravador de CD. Não reconhecia os discos (tentei de várias marcas) virgens e nem os DVD's originais.

Há 1 mês e meio mais ou menos migrei para o Ubuntu, mas nunca pensei em "testar" o DVD denovo. Até que hoje eu fui colocar um CD de vídeo, mas não era um Cd, era um DVD e... FUNCIONOU!!!

Sim, isso mesmo... voltou a funcionar, e inclusive voltou a gravar. Gravei um CD de dados e consegui ler tanto nele como em outros leitores.

Alguém já passou por isso? Aliás, alguém tem alguma explicação para isso? hehehe

Viva o Ubuntu!  ;D

13
Aplicativos / Re: Renomear arquivos em massa
« Online: 09 de Outubro de 2006, 18:06 »
Olá pessoal, desculpe a demora, não deu para acessar o fórum esses últimos dias.

Obrigado pelas dicas, testei todos e dá para fazer o que eu preciso usando um pouco de cada um.

Abraços.

14
Aplicativos / Renomear arquivos em massa
« Online: 06 de Outubro de 2006, 10:28 »
Olá pessoal, tudo bem?

Estou procurando um renomeador de arquivos em massa.

Atualmente estou usando o que veio com o Thunar. Ele é ótimo, permite renomear usando expressões regulares, mudar para maiúsculas/minúsculas e várias outras opções, mas o que mais sinto falta é uma opção de salvar "macros" (estou acostumado com os termos do Windows, não sei se em Linux isso é chamado assim).

Alguém conhece algum?

Abraçcos e obrigado.

15
Aplicativos / Re: Gaim2 Beta 3
« Online: 13 de Setembro de 2006, 17:11 »
Olá pessoal, boa tarde

Instalei o Ubuntu recentemente (na verdade ontem) e tentei atualizar o GAIM para a última versão (conforme os pacotes disponibilizados).

Consegui e está tudo funcionando corretamente, sem nenhum problema.

Abraços

Páginas: [1]