Biblioteca Reg corrigida

[adalberto]

Fiz uma correção na biblioteca reg.pris, nas funções reg.leiaArquivo() e reg.graveArquivo();

para ler arquivos como fotos, vídeos, pdf etc. ou gravá-los novamente.

você pode baixar o arquivo corrigido em:  http://linguagemprisma.br4.biz/blog/wp-content/uploads/2016/04/lib_reg_instal.zip

Página com tutorial aqui: http://linguagemprisma.br4.biz/blog/uncategorized/biblioteca-reg/

ou se preferir logo abaixo vai o código completo da biblioteca reg bastando salvar na pasta padrão de bibliotecas prisma:

No Windows em C:\\Prisma\\1.0\\bin\\plibs\\reg.pris

No Linux:  /usr/local/share/prisma/1.0/plib/reg.pris

segue o código:

Código Selecionar Expandir

//biblioteca para salvar e acessar configurações:
//autor Adalberto Amorim Felipe, licença livre para copiar, usar, modificar, sem responsabilizar o autor pelo uso.
//data: 7/01/2016; qui 16:40 Diamantino MT;

//13/04/2016 -- correção nos comandos reg.graveArquivo() e reg.leiaArquivo()
//estava corrompendo arquivos binários, como fotos, .exe, pdf etc.

/**
   
    Atenção! Cuidado ao modificar este arquivo, qualquer erro pode comprometer o funcionamento.
   
    Mas, mexa a vontade se quiser, especialmente se for fazer aprimoramentos.
   
    E caso os aprimoramentos possam ser úteis aos demais poste em:
   
    http://linguagemprisma.br4.biz/prisma_forum/index.php?board=5.0
   
**//


reg = {};


//funcao para compilar em prisma mesmo, sem usar o prismac
funcao reg_arq_compile(sa,en,d)
local d = d ou 1;
          local f = carreguearquivo(en);
          se nao f entao erro( 'Erro ao carregar arquivo: ' .. en );
          senao
                 local cstr = string.compile(f,d); //1 para resumir a string compilada sem dados de debug
                 local a = es.abra(sa,'escritabin');
                 se nao a entao erro('Erro ao tentar abrir arquivo: ' .. sa );
                 senao
                       //grava a
                       a:escreva(cstr);//escreve a string compilada
                       a:feche(); //fecha o objeto de gravação de arquivos.
                 fim
                 
          fim
fim


codigo_erro = 0;

funcao def_tabela( f, chave , tab)
  se tipo(chave) == 'numero' entao
     f:escreva( '{' );
  senao
     f:escreva( chave , '={');
  fim

  para c , v em pares(tab) inicio
 
     se tipo(v) == 'string' entao
       v = string.formate('%q' , v);
     fim
     se v == falso entao v = 'falso'
     senaose v == verdadeiro entao v = 'verdadeiro'
     fim
     
     se tipo(v) == 'tabela' entao
           def_tabela( f , c , v );
     senao
     
        se tipo(c) == 'numero' entao
          f:escreva( v , ',' );
        senao
          f:escreva( c , '=' , v , ',');
        fim
     fim //fim se tipo(v) == 'tabela'
  fim//fim para c, v
 
  f:escreva('};');

fim //fim funcao def_tabela

funcao reg.grave( a, tab )

   se tipo(tab) <> 'tabela' entao retorne falso , codigo_erro fim;
   se nao a entao retorne falso , codigo_erro fim;
   
   local f = es.abra( a , 'escrita'); //abrindo o arquivo para escrita;
      se f entao //se o arquivo aberto for válido entao:
     
          //abrindo a tabela e gravando:
          para c , v em pares(tab) inicio
             
              se tipo (v) == 'string' entao
                 v = string.formate("%q",v);
              fim
             
              se v == falso entao
                   v = 'falso';
              senaose v == verdadeiro entao
                   v = 'verdadeiro';             
              fim
             
              se tipo(v) == 'tabela' entao
                 def_tabela( f , c, v );
                 f:escreva('\n');
              senao
                 se tipo(c) == 'numero' entao
                 f:escreva( v , ';\n');
                 senao
                 f:escreva(c ,'=', v , ';\n');
                 fim
              fim
         
          fim //fim para;
         
          f:feche();
          retorne verdadeiro;         
      senao
          retorne falso , codigo_erro ;
      fim //fim se f
fim //fim funcao reg.grave()


//leitura:
funcao reg.leia( a )

