em dois tempos isso é “desofuscado” qse q por completo (Abrir e executar)
dps com a ajuda de um Refatorador vc faz o resto.
rsrs.
“distribui sua aplicação”
como seria pra trabalhar com PAF-ECF por exemplo?
[quote=x@ndy][quote=juliocbq]
Agora você está falando besteira. Assembly e c é para hardware. Utilizamos java e c++ para alto nível.[/quote]
Por que besteira? Quer dizer que eu não posso utilizar C e Assembly para fazer programas em alto nível? Eu mesmo já criei interfaces gráficas para o windows e programas de alto nível utilizando C!
PS:
É necessário apenas ter o conhecimento necessário para fazer o programas de alto nível utilizando C. Com certeza não é uma tarefa fácil, exige um trabalho monstruoso, mas é possivel sim, agora porque eu vou fazer isso em C se existe linguagens e frameworks que já fizeram isso para mim?[/quote]
Linguagem c é para sistemas, não para aplicações. Você não vai escrever alto nível com c porque a sintaxe foi feita para se fazer o que o assembly faz com recursos mais amigáveis. Você pode até usar um toolkit como gtk(que é escrito em c) mas para fazer aplicações é preferível usar uma ferramenta de alto nível. Eu citei o caso do assembly porque é uma ferramenta que você precisa até mesmo mapear os endereços de memória que vai utilizar para alocar uma variável ali. E o pessoal escreve com a mesma facilidade que eu escrevo java, c++ ou c. Falei do conhecimento objetivando mostrar que, quando você sabe o que fazer não existe tarefa difícil.
eu uso assembly pra desenvolver pra microcontrolador/microprocessador.
pq vc usando uma linguagem de nivel um pouco mais alto vc perde mt optimização.
mas agora eu to preferindo as vezes fazer em pascal, dado a complexidade do programa,
e dps fazendo intervenção em pontos mais criticos direto no assembly.
cheguei a fazer um descompilador q implementa uma especie de refatorador pra dps re-montar td já optimizado;
[quote=GilsonNunes]meu prob não resolvido com o java é ele não compilar. só traduzir.
vc arrasta o prog e solta num descompilador(tradutor) ele mostra td seu fonte.
tem solução?[/quote]
Se você usar um obfuscador vai resolver o problema. O proguard é uma ferramenta muito boa para esse tipo de solução.
Você vai ter que configurar alguns parâmetros porque o obfuscamento afeta o funcionamento do software que usa reflection, mas existe toda uma documentação adequada.
O obfuscamento funciona encriptpgrafando nome de classes e variáveis, criando uma tabela de referência.
getIntPoint(int x, y) pode se transformar em algo do tipo xyz(int o, int p);
Aqui, um bom artigo sobre.
[quote=GilsonNunes]eu uso assembly pra desenvolver pra microcontrolador/microprocessador.
pq vc usando uma linguagem de nivel um pouco mais alto vc perde mt optimização.
mas agora eu to preferindo as vezes fazer em pascal, dado a complexidade do programa,
e dps fazendo intervenção em pontos mais criticos direto no assembly.
cheguei a fazer um descompilador q implementa uma especie de refatorador pra dps re-montar td já optimizado;[/quote]
Você pode usar pascal e usar assembly inline para otimizar alguns trechos críticos. Por exemplo, já tive problemas com memcpy da api do proprio win, e consegui contornar o problema criando um similar usando asm inline.
[quote=GilsonNunes]em dois tempos isso é “desofuscado” qse q por completo (Abrir e executar)
dps com a ajuda de um Refatorador vc faz o resto.
rsrs.
"distribui sua aplicação"
como seria pra trabalhar com PAF-ECF por exemplo?[/quote]
Esse foi só um exemplo. Já vi código que fica totalmente ilegível. Refatorar o código não ia ajudar muito, pois você não saberia o que uma função ou variável faz, então renomear e ter algo que faça sentido vai demorar muito, vão ser necessários várias refatorações e muita dedicação e o tempo dedicado sera diretamente proporcional ao tamanho do sistema.
Aplicações web não necessitam de distribuição, por isso que falei se você “distribui sua aplicação”.
[quote=juliocbq]
Linguagem c é para sistemas, não para aplicações. Você não vai escrever alto nível com c porque a sintaxe foi feita para se fazer o que o assembly faz com recursos mais amigáveis. Você pode até usar um toolkit como gtk(que é escrito em c) mas para fazer aplicações é preferível usar uma ferramenta de alto nível. Eu citei o caso do assembly porque é uma ferramenta que você precisa até mesmo mapear os endereços de memória que vai utilizar para alocar uma variável ali. E o pessoal escreve com a mesma facilidade que eu escrevo java, c++ ou c. Falei do conhecimento objetivando mostrar que, quando você sabe o que fazer não existe tarefa difícil.[/quote]
Concordo com você principalmente aqui: "Você pode até usar um toolkit como gtk(que é escrito em c) mas para fazer aplicações é preferível usar uma ferramenta de alto nível"
Ferramentas de alto nivel abstraem a complexidade e isso otimiza o trabalho mas não isenta o programador de saber como as coisas funcionam. Por isso que não acho que é preguiça utilizar uma linguagem que use gerenciamento automático de memória.
A meu ver, se estou desenvolvendo um sistema de cobrança, por exemplo, tenho que me preocupar em modelar o sistema da melhor maneira para esse dominio. Ao acrescentar ao projeto o gerenciamento de memória dos objetos desse dominio, estou colocando uma responsabilidade que não faz parte do dominio da aplicação.
[quote=juliocbq][quote=GilsonNunes]eu uso assembly pra desenvolver pra microcontrolador/microprocessador.
pq vc usando uma linguagem de nivel um pouco mais alto vc perde mt optimização.
mas agora eu to preferindo as vezes fazer em pascal, dado a complexidade do programa,
e dps fazendo intervenção em pontos mais criticos direto no assembly.
cheguei a fazer um descompilador q implementa uma especie de refatorador pra dps re-montar td já optimizado;[/quote]
Você pode usar pascal e usar assembly inline para otimizar alguns trechos críticos. Por exemplo, já tive problemas com memcpy da api do proprio win, e consegui contornar o problema criando um similar usando asm inline.
[/quote]
é isso mesmo.
sobre o ofuscador não é bem uma criptografia é uma troca de nomes. seria o mesmo q eu ja programasse com nomes estranhos (lógico q seria caos).
mas isso é balela pra quem ta acostumado mecher com descompilacao em assembly.
qdo olho pra um codigo java ofuscado eu vejo um codigo melhor q asm32 documentado (só vc ler e dar nomes aos bois com rafator).
Alguém sabe dizer se existe alguma ferramenta / framework para testes unitários em Delphi?
[quote=juliocbq][quote=GilsonNunes]eu uso assembly pra desenvolver pra microcontrolador/microprocessador.
pq vc usando uma linguagem de nivel um pouco mais alto vc perde mt optimização.
mas agora eu to preferindo as vezes fazer em pascal, dado a complexidade do programa,
e dps fazendo intervenção em pontos mais criticos direto no assembly.
cheguei a fazer um descompilador q implementa uma especie de refatorador pra dps re-montar td já optimizado;[/quote]
Você pode usar pascal e usar assembly inline para otimizar alguns trechos críticos. Por exemplo, já tive problemas com memcpy da api do proprio win, e consegui contornar o problema criando um similar usando asm inline.
[/quote]
Como você fez isso? Faz tempo que tentei acessar a porta paralela utilizando assembly inline e não consegui por que o windows estava bloqueando. Eu até conseguia fazer funcionar com o Win98, mas a partir do XP começou a bloquear! Como não era nada importante não fui atrás para saber o que aconteceu!
Ai você tem razão, se o cara é bom em descompilar em assembly, não vai fazer muita diferença. Mas isso não é qualquer um que faz isso né…
[quote=x@ndy][quote=juliocbq]
Linguagem c é para sistemas, não para aplicações. Você não vai escrever alto nível com c porque a sintaxe foi feita para se fazer o que o assembly faz com recursos mais amigáveis. Você pode até usar um toolkit como gtk(que é escrito em c) mas para fazer aplicações é preferível usar uma ferramenta de alto nível. Eu citei o caso do assembly porque é uma ferramenta que você precisa até mesmo mapear os endereços de memória que vai utilizar para alocar uma variável ali. E o pessoal escreve com a mesma facilidade que eu escrevo java, c++ ou c. Falei do conhecimento objetivando mostrar que, quando você sabe o que fazer não existe tarefa difícil.[/quote]
Concordo com você principalmente aqui: "Você pode até usar um toolkit como gtk(que é escrito em c) mas para fazer aplicações é preferível usar uma ferramenta de alto nível"
Ferramentas de alto nivel abstraem a complexidade e isso otimiza o trabalho mas não isenta o programador de saber como as coisas funcionam. Por isso que não acho que é preguiça utilizar uma linguagem que use gerenciamento automático de memória.
A meu ver, se estou desenvolvendo um sistema de cobrança, por exemplo, tenho que me preocupar em modelar o sistema da melhor maneira para esse dominio. Ao acrescentar ao projeto o gerenciamento de memória dos objetos desse dominio, estou colocando uma responsabilidade que não faz parte do dominio da aplicação.
[/quote]
Sim, mas é válido quando você já sabe como as coisas funcionam. Esse é o ponto. Você quer escrever um programa em pascal ou c++, ótimo, mas saiba como. A mesma idéia serve para qualquer outra ferramenta mesmo que seja de baixo nível. É questão de know how como dizem.
[quote=x@ndy][quote=juliocbq][quote=GilsonNunes]eu uso assembly pra desenvolver pra microcontrolador/microprocessador.
pq vc usando uma linguagem de nivel um pouco mais alto vc perde mt optimização.
mas agora eu to preferindo as vezes fazer em pascal, dado a complexidade do programa,
e dps fazendo intervenção em pontos mais criticos direto no assembly.
cheguei a fazer um descompilador q implementa uma especie de refatorador pra dps re-montar td já optimizado;[/quote]
Você pode usar pascal e usar assembly inline para otimizar alguns trechos críticos. Por exemplo, já tive problemas com memcpy da api do proprio win, e consegui contornar o problema criando um similar usando asm inline.
[/quote]
Como você fez isso? Faz tempo que tentei acessar a porta paralela utilizando assembly inline e não consegui por que o windows estava bloqueando. Eu até conseguia fazer funcionar com o Win98, mas a partir do XP começou a bloquear! Como não era nada importante não fui atrás para saber o que aconteceu![/quote]
Você só pode ler e escrever em registradores que não setam interrupções. As versões mais recentes do windows possuem uma máquina virtual que não te deixa escrever neles como medida de proteção.
No caso do memcpy é simplesmente mover valores em endereços de memória.
Se for fazer uma comparação de arquitetura, os sistemas POSIX(portable operating system interface) são bem melhores para programação de sistemas, pois todo dispositivo é um arquivo.
Ex: enviar dados na porta serial simplesmente abrindo o arquivo /dev/ttyx:
x = open("/dev/ttyx", O_RDWR)
x << “teste”;
ler do teclado ou hd, usb, porta setial é sempre a mesma coisa
open("/dev/device", O_RDWR);
já que dispositivos ou são dispositivos de caracteres(teclado, mouse, etc…) ou blocos(hd, usb e qualquer dispo de armazenamento).
Já com windows precisa da api da microsof, ou seja, um parto.
[quote=x@ndy][quote=juliocbq][quote=GilsonNunes]eu uso assembly pra desenvolver pra microcontrolador/microprocessador.
pq vc usando uma linguagem de nivel um pouco mais alto vc perde mt optimização.
mas agora eu to preferindo as vezes fazer em pascal, dado a complexidade do programa,
e dps fazendo intervenção em pontos mais criticos direto no assembly.
cheguei a fazer um descompilador q implementa uma especie de refatorador pra dps re-montar td já optimizado;[/quote]
Você pode usar pascal e usar assembly inline para otimizar alguns trechos críticos. Por exemplo, já tive problemas com memcpy da api do proprio win, e consegui contornar o problema criando um similar usando asm inline.
[/quote]
Como você fez isso? Faz tempo que tentei acessar a porta paralela utilizando assembly inline e não consegui por que o windows estava bloqueando. Eu até conseguia fazer funcionar com o Win98, mas a partir do XP começou a bloquear! Como não era nada importante não fui atrás para saber o que aconteceu![/quote]
eu não desenvolvo app pra comunicar com o PIC, eu desenvolvo o SO q vai rodar no PIC.
tipo:
[code];***************************************************************************************************************************
;* Projeto: Automação com inteligencia (PIC ‘A’ comunicação com o PC) *
;* desenvolvido por: Gilson Nunes Para: Futura Soluções *
;***************************************************************************************************************************
;CRISTAL: 4MHz
;******************************** DEFINIÇÕES INICIAIS **********************************************************************
INCLUDE <P16F877A.INC>
__CONFIG _CP_OFF & _DEBUG_OFF & _WRT_OFF & _CPD_OFF & _LVP_OFF & _BODEN_OFF & _PWRTE_ON & _WDT_OFF & _XT_OSC
ERRORLEVEL -302
;******************************** DECLARAÇÕES DE VARIAVEIS *****************************************************************
#DEFINE BANCO_0 bcf status,rp0
#DEFINE BANCO_1 bSf status,rp0
#DEFINE LCD PORTB
#DEFINE SET_RAM PORTC,0
#DEFINE E_RAM PORTC,1
#DEFINE L_RAM PORTC,5
#DEFINE DADO_RAM PORTD
[/code]
Nunca tive a necessidade de acessar outros dispositivos além da porta serial e para algumas coisas a porta paralela. Mas para serial também acesso abrindo um arquivo:
FHandlePort := CreateFile(PChar(Format('COM%d',[FPort])),
GENERIC_READ or GENERIC_WRITE, 0, nil, OPEN_EXISTING, 0, 0);Agora para configurar os parâmetros de taxa de transferencia, bits de parada, etc, só acessando a API mesmo.
[code]procedure TdtCustomSerialComm.SetupDCB;
var
DCB: TDCB;
begin
if FActive and not (csDesigning in ComponentState) then
begin
if not GetCommState(FHandlePort, DCB) then
raise ESeriamComm.Create(SysErrorMessage(GetLastError));
DCB.BaudRate := FBaudRate;
DCB.Flags := 1;
if FParity <> prNone then
DCB.Flags := DCB.Flags or 2;
DCB.Parity := Byte(FParity);
case FFlowControl of
fcNone: DCB.Flags := DCB.Flags or 0;
fcXOnXOff: DCB.Flags := DCB.Flags or 896;
fcRtsCts: DCB.Flags := DCB.Flags or 8196;
fcDtrDsr: DCB.Flags := DCB.Flags or 40;
end;
case FStopBits of
1: DCB.StopBits := 0;
2: DCB.StopBits := 2;
end;
DCB.ByteSize := FDataBits;
DCB.XONChar := FXONChar;
DCB.XOFFChar := FXOFFChar;
DCB.XONLim := FRxBuffer * FXOnLimDiv div 100;
DCB.XOFFLim := FRxBuffer * FXoffLimDiv div 100;
if not SetCommState(FHandlePort, DCB) then
raise ESeriamComm.Create(SysErrorMessage(GetLastError));
end;
end;[/code]Como essas configurações são feitas em sistemas posix, como no linux?
[quote=GilsonNunes]tipo:
[code];***************************************************************************************************************************
;* Projeto: Automação com inteligencia (PIC ‘A’ comunicação com o PC) *
;* desenvolvido por: Gilson Nunes Para: Futura Soluções *
;***************************************************************************************************************************
;CRISTAL: 4MHz
;******************************** DEFINIÇÕES INICIAIS **********************************************************************
INCLUDE <P16F877A.INC>
__CONFIG _CP_OFF & _DEBUG_OFF & _WRT_OFF & _CPD_OFF & _LVP_OFF & _BODEN_OFF & _PWRTE_ON & _WDT_OFF & _XT_OSC
ERRORLEVEL -302
;******************************** DECLARAÇÕES DE VARIAVEIS *****************************************************************
#DEFINE BANCO_0 bcf status,rp0
#DEFINE BANCO_1 bSf status,rp0
#DEFINE LCD PORTB
#DEFINE SET_RAM PORTC,0
#DEFINE E_RAM PORTC,1
#DEFINE L_RAM PORTC,5
#DEFINE DADO_RAM PORTD
[/code][/quote]
Você não acha desperdício de tempo usar assembly num pic parrudo como o 16f877? O compilador da microship além de falcilitar pode otimizar o código que uma pessoa levaria dias para fazer.
[quote=GilsonNunes]
eu não desenvolvo app pra comunicar com o PIC, eu desenvolvo o SO q vai rodar no PIC.[/quote]
SO não, firmware, ok?
O seu software não organiza processos de outros programas, nem organiza sistema de arquivos ou paginação deles na ram.
Você pode fazer um bind diretamente entre a serial e o console por exemplo:
Dessa maneira tudo que chega na porta é redirecionado para o console
[code]#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>
int main(int argc,char** argv)
{
struct termios tio;
struct termios stdio;
int tty_fd;
fd_set rdset;
unsigned char c='D';
printf("Please start with %s /dev/ttyS1 (for example)\n",argv[0]);
memset(&stdio,0,sizeof(stdio));
stdio.c_iflag=0;
stdio.c_oflag=0;
stdio.c_cflag=0;
stdio.c_lflag=0;
stdio.c_cc[VMIN]=1;
stdio.c_cc[VTIME]=0;
tcsetattr(STDOUT_FILENO,TCSANOW,&stdio);
tcsetattr(STDOUT_FILENO,TCSAFLUSH,&stdio);
fcntl(STDIN_FILENO, F_SETFL, O_NONBLOCK); // make the reads non-blocking
memset(&tio,0,sizeof(tio));
tio.c_iflag=0;
tio.c_oflag=0;
tio.c_cflag=CS8|CREAD|CLOCAL; // 8n1, see termios.h for more information
tio.c_lflag=0;
tio.c_cc[VMIN]=1;
tio.c_cc[VTIME]=5;
tty_fd=open(argv[1], O_RDWR | O_NONBLOCK);
cfsetospeed(&tio,B115200); // 115200 baud
cfsetispeed(&tio,B115200); // 115200 baud
tcsetattr(tty_fd,TCSANOW,&tio);
while (c!='q')
{
if (read(tty_fd,&c,1)>0) write(STDOUT_FILENO,&c,1); // if new data is available on the serial port, print it out
if (read(STDIN_FILENO,&c,1)>0) write(tty_fd,&c,1); // if new data is available on the console, send it to the serial port
}
close(tty_fd);
}[/code]
Tem um wiki book de onde eu tirei esse exemplo
http://en.wikibooks.org/wiki/Serial_Programming/Serial_Linux
o compilador da microship compila pascal?