se nao a entao retorne falso , codigo_erro ; fim

    local f = es.abra(a , 'leitura');
    local str = nulo;
      se f entao
     
          str = f:leia('*t');
          f:feche();
         
      senao
          retorne falso , codigo_erro;
      fim //fim se f
     
   se str <> nulo entao
   
      local load = string.formate("retorne{%s}" , str);
         
      local obt_tab_conf = carregue( load );
      se obt_tab_conf entao
            retorne obt_tab_conf();
      senao
          retorne falso , codigo_erro;           
      fim
   
   fim //fim se str <> nulo...   

fim //fim funcao reg.leia


funcao reg.adicione( a, tab )

se tipo(tab) <> 'tabela' entao retorne falso , codigo_erro fim;
   se nao a entao retorne falso , codigo_erro fim;
   
   local f = es.abra( a , 'adicao'); //abrindo o arquivo para escrita;
      se f entao //se o arquivo aberto for válido entao:
     
          //abrindo a tabela e gravando:
          para c , v em pares(tab) inicio
             
              se tipo (v) == 'string' entao
                 v = string.formate("%q",v);
              fim
                         
              se v == falso entao
                   v = 'falso';
              senaose v == verdadeiro entao
                   v = 'verdadeiro';             
              fim
             
              se tipo(v) == 'tabela' entao
               
                 def_tabela( f ,c, v );
                 f:escreva('\n');
              senao
              f:escreva(c ,'=', v , ';\n');
              fim
         
          fim //fim para;
         
          f:feche();
          retorne verdadeiro;
         
      senao
          retorne falso , codigo_erro ;
      fim //fim se f
       
fim //fim funcao reg.adicione

/**
funcao reg.compile( a )
       local f = es.abra(a, 'leitura');
       local str = nulo;
          se f entao
              str = f:leia'*t';
              f:feche();
              local load = string.formate('retorne{%s}' , str );
                  local f = es.abra(a , 'escritabin');
                  se f entao
                      f:escreva( load );
                      f:feche();
                      local cmd = reg.prismac .. ' -o ' .. a .. ' ' .. a
                      local ret = sis.execute( cmd );
                      retorne ret,'prismac nao encontrado'; //se prismac for executado o retorno é verdadeiro senao é falso. erro prismac nao encontrado.
                  senao
                      retorne falso , codigo_erro;
                  fim
             
          senao
               retorne falso , codigo_erro;
          fim
fim //fim funcao reg.grave()

**//

funcao reg.compile( a, tab )

   se tipo(tab) <> 'tabela' entao retorne falso , codigo_erro fim;
   se nao a entao retorne falso , codigo_erro fim;
   
   local f = es.abra( a , 'escrita'); //abrindo o arquivo para escrita;
      se f entao //se o arquivo aberto for válido entao:
     
      f:escreva('retorne{');
     
          //abrindo a tabela e gravando:
          para c , v em pares(tab) inicio
             
              se tipo (v) == 'string' entao
                 v = string.formate("%q",v);
              fim
             
              se v == falso entao
                   v = 'falso';
              senaose v == verdadeiro entao
                   v = 'verdadeiro';             
              fim
             
              se tipo(v) == 'tabela' entao
                 def_tabela( f , c, v );
                 f:escreva('\n');
              senao
                 se tipo(c) == 'numero' entao
                 f:escreva( v , ';\n');
                 senao
                 f:escreva(c ,'=', v , ';\n');
                 fim
              fim
         
          fim //fim para;
          f:escreva('}');
          f:feche();
          reg_arq_compile(a,a); //esta função compila o arquivo de configuração sem precisar do prismac
          retorne verdadeiro;       
      senao
          retorne falso , codigo_erro ;
      fim //fim se f
       

fim //fim funcao reg.compile()

funcao reg.carregue( a )
     local func = carreguearquivo( a );
     se func entao
        retorne func();
     senao
        retorne falso , codigo_erro;
     fim
fim

funcao reg.limpe(a)   
   local f = es.abra(a,'escrita');
   se f entao
          f:escreva('');
   senao
      retorne falso, codigo_erro;
   fim
fim

funcao reg.leiaArquivo(b)
            local txt = '';
            local erro = '';
            local a = es.abra(b,'leiturabin');
                    se a entao
                         txt = a:leia'*t';
                         a:feche();
                         retorne txt;
                    senao
                        erro = 'erro ao abrir arquivo';
                        retorne nulo, erro;
                    fim           
fim

funcao reg.graveArquivo(b,txt)
         local a = es.abra(b,'escritabin');
         se a entao
                    a:escreva(txt);
                    a:feche();
                    retorne verdadeiro;
         senao
                    retorne falso, 'erro ao tentar abrir arquivo';
         fim
fim

retorne reg;



Até mais.