Temas

Bueno recién encontré una especie de bug que sucede al apretar las tecla de subir y bajar volumen las dos a la vez repetida cantidad de veces, prueben en el escritorio por ejemplo y verán (almenos en Win 10) que como que se pone la pantalla en negro (no es que se actualiza como con el F5)

Por favor requiero su ayuda para poder terminar este código, es similar al hacha, divide los archivos en 100 bytes pero no funciona como quiero que funcione, tengo pensado pasarlo a C++ por completo.

Código (cpp) [Seleccionar] Expandir

// copia.c: Copia de ficheros
// Uso: copia <fichero_origen> <fichero_destino>
/// Teoria . . .
/// Se empieza por intentar hacer un divisor de archivos
/// Ingresa el archivo
/// Lee cabecera y si hay > es ok, < cierre...
/// > 2do es el nombre y 1ero > "/" es que hay carpeta
/// si la hay lee y va guardando caracter por caracter hasta en encontrar el
/// siguiente > es el tamaño hasta <, finaliza encabezado sigue hasta la cantidad de bytes
/// que se especificaron, si hay otro reinicia el proceso.

#include <stdio.h>
#include <iostream>
#include <string.h>
using namespace std;

int c=0;
int main(int argc, char **argv) {
   FILE *abrir, *crear;
//const int BUFSIZE=0x160000; // Tamaño del buffer
   //unsigned char buffer[BUFSIZE];
unsigned char buffer[1];
   int bytesLeidos;
char nombre[1023];
char divisor[1023];

   if(argc != 3) {
      cout<<"Usar: abrir <fichero_origen_ach>\n";
      return 1;
   }
// Abrir el fichero de entrada en lectura y binario
   abrir = fopen(argv[1], "rb");
   if(!abrir) {
      cout<<"El fichero "<<argv[1]<<" no existe o no puede ser abierto.\n";
      return 1;
   }
int co=0;
sprintf(divisor, "%d", co);
strcpy(nombre,argv[1]);
strcat(nombre,divisor);
printf(nombre);
getchar();

   // Crear o sobreescribir el fichero de salida en binario
   crear = fopen(nombre, "wb");
   if(!crear) {
      cout<<"El fichero "<<argv[1]<<" no puede ser creado.\n";
      fclose(abrir);
      return 1;
   }
int i=100;
   // Bucle de copia:

   while((bytesLeidos = fread(buffer, 1, 1, abrir))) {
if (c == i){
co++;
strcat(nombre,divisor);
strcpy(nombre,argv[1]);
sprintf(divisor, "%d", co);
printf(divisor); // prueba
getchar(); // prueba
}
fwrite(buffer, 1, bytesLeidos, crear);
c++;
}

   // Cerrar ficheros:
   fclose(abrir);
   fclose(crear);
   return 0;
}

Un regalo para ustedes que encontré por ahí   después de tanta ayuda prestada, muchos ya lo deben conocer, es un derivado de PAQ8 ¿Se acuerdan del famoso KGB archiver?, bueno este código usa casi el mismo método pero es mucho mas rápido y funciono en mi Android con CppDroid. Excepto WAV (Tiene un algoritmo especial), es muy superior que FreeARC.

Uso:

Código [Seleccionar] Expandir

paq9a a "saliente.paq9a" -0...9 "entrante.archivo"

Compilación:

Código [Seleccionar] Expandir

@path C:\MinGw\bin;%path%
g++ -fpermissive -O3 -s paq9a.cpp -o paq9a
pause
Web (muy buena): http://mattmahoney.net/dc/

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
#define NDEBUG  // remove for debugging
#include <assert.h>

int allocated=0;  // Total memory allocated by alloc()

// Create an array p of n elements of type T
template <class T> void alloc(T*&p, int n) {
 p=(T*)calloc(n, sizeof(T));
 if (!p) printf("Out of memory\n"), exit(1);
 allocated+=n*sizeof(T);
}

// 8, 16, 32 bit unsigned types (adjust as appropriate)
typedef unsigned char  U8;
typedef unsigned short U16;
typedef unsigned int   U32;

///////////////////////////// Squash //////////////////////////////

// return p = 1/(1 + exp(-d)), d scaled by 8 bits, p scaled by 12 bits
class Squash {
 short t[4096];
public:
 Squash();
 int operator()(int p) const {
   if (p>2047) return 4095;
 if (p<-2047) return 0;
   return t[p+2048];
 }
} squash;

Squash::Squash() {
int ts[33]={1,2,3,6,10,16,27,45,73,120,194,310,488,747,1101,
   1546,2047,2549,2994,3348,3607,3785,3901,3975,4022,
   4050,4068,4079,4085,4089,4092,4093,4094};
int w,d;
 for (int i=-2047; i<=2047; ++i){
   w=i&127;
   d=(i>>7)+16;
   t[i+2048]=(ts[d]*(128-w)+ts[(d+1)]*w+64) >> 7;
   }
}

//////////////////////////// Stretch ///////////////////////////////

// Inverse of squash. stretch(d) returns ln(p/(1-p)), d scaled by 8 bits,
// p by 12 bits.  d has range -2047 to 2047 representing -8 to 8.  
// p has range 0 to 4095 representing 0 to 1.

class Stretch {
 short t[4096];
public:
 Stretch();
 int operator()(int p) const {
   assert(p>=0 && p<4096);
   return t[p];
 }
} stretch;

Stretch::Stretch() {
 int pi=0;
 for (int x=-2047; x<=2047; ++x) {  // invert squash()
   int i=squash(x);
   for (int j=pi; j<=i; ++j)
     t[j]=x;
   pi=i+1;
 }
 t[4095]=2047;
}

///////////////////////////// ilog //////////////////////////////

// ilog(x) = round(log2(x) * 16), 0 <= x < 64K
class Ilog {
 U8* t;
public:
 int operator()(U16 x) const {return t[x];}
 Ilog();
} ilog;

// Compute lookup table by numerical integration of 1/x
Ilog::Ilog(): t(65536) {
 U32 x=14155776;
 for (int i=2; i<65536; ++i) {
   x+=774541002/(i*2-1);  // numerator is 2^29/ln 2
   t[i]=x>>24;
 }
}

// llog(x) accepts 32 bits
inline int llog(U32 x) {
 if (x>=0x1000000)
   return 256+ilog(x>>16);
 else if (x>=0x10000)
   return 128+ilog(x>>8);
 else
   return ilog(x);
}

///////////////////////// state table ////////////////////////

// State table:
//   nex(state, 0) = next state if bit y is 0, 0 <= state < 256
//   nex(state, 1) = next state if bit y is 1
//
// States represent a bit history within some context.
// State 0 is the starting state (no bits seen).
// States 1-30 represent all possible sequences of 1-4 bits.
// States 31-252 represent a pair of counts, (n0,n1), the number
//   of 0 and 1 bits respectively.  If n0+n1 < 16 then there are
//   two states for each pair, depending on if a 0 or 1 was the last
//   bit seen.
// If n0 and n1 are too large, then there is no state to represent this
// pair, so another state with about the same ratio of n0/n1 is substituted.
// Also, when a bit is observed and the count of the opposite bit is large,
// then part of this count is discarded to favor newer data over old.

static const U8 State_table[256][4]={
 {  1,  2, 0, 0},{  3,  5, 1, 0},{  4,  6, 0, 1},{  7, 10, 2, 0}, // 0-3
 {  8, 12, 1, 1},{  9, 13, 1, 1},{ 11, 14, 0, 2},{ 15, 19, 3, 0}, // 4-7
 { 16, 23, 2, 1},{ 17, 24, 2, 1},{ 18, 25, 2, 1},{ 20, 27, 1, 2}, // 8-11
 { 21, 28, 1, 2},{ 22, 29, 1, 2},{ 26, 30, 0, 3},{ 31, 33, 4, 0}, // 12-15
 { 32, 35, 3, 1},{ 32, 35, 3, 1},{ 32, 35, 3, 1},{ 32, 35, 3, 1}, // 16-19
 { 34, 37, 2, 2},{ 34, 37, 2, 2},{ 34, 37, 2, 2},{ 34, 37, 2, 2}, // 20-23
 { 34, 37, 2, 2},{ 34, 37, 2, 2},{ 36, 39, 1, 3},{ 36, 39, 1, 3}, // 24-27
 { 36, 39, 1, 3},{ 36, 39, 1, 3},{ 38, 40, 0, 4},{ 41, 43, 5, 0}, // 28-31
 { 42, 45, 4, 1},{ 42, 45, 4, 1},{ 44, 47, 3, 2},{ 44, 47, 3, 2}, // 32-35
 { 46, 49, 2, 3},{ 46, 49, 2, 3},{ 48, 51, 1, 4},{ 48, 51, 1, 4}, // 36-39
 { 50, 52, 0, 5},{ 53, 43, 6, 0},{ 54, 57, 5, 1},{ 54, 57, 5, 1}, // 40-43
 { 56, 59, 4, 2},{ 56, 59, 4, 2},{ 58, 61, 3, 3},{ 58, 61, 3, 3}, // 44-47
 { 60, 63, 2, 4},{ 60, 63, 2, 4},{ 62, 65, 1, 5},{ 62, 65, 1, 5}, // 48-51
 { 50, 66, 0, 6},{ 67, 55, 7, 0},{ 68, 57, 6, 1},{ 68, 57, 6, 1}, // 52-55
 { 70, 73, 5, 2},{ 70, 73, 5, 2},{ 72, 75, 4, 3},{ 72, 75, 4, 3}, // 56-59
 { 74, 77, 3, 4},{ 74, 77, 3, 4},{ 76, 79, 2, 5},{ 76, 79, 2, 5}, // 60-63
 { 62, 81, 1, 6},{ 62, 81, 1, 6},{ 64, 82, 0, 7},{ 83, 69, 8, 0}, // 64-67
 { 84, 71, 7, 1},{ 84, 71, 7, 1},{ 86, 73, 6, 2},{ 86, 73, 6, 2}, // 68-71
 { 44, 59, 5, 3},{ 44, 59, 5, 3},{ 58, 61, 4, 4},{ 58, 61, 4, 4}, // 72-75
 { 60, 49, 3, 5},{ 60, 49, 3, 5},{ 76, 89, 2, 6},{ 76, 89, 2, 6}, // 76-79
 { 78, 91, 1, 7},{ 78, 91, 1, 7},{ 80, 92, 0, 8},{ 93, 69, 9, 0}, // 80-83
 { 94, 87, 8, 1},{ 94, 87, 8, 1},{ 96, 45, 7, 2},{ 96, 45, 7, 2}, // 84-87
 { 48, 99, 2, 7},{ 48, 99, 2, 7},{ 88,101, 1, 8},{ 88,101, 1, 8}, // 88-91
 { 80,102, 0, 9},{103, 69,10, 0},{104, 87, 9, 1},{104, 87, 9, 1}, // 92-95
 {106, 57, 8, 2},{106, 57, 8, 2},{ 62,109, 2, 8},{ 62,109, 2, 8}, // 96-99
 { 88,111, 1, 9},{ 88,111, 1, 9},{ 80,112, 0,10},{113, 85,11, 0}, // 100-103
 {114, 87,10, 1},{114, 87,10, 1},{116, 57, 9, 2},{116, 57, 9, 2}, // 104-107
 { 62,119, 2, 9},{ 62,119, 2, 9},{ 88,121, 1,10},{ 88,121, 1,10}, // 108-111
 { 90,122, 0,11},{123, 85,12, 0},{124, 97,11, 1},{124, 97,11, 1}, // 112-115
 {126, 57,10, 2},{126, 57,10, 2},{ 62,129, 2,10},{ 62,129, 2,10}, // 116-119
 { 98,131, 1,11},{ 98,131, 1,11},{ 90,132, 0,12},{133, 85,13, 0}, // 120-123
 {134, 97,12, 1},{134, 97,12, 1},{136, 57,11, 2},{136, 57,11, 2}, // 124-127
 { 62,139, 2,11},{ 62,139, 2,11},{ 98,141, 1,12},{ 98,141, 1,12}, // 128-131
 { 90,142, 0,13},{143, 95,14, 0},{144, 97,13, 1},{144, 97,13, 1}, // 132-135
 { 68, 57,12, 2},{ 68, 57,12, 2},{ 62, 81, 2,12},{ 62, 81, 2,12}, // 136-139
 { 98,147, 1,13},{ 98,147, 1,13},{100,148, 0,14},{149, 95,15, 0}, // 140-143
 {150,107,14, 1},{150,107,14, 1},{108,151, 1,14},{108,151, 1,14}, // 144-147
 {100,152, 0,15},{153, 95,16, 0},{154,107,15, 1},{108,155, 1,15}, // 148-151
 {100,156, 0,16},{157, 95,17, 0},{158,107,16, 1},{108,159, 1,16}, // 152-155
 {100,160, 0,17},{161,105,18, 0},{162,107,17, 1},{108,163, 1,17}, // 156-159
 {110,164, 0,18},{165,105,19, 0},{166,117,18, 1},{118,167, 1,18}, // 160-163
 {110,168, 0,19},{169,105,20, 0},{170,117,19, 1},{118,171, 1,19}, // 164-167
 {110,172, 0,20},{173,105,21, 0},{174,117,20, 1},{118,175, 1,20}, // 168-171
 {110,176, 0,21},{177,105,22, 0},{178,117,21, 1},{118,179, 1,21}, // 172-175
 {110,180, 0,22},{181,115,23, 0},{182,117,22, 1},{118,183, 1,22}, // 176-179
 {120,184, 0,23},{185,115,24, 0},{186,127,23, 1},{128,187, 1,23}, // 180-183
 {120,188, 0,24},{189,115,25, 0},{190,127,24, 1},{128,191, 1,24}, // 184-187
 {120,192, 0,25},{193,115,26, 0},{194,127,25, 1},{128,195, 1,25}, // 188-191
 {120,196, 0,26},{197,115,27, 0},{198,127,26, 1},{128,199, 1,26}, // 192-195
 {120,200, 0,27},{201,115,28, 0},{202,127,27, 1},{128,203, 1,27}, // 196-199
 {120,204, 0,28},{205,115,29, 0},{206,127,28, 1},{128,207, 1,28}, // 200-203
 {120,208, 0,29},{209,125,30, 0},{210,127,29, 1},{128,211, 1,29}, // 204-207
 {130,212, 0,30},{213,125,31, 0},{214,137,30, 1},{138,215, 1,30}, // 208-211
 {130,216, 0,31},{217,125,32, 0},{218,137,31, 1},{138,219, 1,31}, // 212-215
 {130,220, 0,32},{221,125,33, 0},{222,137,32, 1},{138,223, 1,32}, // 216-219
 {130,224, 0,33},{225,125,34, 0},{226,137,33, 1},{138,227, 1,33}, // 220-223
 {130,228, 0,34},{229,125,35, 0},{230,137,34, 1},{138,231, 1,34}, // 224-227
 {130,232, 0,35},{233,125,36, 0},{234,137,35, 1},{138,235, 1,35}, // 228-231
 {130,236, 0,36},{237,125,37, 0},{238,137,36, 1},{138,239, 1,36}, // 232-235
 {130,240, 0,37},{241,125,38, 0},{242,137,37, 1},{138,243, 1,37}, // 236-239
 {130,244, 0,38},{245,135,39, 0},{246,137,38, 1},{138,247, 1,38}, // 240-243
 {140,248, 0,39},{249,135,40, 0},{250, 69,39, 1},{ 80,251, 1,39}, // 244-247
 {140,252, 0,40},{249,135,41, 0},{250, 69,40, 1},{ 80,251, 1,40}, // 248-251
 {140,252, 0,41}};  // 252, 253-255 are reserved

#define nex(state,sel) State_table[state][sel]

//////////////////////////// StateMap //////////////////////////

// A StateMap maps a context to a probability.  Methods:
//
// Statemap sm(n) creates a StateMap with n contexts using 4*n bytes memory.
// sm.p(cx, limit) converts state cx (0..n-1) to a probability (0..4095)
//     that the next updated bit y=1.
//     limit (1..1023, default 255) is the maximum count for computing a
//     prediction.  Larger values are better for stationary sources.
// sm.update(y) updates the model with actual bit y (0..1).

class StateMap {
protected:
 const int N;  // Number of contexts
 int cxt;      // Context of last prediction
 U32 *t;       // cxt -> prediction in high 22 bits, count in low 10 bits
 static int dt[1024];  // i -> 16K/(i+3)
public:
 StateMap(int n=256);

 // update bit y (0..1)
 void update(int y, int limit=255) {
   assert(cxt>=0 && cxt<N);
   int n=t[cxt]&1023, p=t[cxt]>>10;  // count, prediction
   if (n<limit) ++t[cxt];
   else t[cxt]=t[cxt]&0xfffffc00|limit;
   t[cxt]+=(((y<<22)-p)>>3)*dt[n]&0xfffffc00;
 }

 // predict next bit in context cx
 int p(int cx) {
   assert(cx>=0 && cx<N);
   return t[cxt=cx]>>20;
 }
};

int StateMap::dt[1024]={0};

StateMap::StateMap(int n): N(n), cxt(0) {
 alloc(t, N);
 for (int i=0; i<N; ++i)
   t[i]=1<<31;
 if (dt[0]==0)
   for (int i=0; i<1024; ++i)
     dt[i]=16384/(i+i+3);
}

//////////////////////////// Mix, APM /////////////////////////

// Mix combines 2 predictions and a context to produce a new prediction.
// Methods:
// Mix m(n) -- creates allowing with n contexts.
// m.pp(p1, p2, cx) -- inputs 2 stretched predictions and a context cx
//   (0..n-1) and returns a stretched prediction.  Stretched predictions
//   are fixed point numbers with an 8 bit fraction, normally -2047..2047
//   representing -8..8, such that 1/(1+exp(-p) is the probability that
//   the next update will be 1.
// m.update(y) updates the model after a prediction with bit y (0..1).

class Mix {
protected:
 const int N;  // n
 int* wt;  // weights, scaled 24 bits
 int x1, x2;    // inputs, scaled 8 bits (-2047 to 2047)
 int cxt;  // last context (0..n-1)
 int pr;   // last output
public:
 Mix(int n=512);
 int pp(int p1, int p2, int cx) {
   assert(cx>=0 && cx<N);
   cxt=cx*2;
   return pr=(x1=p1)*(wt[cxt]>>16)+(x2=p2)*(wt[cxt+1]>>16)+128>>8;
 }
 void update(int y) {
   assert(y==0 || y==1);
   int err=((y<<12)-squash(pr));
   if ((wt[cxt]&3)<3)
     err*=4-(++wt[cxt]&3);
   err=err+8>>4;
   wt[cxt]+=x1*err&-4;
   wt[cxt+1]+=x2*err;
 }
};

Mix::Mix(int n): N(n), x1(0), x2(0), cxt(0), pr(0) {
 alloc(wt, n*2);
 for (int i=0; i<N*2; ++i)
   wt[i]=1<<23;
}

// An APM is a Mix optimized for a constant in place of p1, used to
// refine a stretched prediction given a context cx.
// Normally p1 is in the range (0..4095) and p2 is doubled.

class APM: public Mix {
public:
 APM(int n);
};

APM::APM(int n): Mix(n) {
 for (int i=0; i<n; ++i)
   wt[2*i]=0;
}

//////////////////////////// HashTable /////////////////////////

// A HashTable maps a 32-bit index to an array of B bytes.
// The first byte is a checksum using the upper 8 bits of the
// index.  The second byte is a priority (0 = empty) for hash
// replacement.  The index need not be a hash.

// HashTable<B> h(n) - create using n bytes  n and B must be
//     powers of 2 with n >= B*4, and B >= 2.
// h[i] returns array [1..B-1] of bytes indexed by i, creating and
//     replacing another element if needed.  Element 0 is the
//     checksum and should not be modified.

template <int B>
class HashTable {
 U8* t;  // table: 1 element = B bytes: checksum priority data data
 const U32 N;  // size in bytes
public:
 HashTable(int n);
 ~HashTable();
 U8* operator[](U32 i);
};

template <int B>
HashTable<B>::HashTable(int n): t(0), N(n) {
 assert(B>=2 && (B&B-1)==0);
 assert(N>=B*4 && (N&N-1)==0);
 alloc(t, N+B*4+64);
 t+=64-int(((long)t)&63);  // align on cache line boundary
}

template <int B>
inline U8* HashTable<B>::operator[](U32 i) {
 i*=123456791;
 i=i<<16|i>>16;
 i*=234567891;
 int chk=i>>24;
 i=i*B&N-B;
 if (t[i]==chk) return t+i;
 if (t[i^B]==chk) return t+(i^B);
 if (t[i^B*2]==chk) return t+(i^B*2);
 if (t[i+1]>t[i+1^B] || t[i+1]>t[i+1^B*2]) i^=B;
 if (t[i+1]>t[i+1^B^B*2]) i^=B^B*2;
 memset(t+i, 0, B);
 t[i]=chk;
 return t+i;
}

template <int B>
HashTable<B>::~HashTable() {
 int c=0, c0=0;
 for (U32 i=0; i<N; ++i) {
   if (t[i]) {
     ++c;
     if (i%B==0) ++c0;
   }
 }
 printf("HashTable<%d> %1.4f%% full, %1.4f%% utilized of %d KiB\n",
   B, 100.0*c0*B/N, 100.0*c/N, N>>10);
}

////////////////////////// LZP /////////////////////////

U32 MEM=1<<29;  // Global memory limit, 1 << 22+(memory option)

// LZP predicts the next byte and maintains context.  Methods:
// c() returns the predicted byte for the next update, or -1 if none.
// p() returns the 12 bit probability (0..4095) that c() is next.
// update(ch) updates the model with actual byte ch (0..255).
// c(i) returns the i'th prior byte of context, i > 0.
// c4() returns the order 4 context, shifted into the LSB.
// c8() returns a hash of the order 8 context, shifted 4 bits into LSB.
// word0, word1 are hashes of the current and previous word (a-z).

class LZP {
private:
 const int N, H; // buf, t sizes
 enum {MINLEN=12};  // minimum match length
 U8* buf;     // Rotating buffer of size N
 U32* t;      // hash table of pointers in high 24 bits, state in low 8 bits
 int match;   // start of match
 int len;     // length of match
 int pos;     // position of next ch to write to buf
 U32 h;       // context hash
 U32 h1;      // hash of last 8 byte updates, shifting 4 bits to MSB
 U32 h2;      // last 4 updates, shifting 8 bits to MSB
 StateMap sm1; // len+offset -> p
 APM a1, a2, a3;   // p, context -> p
 int literals, matches;  // statistics
public:
 U32 word0, word1;  // hashes of last 2 words (case insensitive a-z)
 LZP();
 ~LZP();
 int c();     // predicted char
 int c(int i);// context
 int c4() {return h2;}  // order 4 context, c(1) in LSB
 int c8() {return h1;}  // hashed order 8 context
 int p();     // probability that next char is c() * 4096
 void update(int ch);  // update model with actual char ch
};

// Initialize
LZP::LZP(): N(MEM/8), H(MEM/32),
   match(-1), len(0), pos(0), h(0), h1(0), h2(0),
   sm1(0x200), a1(0x10000), a2(0x40000), a3(0x100000),
   literals(0), matches(0), word0(0), word1(0) {
 assert(MEM>0);
 assert(H>0);
 alloc(buf, N);
 alloc(t, H);
}

// Print statistics
LZP::~LZP() {
 int c=0;
 for (int i=0; i<H; ++i)
   c+=(t[i]!=0);
 printf("LZP hash table %1.4f%% full of %d KiB\n"
   "LZP buffer %1.4f%% full of %d KiB\n",
   100.0*c/H, H>>8, pos<N?100.0*pos/N:100.0, N>>10);
 printf("LZP %d literals, %d matches (%1.4f%% matched)\n",
   literals, matches,
   literals+matches>0?100.0*matches/(literals+matches):0.0);
}

// Predicted next byte, or -1 for no prediction
inline int LZP::c() {
 return len>=MINLEN ? buf[match&N-1] : -1;
}

// Return i'th byte of context (i > 0)
inline int LZP::c(int i) {
 assert(i>0);
 return buf[pos-i&N-1];
}

// Return prediction that c() will be the next byte (0..4095)
int LZP::p() {
 if (len<MINLEN) return 0;
 int cxt=len;
 if (len>28) cxt=28+(len>=32)+(len>=64)+(len>=128);
 int pc=c();
 int pr=sm1.p(cxt);
 pr=stretch(pr);
 pr=a1.pp(2048, pr*2, h2*256+pc&0xffff)*3+pr>>2;
 pr=a2.pp(2048, pr*2, h1*(11<<6)+pc&0x3ffff)*3+pr>>2;
 pr=a3.pp(2048, pr*2, h1*(7<<4)+pc&0xfffff)*3+pr>>2;
 pr=squash(pr);
 return pr;
}

// Update model with predicted byte ch (0..255)
void LZP::update(int ch) {
 int y=c()==ch;     // 1 if prediction of ch was right, else 0
 h1=h1*(3<<4)+ch+1; // update context hashes
 h2=h2<<8|ch;
 h=h*(5<<2)+ch+1&H-1;
 if (len>=MINLEN) {
   sm1.update(y);
   a1.update(y);
   a2.update(y);
   a3.update(y);
 }
 if (isalpha(ch))
   word0=word0*(29<<2)+tolower(ch);
 else if (word0)
   word1=word0, word0=0;
 buf[pos&N-1]=ch;   // update buf
 ++pos;
 if (y) {  // extend match
   ++len;
   ++match;
   ++matches;
 }
 else {  // find new match, try order 6 context first
   ++literals;
   y=0;
   len=1;
   match=t[h];
   if (!((match^pos)&N-1)) --match;
   while (len<=128 && buf[match-len&N-1]==buf[pos-len&N-1]) ++len;
   --len;
 }
 t[h]=pos;
}

LZP* lzp=0;

//////////////////////////// Predictor /////////////////////////

// A Predictor estimates the probability that the next bit of
// uncompressed data is 1.  Methods:
// Predictor() creates.
// p() returns P(1) as a 12 bit number (0-4095).
// update(y) trains the predictor with the actual bit (0 or 1).

class Predictor {
 enum {N=11}; // number of contexts
 int c0;      // last 0-7 bits with leading 1, 0 before LZP flag
 int nibble;  // last 0-3 bits with leading 1 (1..15)
 int bcount;  // number of bits in c0 (0..7)
 HashTable<16> t;  // context -> state
 StateMap sm[N];   // state -> prediction
 U8* cp[N];   // i -> state array of bit histories for i'th context
 U8* sp[N];   // i -> pointer to bit history for i'th context
 Mix m[N-1];  // combines 2 predictions given a context
 APM a1, a2, a3;  // adjusts a prediction given a context
 U8* t2;      // order 1 contexts -> state

public:
 Predictor();
 int p();
 void update(int y);
};

// Initialize
Predictor::Predictor():
   c0(0), nibble(1), bcount(0), t(MEM/2),
   a1(0x10000), a2(0x10000), a3(0x10000) {
 alloc(t2, 0x40000);
 for (int i=0; i<N; ++i)
   sp[i]=cp[i]=t2;
}

// Update model
void Predictor::update(int y) {
 assert(y==0 || y==1);
 assert(bcount>=0 && bcount<8);
 assert(c0>=0 && c0<256);
 assert(nibble>=1 && nibble<=15);
 if (c0==0)
   c0=1-y;
 else {
   *sp[0]=nex(*sp[0], y);
   sm[0].update(y);
   for (int i=1; i<N; ++i) {
     *sp[i]=nex(*sp[i], y);
     sm[i].update(y);
     m[i-1].update(y);
   }
   c0+=c0+y;
   if (++bcount==8) bcount=c0=0;
   if ((nibble+=nibble+y)>=16) nibble=1;
   a1.update(y);
   a2.update(y);
   a3.update(y);
 }
}

// Predict next bit
int Predictor::p() {
 assert(lzp);
 if (c0==0)
   return lzp->p();
 else {

   // Set context pointers
   int pc=lzp->c();  // mispredicted byte
   int r=pc+256>>8-bcount==c0;  // c0 consistent with mispredicted byte?
   U32 c4=lzp->c4();  // last 4 whole context bytes, shifted into LSB
   U32 c8=(lzp->c8()<<4)-1;  // hash of last 7 bytes with 4 trailing 1 bits
   if ((bcount&3)==0) {  // nibble boundary?  Update context pointers
     pc&=-r;
     U32 c4p=c4<<8;
     if (bcount==0) {  // byte boundary?  Update order-1 context pointers
       cp[0]=t2+(c4>>16&0xff00);
       cp[1]=t2+(c4>>8 &0xff00)+0x10000;
       cp[2]=t2+(c4    &0xff00)+0x20000;
       cp[3]=t2+(c4<<8 &0xff00)+0x30000;
     }
     cp[4]=t[(c4p&0xffff00)-c0];
     cp[5]=t[(c4p&0xffffff00)*3+c0];
     cp[6]=t[c4*7+c0];
     cp[7]=t[(c8*5&0xfffffc)+c0];
     cp[8]=t[(c8*11&0xffffff0)+c0+pc*13];
     cp[9]=t[lzp->word0*5+c0+pc*17];
     cp[10]=t[lzp->word1*7+lzp->word0*11+c0+pc*37];
   }

   // Mix predictions
   r<<=8;
   sp[0]=&cp[0][c0];
   int pr=stretch(sm[0].p(*sp[0]));
   for (int i=1; i<N; ++i) {
     sp[i]=&cp[i][i<4?c0:nibble];
     int st=*sp[i];
     pr=m[i-1].pp(pr, stretch(sm[i].p(st)), st+r)*3+pr>>2;
   }
   pr=a1.pp(512, pr*2, c0+pc*256&0xffff)*3+pr>>2;  // Adjust prediction
   pr=a2.pp(512, pr*2, c4<<8&0xff00|c0)*3+pr>>2;
   pr=a3.pp(512, pr*2, c4*3+c0&0xffff)*3+pr>>2;
   return squash(pr);
 }
}

Predictor* predictor=0;

/////////////////////////// get4, put4 //////////////////////////

// Read/write a 4 byte big-endian number
int get4(FILE* in) {
 int r=getc(in);
 r=r*256+getc(in);
 r=r*256+getc(in);
 r=r*256+getc(in);
 return r;
}

void put4(U32 c, FILE* out) {
 fprintf(out, "%c%c%c%c", c>>24, c>>16, c>>8, c);
}

//////////////////////////// Encoder ////////////////////////////

// An Encoder arithmetic codes in blocks of size BUFSIZE.  Methods:
// Encoder(COMPRESS, f) creates encoder for compression to archive f, which
//     must be open past any header for writing in binary mode.
// Encoder(DECOMPRESS, f) creates encoder for decompression from archive f,
//     which must be open past any header for reading in binary mode.
// code(i) in COMPRESS mode compresses bit i (0 or 1) to file f.
// code() in DECOMPRESS mode returns the next decompressed bit from file f.
// count() should be called after each byte is compressed.
// flush() should be called after compression is done.  It is also called
//   automatically when a block is written.

typedef enum {COMPRESS, DECOMPRESS} Mode;
class Encoder {
private:
 const Mode mode;       // Compress or decompress?
 FILE* archive;         // Compressed data file
 U32 x1, x2;            // Range, initially [0, 1), scaled by 2^32
 U32 x;                 // Decompress mode: last 4 input bytes of archive
 enum {BUFSIZE=0x20000};
 static unsigned char* buf; // Compression output buffer, size BUFSIZE
 int usize, csize;      // Buffered uncompressed and compressed sizes
 double usum, csum;     // Total of usize, csize

public:
 Encoder(Mode m, FILE* f);
 void flush();  // call this when compression is finished

 // Compress bit y or return decompressed bit
 int code(int y=0) {
   assert(predictor);
   int p=predictor->p();
   assert(p>=0 && p<4096);
   p+=p<2048;
   U32 xmid=x1 + (x2-x1>>12)*p + ((x2-x1&0xfff)*p>>12);
   assert(xmid>=x1 && xmid<x2);
   if (mode==DECOMPRESS) y=x<=xmid;
   y ? (x2=xmid) : (x1=xmid+1);
   predictor->update(y);
   while (((x1^x2)&0xff000000)==0) {  // pass equal leading bytes of range
     if (mode==COMPRESS) buf[csize++]=x2>>24;
     x1<<=8;
     x2=(x2<<8)+255;
     if (mode==DECOMPRESS) x=(x<<8)+getc(archive);
   }
   return y;
 }

 // Count one byte
 void count() {
   assert(mode==COMPRESS);
   ++usize;
   if (csize>BUFSIZE-256)
     flush();
 }
};
unsigned char* Encoder::buf=0;

// Create in mode m (COMPRESS or DECOMPRESS) with f opened as the archive.
Encoder::Encoder(Mode m, FILE* f):
   mode(m), archive(f), x1(0), x2(0xffffffff), x(0),
   usize(0), csize(0), usum(0), csum(0) {
 if (mode==DECOMPRESS) {  // x = first 4 bytes of archive
   for (int i=0; i<4; ++i)
     x=(x<<8)+(getc(archive)&255);
   csize=4;
 }
 else if (!buf)
   alloc(buf, BUFSIZE);
}

// Write a compressed block and reinitialize the encoder.  The format is:
//   uncompressed size (usize, 4 byte, MSB first)
//   compressed size (csize, 4 bytes, MSB first)
//   compressed data (csize bytes)
void Encoder::flush() {
 if (mode==COMPRESS) {
   buf[csize++]=x1>>24;
   buf[csize++]=255;
   buf[csize++]=255;
   buf[csize++]=255;
   putc(0, archive);
   putc('c', archive);
   put4(usize, archive);
   put4(csize, archive);
   fwrite(buf, 1, csize, archive);
   usum+=usize;
   csum+=csize+10;
   printf("%15.0f -> %15.0f"
     "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b",
     usum, csum);
   x1=x=usize=csize=0;
   x2=0xffffffff;
 }
}

/////////////////////////// paq9a ////////////////////////////////

// Compress or decompress from in to out, depending on whether mode
// is COMPRESS or DECOMPRESS.  A byte c is encoded as a 1 bit if it
// is predicted by LZP, otherwise a 0 followed by 8 bits from MSB to LSB.
void paq9a(FILE* in, FILE* out, Mode mode) {
 if (!lzp && !predictor) {
   lzp=new LZP;
   predictor=new Predictor;
   printf("%8d KiB\b\b\b\b\b\b\b\b\b\b\b\b", allocated>>10);
 }
 if (mode==COMPRESS) {
   Encoder e(COMPRESS, out);
   int c;
   while ((c=getc(in))!=EOF) {
     int cp=lzp->c();
     if (c==cp)
       e.code(1);
     else
       for (int i=8; i>=0; --i)
         e.code(c>>i&1);
     e.count();
     lzp->update(c);
   }
   e.flush();
 }
 else {  // DECOMPRESS
   int usize=get4(in);
   get4(in);  // csize
   Encoder e(DECOMPRESS, in);
   while (usize--) {
     int c=lzp->c();
     if (e.code()==0) {
       c=1;
       while (c<256) c+=c+e.code();
       c&=255;
     }
     if (out) putc(c, out);
     lzp->update(c);
   }
 }
}


///////////////////////////// store ///////////////////////////

// Store a file in blocks as: {'\0' mode usize csize contents}...
void store(FILE* in, FILE* out) {
 assert(in);
 assert(out);

 // Store in blocks
 const int BLOCKSIZE=0x100000;
 static char* buf=0;
 if (!buf) alloc(buf, BLOCKSIZE);
 bool first=true;
 while (true) {
   int n=fread(buf, 1, BLOCKSIZE, in);
   if (!first && n<=0) break;
   fprintf(out, "%c%c", 0, 's');
   put4(n, out);  // usize
   put4(n, out);  // csize
   fwrite(buf, 1, n, out);
   first=false;
 }

 // Close file
 fclose(in);
}

// Write usize == csize bytes of an uncompressed block from in to out
void unstore(FILE* in, FILE* out) {
 assert(in);
 int usize=get4(in);
 int csize=get4(in);
 if (usize!=csize)
   printf("Bad archive format: usize=%d csize=%d\n", usize, csize);
 static char* buf=0;
 const int BUFSIZE=0x1000;
 if (!buf) alloc(buf, BUFSIZE);
 while (csize>0) {
   usize=csize;
   if (usize>BUFSIZE) usize=BUFSIZE;
   if (int(fread(buf, 1, usize, in))!=usize)
     printf("Unexpected end of archive\n"), exit(1);
   if (out) fwrite(buf, 1, usize, out);
   csize-=usize;
 }
}

//////////////////////// Archiving functions ////////////////////////

const int MAXNAMELEN=1023;  // max filename length

// Return true if the first 4 bytes of in are a valid archive
bool check_archive(FILE* in) {
 return getc(in)=='p' && getc(in)=='Q' && getc(in)=='9' && getc(in)==1;
}

// Open archive and check for valid archive header, exit if bad.
// Set MEM to memory option '1' through '9'
FILE* open_archive(const char* filename) {
 FILE* in=fopen(filename, "rb");
 if (!in)
   printf("Cannot find archive %s\n", filename), exit(1);
 if (!check_archive(in) || (MEM=getc(in))<'1' || MEM>'9') {
   fclose(in);
   printf("%s: Not a paq9a archive\n", filename);
   exit(1);
 }
 return in;
}

// Compress filename to out.  option is 'c' to compress or 's' to store.
void compress(const char* filename, FILE* out, int option) {

 // Open input file
 FILE* in=fopen(filename, "rb");
 if (!in) {
   printf("File not found: %s\n", filename);
   return;
 }
 fprintf(out, "%s", filename);
 printf("%-40s ", filename);

 // Compress depending on option
 if (option=='s')
   store(in, out);
 else if (option=='c')
   paq9a(in, out, COMPRESS);
 printf("\n");
}

// List archive contents
void list(const char* archive) {
 double usum=0, csum=0;  // uncompressed and compressed size per file
 double utotal=0, ctotal=4;  // total size in archive
 static char filename[MAXNAMELEN+1];
 int mode=0;

 FILE* in=open_archive(archive);
 printf("\npaq9a -%c\n", MEM);
 while (true) {

   // Get filename, mode
   int c=getc(in);
   if (c==EOF) break;
   if (c) {   // start of new file?  Print previous file
     if (mode)
       printf("%10.0f -> %10.0f %c %s\n", usum, csum, mode, filename);
     int len=0;
     filename[len++]=c;
     while ((c=getc(in))!=EOF && c)
       if (len<MAXNAMELEN) filename[len++]=c;
     filename[len]=0;
     utotal+=usum;
     ctotal+=csum;
     usum=0;
     csum=len;
   }

   // Get uncompressed size
   mode=getc(in);
   int usize=get4(in);
   usum+=usize;

   // Get compressed size
   int csize=get4(in);
   csum+=csize+10;

   if (usize<0 || csize<0 || mode!='c' && mode!='s')
     printf("Archive corrupted usize=%d csize=%d mode=%d at %ld\n",
       usize, csize, mode, ftell(in)), exit(1);

   // Skip csize bytes
   const int BUFSIZE=0x1000;
   char buf[BUFSIZE];
   while (csize>BUFSIZE)
     csize-=fread(buf, 1, BUFSIZE, in);
   fread(buf, 1, csize, in);
 }
 printf("%10.0f -> %10.0f %c %s\n", usum, csum, mode, filename);
 utotal+=usum;
 ctotal+=csum;
 printf("%10.0f -> %10.0f total\n", utotal, ctotal);
 fclose(in);
}

// Extract files given command line arguments
// Input format is: [filename {'\0' mode usize csize contents}...]...
void extract(int argc, char** argv) {
 assert(argc>2);
 assert(argv[1][0]=='x');
 static char filename[MAXNAMELEN+1];  // filename from archive

 // Open archive
 FILE* in=open_archive(argv[2]);
 MEM=1<<22+MEM-'0';

 // Extract files
 argc-=3;
 argv+=3;
 FILE* out=0;
 while (true) {  // for each block

   // Get filename
   int c;
   for (int i=0;; ++i) {
     c=getc(in);
     if (c==EOF) break;
     if (i<MAXNAMELEN) filename[i]=c;
     if (!c) break;
   }
   if (c==EOF) break;

   // Open output file
   if (filename[0]) {  // new file?
     const char* fn=filename;
     if (argc>0) fn=argv[0], --argc, ++argv;
     if (out) fclose(out);
     out=fopen(fn, "rb");
     if (out) {
       printf("\nCannot overwrite file, skipping: %s ", fn);
       fclose(out);
       out=0;
     }
     else {
       out=fopen(fn, "wb");
       if (!out) printf("\nCannot create file: %s ", fn);
     }
     if (out) {
       if (fn==filename) printf("\n%s ", filename);
       else printf("\n%s -> %s ", filename, fn);
     }
   }

   // Extract block
   int mode=getc(in);
   if (mode=='s')
     unstore(in, out);
   else if (mode=='c')
     paq9a(in, out, DECOMPRESS);
   else
     printf("\nUnsupported compression mode %c %d at %ld\n",
       mode, mode, ftell(in)), exit(1);
 }
 printf("\n");
 if (out) fclose(out);
}

// Command line is: paq9a {a|x|l} archive [[-option] files...]...
int main(int argc, char** argv) {
 clock_t start=clock();

 // Check command line arguments
 if (argc<3 || argv[1][1] || (argv[1][0]!='a' && argv[1][0]!='x'
     && argv[1][0]!='l') || (argv[1][0]=='a' && argc<4) || argv[2][0]=='-')
 {
   printf("paq9a archiver (C) 2007, Matt Mahoney\n"
     "Free software under GPL, http://www.gnu.org/copyleft/gpl.html\n"
     "\n"
     "To create archive: paq9a a archive [-1..-9] [[-s|-c] files...]...\n"
     "  -1..-9 = use 18 to 1585 MiB memory (default -7 = 408 MiB)\n"
     "  -s = store, -c = compress (default)\n"
     "To extract files:  paq9a x archive [files...]\n"
     "To list contents:  paq9a l archive\n");
   exit(1);
 }

 // Create archive
 if (argv[1][0]=='a') {
   int option = 'c';  // -c or -s
   FILE* out=fopen(argv[2], "rb");
   if (out) printf("Cannot overwrite archive %s\n", argv[2]), exit(1);
   out=fopen(argv[2], "wb");
   if (!out) printf("Cannot create archive %s\n", argv[2]), exit(1);
   fprintf(out, "pQ9%c", 1);
   int i=3;
   if (argc>3 && argv[3][0]=='-' && argv[3][1]>='1' && argv[3][1]<='9'
       && argv[3][2]==0) {
     putc(argv[3][1], out);
     MEM=1<<22+argv[3][1]-'0';
     ++i;
   }
   else
     putc('7', out);
   for (; i<argc; ++i) {
     if (argv[i][0]=='-' && (argv[i][1]=='c' || argv[i][1]=='s')
         && argv[i][2]==0)
       option=argv[i][1];
     else
       compress(argv[i], out, option);
   }
   printf("-> %ld in %1.2f sec\n", ftell(out),
     double(clock()-start)/CLOCKS_PER_SEC);
 }

 // List archive contents
 else if (argv[1][0]=='l')
   list(argv[2]);

 // Extract from archive
 else if (argv[1][0]=='x') {
   extract(argc, argv);
   printf("%1.2f sec\n", double(clock()-start)/CLOCKS_PER_SEC);
 }

 // Report statistics
 delete predictor;
 delete lzp;
 printf("Used %d KiB memory\n", allocated>>10);
 return 0;
}


Se que puede ser un poco atrevido preguntar esto, pero como puedo hacer algún código para almacenar archivo, con carpeta, o solo archivo, supongo que debería juntar los archivos en uno y al final agregarle el árbol de archivos por ejemplo tengo un archivo de 5 bites que se llama 123.txt + otro de 10 que se llama 231.txt que serian 15 - los 5 del anterior, entonces seria algo como un hacha variable, el problema es que no tengo ni idea de como manipular los archivos en binario, para las carpetas debería crear un void, o algo para cada plataforma. Seria excelente ver aunquesea que cree archivos, pero no se ni por donde empezar, y los archivos muy grandes fallaría el compilador, creo ¿ Tendría que usar XML o que?. Necesitaría algo para listar los archivos, voy a hacer todo los que pueda. Tengo vergüenza de no tener mucho código por ahora.

Necesito algún código para pasa un texto a binario (0 y 1). porque el editor que tengo no lo hace como quiero osea, quiero probar porque encontré algo que le puede servir a la humanidad (?), realmente si tendría algún código lo pondría.

Mi planteo es porque en vez de hacer procesadores con 0: 0.5v y 1: 5v no se hacen procesadores así: 0:0,5v 1:1,0v 2:1,5v 3:2,0v 4:2,5v 5:3,0v 6:3,5v 7:4,5v 8:5,0v 9:5,5v 10:6,0v 11:6,5v 12:7,0v 13:7,5v 14:8,0v 15:9,5v... y asi hasta 12 por ejemplo, debe haber alguna explicación lógica.

Bueno, la verdad es que estoy creando unas herramientas para hacer mis repacks en C en mi pais no es que viva mal ni nada pero en donde vivo tengo un mega literalmente (En España deben reirse), el roblema que veo es que usando muchos algoritmos diferentes y con varios compresores ni con PAQ consegui mejores resultados que con FreeARC,  por eso estoy imventando metodos porque los actuales son de los años 50 (muy efectivos), por ejemplo note que no hay efectividad binaria al comprimir (bit a bit) por ejemplo, escribo 01010101 01010101 01010101 01010101 En binario y luego comparo lo mismo en un txt normal y el archivo pesa mas si es en binario literal que el del texto normal (8 bits x numero), es para pensar, actualmente cree un sistema que lo transforma a unos bit (no se ahoguen con el humo que no es para tanto), lamentable no tengo habilidad para pasarlo a C

Vendria a ser algo asi ¿No?

Código (c) [Seleccionar] Expandir

int main(){}

Resulta que estaba en minecraft y me encontré un cubito (?, resulta que el error de mi programa es el siguiente, yo pongo el archivo que deseo y no sale, probe con if, con while y da el mismo resultado pero no interpreta la primera linea. Tengan en cuenta que es mi primer programa. Lo mas extraño es que antes de unas modificaciones funcionaba de 10. Parece que esta peor que los glitchs del GTA V.

Código (cpp) [Seleccionar] Expandir

#include <cstdio>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <ctime>
//#include <windows.h> Por si se quiere un sleep

using namespace std;

FILE *archivo;
  FILE *ccmd;
char *pos;
char lineas[150];

// DICCIONARIO DE PROCEDIMIENTOS, PARA SIMPLIFICAR:
/*
void fscls(){
fprintf(ccmd,"\tcout << string(50, '\\n');\n");
}
void fsfin(){
fprintf(ccmd,"\texit (0) ;\n");
}
void fspaus(){
fprintf(ccmd,"\tgetchar();\n");
}
void fsAboWhi(){
lineas[0] = '\0';
} */
void ArchCheq( FILE *fili,int n){
if (fili == NULL){
cout << "Error de archivo ("<< n << ")" << endl;
exit(1);
}
}

int main( int argc, char **argv) {
clock_t inicio,fin;
inicio=clock();
               // Fix para que el programa no falle si no tiene comandos
if ( argc < 3 ) {
cout<<"Ejemplo: programa \"Archivo a Abrir.cmd\" -c \"ArchivoSaliente.c\" "<<endl;
return 1;
}
if ( !strcmp( argv[2], "-c" ) ) {
archivo = fopen(argv[1],"r");
ccmd = fopen(argv[3],"wt");
}else{
cout << "Ejemplo: programa \"Archivo a Abrir.cmd\" -c \"ArchivoSaliente.c\" "<< endl;
}
//Verificacion
ArchCheq(archivo,1);
ArchCheq(ccmd,2);

while (!feof(archivo))
{
fgets( lineas, 150, archivo ); //LEE EL ARCHIVO LINEA POR LINEA.
if ((pos=strchr(lineas, '\n')) != NULL) *pos = '\0'; //AGREGA CARACTER NULO

// INTERPRETADOR:
// PAUSAS
if (!strcmp(lineas,"PAUSE>NUL")){
fprintf(ccmd,"\tgetchar();\n");
lineas[0] = '\0';
}
if (!strcmp(lineas,"PAUSA>NUL")){
fprintf(ccmd,"\tgetchar();\n");
lineas[0] = '\0';
}

if (!strcmp(lineas,"PAUSE")){
fprintf(ccmd,"\tcout << \"Presione una tecla para continuar.\" << endl;\n");
fprintf(ccmd,"\tgetchar();\n");
lineas[0] = '\0';
}

if (!strcmp(lineas,"PAUSA")){
fprintf(ccmd,"\tcout << \"Presione una tecla para continuar.\" << endl;\n");
fprintf(ccmd,"\tgetchar();\n");
lineas[0] = '\0';
}

// EXIT, FALTA PARA ESPECIFICAR.
if (!strcmp(lineas,"EXIT")){
fprintf(ccmd,"\texit (0) ;\n");
lineas[0] = '\0';
}
if (!strcmp(lineas,"SALIR")){
fprintf(ccmd,"\texit (0) ;\n");
lineas[0] = '\0';
}

// SECTOR PARA LIMPIAR PANTALLA
if (!strcmp(lineas,"CLS")){
fprintf(ccmd,"\tcout << string(50, '\\n');\n");
lineas[0] = '\0';
}
if (!strcmp(lineas,"CLEAR")){
fprintf(ccmd,"\tcout << string(50, '\\n');\n");
lineas[0] = '\0';
}
if (!strcmp(lineas,"LIMPIAR")){
fprintf(ccmd,"\tcout << string(50, '\\n');\n");
lineas[0] = '\0';
}

// Sistema complejo
//ECHO
if (strncmp (lineas,"ECHO",1) == 0) // Si se verifica la existencia procede a procesar la linea
{
char ECHO[] = "ECHO ";
int posicion = strlen( lineas ) - strlen( strstr( lineas, ECHO  ) );

/* // copiar la primera linea (no es necesario en este caso)
for( int a = 0; a < posicion; a++ )
lineas[ a ] = lineas[ a ];
*/
//copia la segunda linea
for( int a = posicion; a < strlen( lineas ); a++ )
lineas[ a ] = lineas[ a+5 ]; // 5 es el tamaño del ECHO
fprintf(ccmd,"\tcout << \"%s\" << endl;\n",lineas);
lineas[0] = '\0';

}
if (!strcmp(lineas,"\0"))
{
}else{
fprintf(ccmd,"\t%s\n",lineas); // SI NO COINCIDE CON NINGUNO LO IMPRIME EN C/C++ (MUY BETA).
}
// Sleep(100); requiere windows.h
  }
fclose(archivo);
fclose(ccmd);

cout << "\x5C\x5C Interpetracion finalizada \x5C\x5C" << endl;
fin=clock();
printf("Tiempo transcurrido: %f segundos\n", (fin-inicio)/(double)CLOCKS_PER_SEC);
}


Código (cpp) [Seleccionar] Expandir

/*
¿Porque se ultiliza goto? Porque si, reduzco codigo.
*/

#include <cstdio>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
using namespace std;

FILE *archivo;
  FILE *ccmd;

char *pos;

char caracteres[150];

int main( int argc, char **argv) {
    char ArchivoAbrir[21];
char ArchivoSaliente[21];

        if ( argc < 3 ) {
cout<<"Ejemplo: programa \"Archivo a Abrir.cmd\" -c \"ArchivoSaliente.c\" "<<endl;
return 1;
}
if ( !strcmp( argv[2], "-c" ) ) {

strncpy( ArchivoAbrir, argv[1], 20 );
ArchivoAbrir[21] = '\0';

strncpy( ArchivoSaliente, argv[3], 20 );
ArchivoSaliente[21] = '\0';
}

archivo = fopen(argv[1],"r");
ccmd = fopen(argv[3],"wt");

if (archivo == NULL)
exit(1);

while (!feof(archivo))
{
fgets( caracteres, 150, archivo );
if ((pos=strchr(caracteres, '\n')) != NULL)
*pos = '\0';

while (!strcmp(caracteres,"PAUSE>NUL"))
{
goto PAUSANULA;
}

while (!strcmp(caracteres,"PAUSE"))
{
fprintf(ccmd,"\tputs(\"Presione una tecla para continuar.\");\n");
PAUSANULA:
fprintf(ccmd,"\tgetchar();\n");
caracteres[0] = '\0';
}

while (!strcmp(caracteres,"EXIT"))
{
fprintf(ccmd,"\treturn 0 ;\n");
caracteres[0] = '\0';

}

while (!strcmp(caracteres,"CLS"))
{
goto LIMPIADO;
}
while (!strcmp(caracteres,"CLEAR"))
{
LIMPIADO:
fprintf(ccmd,"\tputs(\"\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\");\n");
caracteres[0] = '\0';
}

while (!strcmp(caracteres,"FIN"))
                {
goto FIN;
caracteres[0] = '\0';
                }

if (!strcmp(caracteres,"\0"))
                {
}else{
fprintf(ccmd,"\tsystem(\"%s\");\n",caracteres);
caracteres[0] = '\0';
}
  }
FIN:
        fclose(archivo);
fclose(ccmd);
cout<<"Compilado.."<<endl;
getchar();
}

¿Alguna razón para que no sea así?

Hola nuevamente foro, tengo un problema que me dificulta seguir con mi código, digo que es un bug porque hice mi código aparte, el cual funciona perfectamente, luego lo implemente a mi código y falla:

Código donde se presenta la falla:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>

// Limpiador de pantalla
void clrScr()
{
//Windows/Linux
if (system("CLS")) system("clear");
/* Modo realmente multiplataforma (malo).
   int n;
   for (n = 0; n < 10; n++)
   printf( "\n\n\n\n\n\n\n\n\n\n\n\n\n" );
*/
}

// Mensaje "propagandistico"
void Mensaje()
{
printf("\t+----------------------------+\n");
   printf("\t|BATCH TO C SOURCE CONVERTER |\n");
   printf("\t+----------------------------+\n");
}
// Limpiador de ENTER
void EnterLimp()
{
while ( getchar() != '\n' );    /* limpia el caracter ENTER de la entrada estandar */
}

int main()
{
int oculto;
int clave;

   FILE *fp;
char *cPtr;
   char filename[30];          //filename for source code
   //for command
   char cmd[150];
   //la clave
   char cmb[350];

// Nombre archivo final
Mensaje();
printf("\nEntre el nombre que le quiere dar al codigo saliente(.c): ");
scanf("%s",filename);
EnterLimp();

clrScr();

// Tipo de clave
Mensaje();
printf("AVISO: (No es posible modo oculto con clave externa) (2)\n ");
printf("1: Para modo clave consola.\n 2: para clave externa (-pass clave) \n 0: sin clave");
scanf("%d" ,&clave);
EnterLimp();
clrScr();

// Modo clave 1
if( clave== 1 ){
Mensaje();
   printf("\nLa clave de mas de 3 caracteres: ");
   scanf("%s",cmb);
EnterLimp();
}
// Modo clave 2
if( clave== 2 ){
Mensaje();
   printf("\nLa clave: ");
   scanf("%s",cmb);
EnterLimp();
}
clrScr();

//Modo "oculto"
if( clave== 2 ){
Mensaje();
printf("No es posible modo oculto con clave externa\n");
printf("Enter para continuar\n");
getchar(); //pausa multiplataforma
}else{
Mensaje();
printf("Para modo oculto escriba 1 (solo windows) o 0 para normal : ");
scanf("%d" ,&oculto);
EnterLimp();
}
clrScr();
/*
//Concatenado
Mensaje();
   printf("\nMetodo de concatenado : ");
   printf("\n1 para metodo modo inteligente (beta) : ");
   scanf("%d",&concatenado);
EnterLimp();

clrScr();
*/
//Codigos
fp = fopen(filename,"w");
   if (fp==NULL)
   {
    printf("Ocurrio un error al intentar abrir el archivo");
    getchar();
    exit(1);
   }
   else
   {
// includes normales
fprintf(fp,"#include <stdio.h>\n");
       fprintf(fp,"#include <stdlib.h>\n");
if( clave== 2 ){
fprintf(fp,"#include <string.h>\n");
}
if( oculto== 1 ){
// modo oculto
       fprintf(fp,"#include <windows.h>\n");
}

if( oculto== 1 ){
       fprintf(fp,"int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,\n");
       fprintf(fp,"PSTR szCmdLine, int iCmdShow)\n");
}
// int argc, char **argv
fprintf(fp,"int main( int argc, char **argv)\n");
       fprintf(fp,"{\n");

if( clave== 1 ){
// modo clave

       fprintf(fp,"\nchar clave[6];\n");
       fprintf(fp,"printf(\"Escriba su clave: \");\n");
       fprintf(fp,"scanf(\"%%s\",clave);\n");
       fprintf(fp,"if(strcmp(clave,\"%s\")==0)\n",cmb);
       fprintf(fp,"{\n");
}
if( clave== 2 ){
// modo consola
       fprintf(fp,"\tchar clave[21];\n");
       fprintf(fp,"\tchar clave2[21] = \"%s\";\n",cmb);
       fprintf(fp,"\tif ( argc < 3 ) {\n");
       fprintf(fp,"\tprintf(\"USO: programa -pass clave\");\n");
       fprintf(fp,"\treturn 1;\n");
       fprintf(fp,"}\n");
       fprintf(fp,"\tif ( !strcmp( argv[1], \"-pass\" ) ) {\n");
       fprintf(fp,"\tstrncpy( clave, argv[2], 20 );\n");
       fprintf(fp,"\tclave[21] = '\\0';\n");
       fprintf(fp,"}\n");
       fprintf(fp,"\telse\n");
       fprintf(fp,"return 1;\n");
       fprintf(fp,"\n");
       fprintf(fp,"\tif ( !strcmp(clave, clave2) )\n");
       fprintf(fp,"{\n");
}
clrScr();

Mensaje();

       printf("\nComience a escribir los comandos : \n");
       printf("Cuando finalice, ecriba 'FIN' para terminar\n");
       printf("\nComandos :\n\n");
     
       gets(cmd);
       while (1)
       {

fgets( cmd, 150, stdin );
if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';

while (!strcmp(cmd,"PAUSE\>NUL"))
{
fprintf(fp,"\tgetchar();\n");
fgets( cmd, 150, stdin );
if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';
                }

while (!strcmp(cmd,"PAUSE"))
{
fprintf(fp,"\tprintf(\"Presione una tecla para continuar.\");\n");
fprintf(fp,"\tgetchar();\n");
fgets( cmd, 150, stdin );
if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';
                }
if (!strcmp(cmd,"FIN"))
                {
                break;              //if end is typed, get out of loop
                }
             fprintf(fp,"\tsystem(\"%s\");\n",cmd);
}
if( clave== 0 ){
       fprintf(fp,"}");
}

if( clave== 1 ){
// modo clave
       fprintf(fp,"\t}\nelse\n{\n");
       fprintf(fp,"\tprintf(\"Clave no valida\");\n}\n");
       fprintf(fp,"\treturn 0;\n}");
}

if( clave== 2 ){
// modo clave
       fprintf(fp,"\t}\nelse\n{\n");
       fprintf(fp,"\tprintf(\"Clave no valida\");\n}\n");
       fprintf(fp,"\treturn 0;\n}");
}
fclose(fp);
   }
getchar();
}


Código que funciona perfectamente y es similar:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
int main()
{
char *cPtr;

   FILE *fp;
   char filename[30];
   char incs[200] = "#include <stdio.h>\n#include <stdlib.h>\nint main()\n{\n";
   char end[50] = "}\n";
   char cmd[150];
 
   printf("\nArchivo a crear: ");
   scanf("%s",filename);
   fp = fopen(filename,"w");
   if (fp==NULL)
   {
    printf("Some error occurred while opening file");
    getchar();
    exit(1);
   }
   else
   {
       fprintf(fp,"%s",incs);
       
       printf("\nIngrese sus codigos: \n");
     
       gets(cmd);
       while (1)
       {
fgets( cmd, 150, stdin );
if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';

while (!strcmp(cmd,"PAUSE\>NUL"))
{
fprintf(fp,"\tgetchar();\n");
fgets( cmd, 150, stdin );
if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';
                }

while (!strcmp(cmd,"PAUSE"))
{
fprintf(fp,"\tprintf(\"Presione una tecla para continuar.\");\n");
fprintf(fp,"\tgetchar();\n");
fgets( cmd, 150, stdin );
if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';
                }
if (!strcmp(cmd,"FIN"))
                {
                break;
                }
             fprintf(fp,"\tsystem(\"%s\");\n",cmd);
}
     
       fprintf(fp,"\n%s",end);

       fclose(fp);
   }
   getchar();
}

Lo que pasa es que en el ultimo me devuelve el código perfectamente y el primero de todos, ese es el que falla y no se porque, funciona pero se saltea las lineas, aveces anda otras no ¿Se le puede hacer algo?.

SOLUCIONADO Y CORREGIDO UN POCO.

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>

// Limpiador de pantalla
void clrScr()
{
//Windows/Linux
if (system("CLS")) system("clear");
/* Modo realmente multiplataforma (malo).
    int n;
    for (n = 0; n < 10; n++)
    printf( "\n\n\n\n\n\n\n\n\n\n\n\n\n" );
*/
}

// Mensaje "propagandistico"
void Mensaje()
{
printf("\t+----------------------------+\n");
    printf("\t|BATCH TO C SOURCE CONVERTER |\n");
    printf("\t+----------------------------+\n");
}
// Limpiador de ENTER
void EnterLimp()
{
while ( getchar() != '\n' );    /* limpia el caracter ENTER de la entrada estandar */
}

int main()
{
int oculto;
int clave;

    FILE *fp;
char *cPtr;
    char filename[30];          //filename for source code
    //for command
    char cmd[150];
    //la clave
    char cmb[350];

// Nombre archivo final
Mensaje();
printf("\nEntre el nombre que le quiere dar al codigo saliente(.c): ");
scanf("%s",filename);
EnterLimp();

clrScr();

// Tipo de clave
Mensaje();
printf("AVISO: (No es posible modo oculto con clave externa) (2)\n ");
printf("1: Para modo clave consola.\n 2: para clave externa (-pass clave) \n 0: sin clave:\n\t");
scanf("%d" ,&clave);
EnterLimp();
clrScr();

// Modo clave 1
if( clave== 1 ){
Mensaje();
    printf("\nLa clave de mas de 3 caracteres: ");
    scanf("%s",cmb);
EnterLimp();
clrScr();
}
// Modo clave 2
if( clave== 2 ){
Mensaje();
    printf("\nLa clave: ");
    scanf("%s",cmb);
EnterLimp();

clrScr();

//Modo "oculto"
Mensaje();
printf("No es posible modo oculto con clave externa\n");
printf("Enter para continuar\n");
getchar(); //pausa multiplataforma
}else{
Mensaje();
printf("Para modo oculto escriba 1 (solo windows) o 0 para normal : ");
scanf("%d" ,&oculto);
EnterLimp();
}
clrScr();
/*
//Concatenado
Mensaje();
    printf("\nMetodo de concatenado : ");
    printf("\n1 para metodo modo inteligente (beta) : ");
    scanf("%d",&concatenado);
EnterLimp();

clrScr();
*/
//Codigos
fp = fopen(filename,"w");
    if (fp==NULL)
    {
     printf("Ocurrio un error al intentar abrir el archivo");
     getchar();
     exit(1);
    }
    else
    {
// includes normales
fprintf(fp,"#include <stdio.h>\n");
        fprintf(fp,"#include <stdlib.h>\n");
if( clave== 2 ){
fprintf(fp,"#include <string.h>\n");
}
if( oculto== 1 ){
// modo oculto
        fprintf(fp,"#include <windows.h>\n");
}

if( oculto== 1 ){
        fprintf(fp,"int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,\n");
        fprintf(fp,"PSTR szCmdLine, int iCmdShow)\n");
}
// int argc, char **argv
fprintf(fp,"int main( int argc, char **argv)\n");
        fprintf(fp,"{\n");

if( clave== 1 ){
// modo clave

        fprintf(fp,"\nchar clave[6];\n");
        fprintf(fp,"printf(\"Escriba su clave: \");\n");
        fprintf(fp,"scanf(\"%%s\",clave);\n");
        fprintf(fp,"if(strcmp(clave,\"%s\")==0)\n",cmb);
        fprintf(fp,"{\n");
}
if( clave== 2 ){
// modo consola
        fprintf(fp,"\tchar clave[21];\n");
        fprintf(fp,"\tchar clave2[21] = \"%s\";\n",cmb);
        fprintf(fp,"\tif ( argc < 3 ) {\n");
        fprintf(fp,"\tprintf(\"USO: programa -pass clave\");\n");
        fprintf(fp,"\treturn 1;\n");
        fprintf(fp,"}\n");
        fprintf(fp,"\tif ( !strcmp( argv[1], \"-pass\" ) ) {\n");
        fprintf(fp,"\tstrncpy( clave, argv[2], 20 );\n");
        fprintf(fp,"\tclave[21] = '\\0';\n");
        fprintf(fp,"}\n");
        fprintf(fp,"\telse\n");
        fprintf(fp,"return 1;\n");
        fprintf(fp,"\n");
        fprintf(fp,"\tif ( !strcmp(clave, clave2) )\n");
        fprintf(fp,"{\n");
}
clrScr();

Mensaje();

        printf("\nComience a escribir los comandos : \n");
        printf("Cuando finalice, ecriba 'FIN' para terminar\n");
        printf("\nComandos :\n\n");

        while (1)
        {
fgets( cmd, 150, stdin );
if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';

while (!strcmp(cmd,"PAUSE\>NUL"))
{
fprintf(fp,"\tgetchar();\n");
fgets( cmd, 150, stdin );
if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';
                 }

while (!strcmp(cmd,"PAUSE"))
{
fprintf(fp,"\tprintf(\"Presione una tecla para continuar.\");\n");
fprintf(fp,"\tgetchar();\n");
fgets( cmd, 150, stdin );
if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';
                 }
if (!strcmp(cmd,"FIN"))
                 {
                 break;              //if end is typed, get out of loop
                 }
              fprintf(fp,"\tsystem(\"%s\");\n",cmd);
}
if( clave== 0 ){
        fprintf(fp,"}");
}

if( clave== 1 ){
// modo clave
        fprintf(fp,"\t}\nelse\n{\n");
        fprintf(fp,"\tprintf(\"Clave no valida\");\n}\n");
        fprintf(fp,"\treturn 0;\n}");
}

if( clave== 2 ){
// modo clave
        fprintf(fp,"\t}\nelse\n{\n");
        fprintf(fp,"\tprintf(\"Clave no valida\");\n}\n");
        fprintf(fp,"\treturn 0;\n}");
}
fclose(fp);
    }
getchar();
}

El error era muy básico, había utilizado un gets en donde no tenia que estar antes del bucle, lo elimine y el problema esta resuelto.

Bueno, les explico soy muy pero muy novato en C   y me puse a "mejorar", un poco un código de batch a C, que en realidad solo llama al system, y la verdad es que ahora quiero que traduzca muy básico por ejemplo tengo en batch:

Código [Seleccionar] Expandir

set pepe=hola
echo %pepe%

que en c seria algo asi

Código [Seleccionar] Expandir

#include <stdio.h>
#include <ctype.h>
#include <string.h>

int main()
{
char pepe[21] = hola;
printf(pepe);
return 0;
}

O

Código [Seleccionar] Expandir

echo HOLA MUNDO

que en c seria algo asi

Código [Seleccionar] Expandir

#include <stdio.h>

int main()
{
printf("HOLA MUNDO");
return 0;
}

intente con memcpy y no entiendo muy bien solo necesitaría separar por ejemplo set "variable" = "valor", si sale vamos por linux.

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <ctype.h>
#include <string.h>

#ifdef __cplusplus__
 #include <cstdlib>
#else
 #include <stdlib.h>
#endif

// Limpiador de pantalla
void clrScr()
{
if (system("CLS")) system("clear");
}

// Mensaje "propagandistico"
void Mensaje()
{
printf("\t+----------------------------+\n");
   printf("\t|BATCH TO C SOURCE CONVERTER |\n");
   printf("\t+----------------------------+\n");
}
// Limpiador de ENTER
void EnterLimp()
{
while ( getchar() != '\n' );    /* limpia el caracter ENTER de la entrada estandar */
}

int main()
{
int oculto;
int clave;
int concatenado;

   FILE *fp;
char *cPtr;
   char filename[30];          //filename for source code
   //end part of output file
   char end[50] = "\treturn 0;\n}";
   //for command
   char cmd[150];
   //la clave
   char cmb[350];

// Nombre archivo final
Mensaje();
printf("\nEntre el nombre que le quiere dar al codigo saliente(.c): ");
scanf("%s",filename);
EnterLimp();

clrScr();

// Tipo de clave
Mensaje();
printf("AVISO: (No es posible modo oculto con clave externa) (2) \n ");
printf("Para modo clave escriba 1 o 2 para clave externa (-pass clave) : ");
scanf("%d" ,&clave);
EnterLimp();
clrScr();

// Modo clave 1
if( clave== 1 ){
Mensaje();
   printf("\nLa clave de mas de 3 caracteres: ");
   scanf("%s",cmb);
EnterLimp();
}
// Modo clave 2
if( clave== 2 ){
Mensaje();
   printf("\nLa clave: ");
   scanf("%s",cmb);
EnterLimp();
}
clrScr();

//Modo "oculto"
if( clave== 2 ){
Mensaje();
printf("No es posible modo oculto con clave externa\n");
printf("Enter para continuar\n");
getchar(); //pausa multiplataforma <3
}else{
Mensaje();
printf("Para modo oculto escriba 1 (solo windows) o 0 para normal : ");
scanf("%d" ,&oculto);
EnterLimp();
}
clrScr();

//Concatenado
Mensaje();
   printf("\nMetodo de concatenado : ");
   printf("\n1 para metodo modo inteligente (beta) : ");
   scanf("%d",&concatenado);
EnterLimp();

clrScr();

//Codigos
fp = fopen(filename,"w");
   if (fp==NULL)
   {
    printf("Ocurrio un error al intentar abrir el archivo");
    getchar();
    exit(1);
   }
   else
   {
// includes normales
fprintf(fp,"#include <stdio.h>\n");
       fprintf(fp,"#include <stdlib.h>\n");
if( clave== 2 ){
fprintf(fp,"#include <string.h>\n");
}
if( oculto== 1 ){
// modo oculto
       fprintf(fp,"#include <windows.h>\n");
}

if( oculto== 1 ){
       fprintf(fp,"int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,\n");
       fprintf(fp,"PSTR szCmdLine, int iCmdShow)\n");
}
// int argc, char **argv
fprintf(fp,"int main( int argc, char **argv)\n");
       fprintf(fp,"{\n");


/* A solucionar...
if( clave== 2 ){
// int argc, char **argv
fprintf(fp,"int main( int argc, char **argv)\n");
       fprintf(fp,"{\n");
}else{
// normal
       fprintf(fp,"int main()\n");
       fprintf(fp,"{\n");
} */

if( clave== 1 ){
// modo clave

       fprintf(fp,"\nchar clave[6];\n");
       fprintf(fp,"printf(\"Escriba su clave: \");\n");
       fprintf(fp,"scanf(\"%%s\",clave);\n");
       fprintf(fp,"if(strcmp(clave,\"%s\")==0)\n",cmb);
       fprintf(fp,"{\n");
}
if( clave== 2 ){
// modo consola
       fprintf(fp,"\tchar clave[21];\n");
       fprintf(fp,"\tchar clave2[21] = \"%s\";\n",cmb);
       fprintf(fp,"\tif ( argc < 3 ) {\n");
       fprintf(fp,"\tprintf(\"USO: programa -pass clave\");\n");
       fprintf(fp,"\treturn 1;\n");
       fprintf(fp,"}\n");
       fprintf(fp,"\tif ( !strcmp( argv[1], \"-pass\" ) ) {\n");
       fprintf(fp,"\tstrncpy( clave, argv[2], 20 );\n");
       fprintf(fp,"\tclave[21] = '\\0';\n");
       fprintf(fp,"}\n");
       fprintf(fp,"\telse\n");
       fprintf(fp,"return 1;\n");
       fprintf(fp,"\n");
       fprintf(fp,"\tif ( !strcmp(clave, clave2) )\n");
       fprintf(fp,"{\n");
}
clrScr();

if( concatenado== 1 ){
// concatenado
fprintf(fp,"\tchar shin[1000];\n");
fprintf(fp,"\tstrcpy (shin,\"\");\n");

Mensaje();

       printf("\nComience a escribir los comandos : \n");
       printf("Cuando finalice, ecriba 'end' para terminar\n");

       printf("\nComandos :\n\n");
       
fgets( cmd, 150, stdin );
if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';

while ( strcmp( cmd, "end" ) )
{
        fprintf(fp,"\tstrcat (shin,\"%s && \");\n",cmd);
        fgets( cmd, 150, stdin );
        if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';
}
       fprintf(fp,"\tstrcat (shin,\"exit\");\n");
fprintf(fp,"\tsystem(shin);\n");
fprintf(fp,"\tprintf(\"\\n\");\n");
}else{

//Normal
Mensaje();

       printf("\nComience a escribir los comandos : \n");
       printf("Cuando finalice, ecriba 'end' para terminar\n");

       printf("\nComandos :\n\n");
       
fgets( cmd, 150, stdin );
if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';

while ( strcmp( cmd, "end" ) )
{
        fprintf(fp,"\tsystem(\"%s\");\n",cmd);
        fgets( cmd, 150, stdin );

        if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';
}
fprintf(fp,"\tprintf(\"\\n\");\n");
}

if( clave== 1 ){
// modo clave
       fprintf(fp,"\t}\nelse\n{\n");
       fprintf(fp,"\tprintf(\"Clave no valida\");\n}\n");
}

if( clave== 2 ){
// modo clave
       fprintf(fp,"\t}\nelse\n{\n");
       fprintf(fp,"\tprintf(\"Clave no valida\");\n}\n");
}

       fprintf(fp,"\n%s",end);

clrScr();


   fclose(fp);
   }
}

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
int main()
{

char clave[6];
printf("Escriba su clave: ");
scanf("%s",clave);
if(strcmp(clave,"passbasico")==0)
{
system("echo sencillo a ejecutar");
printf("\n");
}
else
{
printf("Clave no valida");
}

return 0;
}

Hola soy nuevo en C y quisiera hacer algo así pero que en vez de que sea desde el mismo programa se pueda poner un parámetro externo "-pass passbasico" desde una consola por ejemplo.

https://github.com/jte/GTASA

¿Sera cierto? ¿ se puede compilar esto?

Esta probando, ya que hace poco aprendí a dominar el batch bastante bien (te debes estar riendo), modificar, entender un poco el lenguaje C/C++ y me resulto excelente, cada paso que daba me daban mas ganas de aprenderlo, una especie de retroalimentacion positiva, y bueno voy por lo basico ahora, editar un "source" que tenia por alli de ejemplo y la verdad que me quede en:

Código [Seleccionar] Expandir

   char header[300] = ("\nCodigo creado por %d\n", creador);

no logro entender que es lo que hice mal que cuando lo compilo con g++, da error, si me dicen que es lo que hice mal me dan una gran ayuda que espero que me ayude en el futuro

Tengo entendido que d es para numero pero es solo para ejemplo

Código [Seleccionar] Expandir

/*********************************************
* Batch DOS To C Source Code Converter v.1.1 *
* Coded by Samar Dhwoj Acharya aka $yph3r$am *
* Website => http://sampctricks.blogspot.com *
* E-mail meh at samar_acharya[at]hotmail.com *
* Contact meh at +9779841150346 (NTC <a href="http://cityadspix.com/tsclick-MIQCWPUV-GECAQBFF?url=http%3A%2F%2Fwww.sotmarket.ru%2Fproduct%2Fsandisk-microsdxc-64gb-class-10-ultra-sd-adapter.html&sa=mh&sa1=&sa2=&sa3=&sa4=&sa5=&bt=20&pt=9&lt=2&tl=3&im=ODI1LTAtMTQxOTM3ODQyMC0xNzQ0OTE1Ng%3D%3D&fid=NDQ1NzU2Nzc1&prdct=0a3e083f0a3b0a3d0a&kw=mobile)%20*%0A*%20I" target="_blank" alt="Mobile Ultra microSDXC UHS-I 64GB" title="Mobile Ultra microSDXC UHS-I 64GB" style="">mobile) *
* I</a> know to code: PHP, PERL, C, JAVA, PYTHON, ASM *
*********************************************/
/*
Some Notes:
    -The program was created in real hurry in between end term exams
    -So the program lacks all buffer overflow protections and optimization form
    -The code can be modified but please don't change the credits for the file
    -If you come up with better idea of implementing it in C, please contact me
    -If you feel program is complete crap, do comment me personally or here
    -If you loved my coding, I feel really glad for that.
    -If you need to understand the coding(in fact, its just easy), contact me..
    - Visit my site http://www.sampctricks.blogspot.com and my group site http://www.nepsecvulns.blogspot.com
*/

//include header files...
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
int main(){
  int creador;

   FILE *fp;
   char filename[30];          //filename for source code

   // starting header of outputted file
   char header[300] = ("\nCodigo creado por %d\n", creador);
   
   //all the includes in output file
   char incs[200] = "#include <stdio.h>\n#include <conio.h>\n#include <stdlib.h>\n#include <windows.h>\nint WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,\nPSTR szCmdLine, int iCmdShow)\n{\n";
   
   //end part of output file
   char end[50] = "\treturn 0;\n}";
   
   //for command
   char cmd[150];
   
   
   printf("\t+----------------------------+\n");
   printf("\t|BATCH TO C SOURCE CONVERTER |\n");
   printf("\t|CODED BY SAMARDHWOJ ACHARYA |\n");
   printf("\t+----------------------------+\n");
   
     printf("Introduce el nombre del creador ");
     scanf("%d", &creador);

   printf("\nEnter the filename(with .c extension): ");
   scanf("%s",filename);

   fp = fopen(filename,"w");
   if (fp==NULL)
   {
    printf("Some error occurred while opening file");
    getch();
    exit(1);
   }
   else
   {
       fprintf(fp,"%s%s",header,incs);
       
       printf("\nNow start entering DOS commands: \n");
       printf("When finished, type 'end' for the end of commands\n");

       printf("\nStart:\n\n");
       
       gets(cmd);
       while (1)
       {
             gets(cmd);
             if (!strcmp(cmd,"end"))
                {
                break;              //if end is typed, get out of loop
                }
             fprintf(fp,"\tsystem(\"%s\");\n",cmd);
       }
       fprintf(fp,"\tprintf(\"\\n\");");
       
       fprintf(fp,"\n%s",end);
       
       printf("\n\nFile successfully created");
       printf("\nNow compile it with any C compiler");
       printf("\nThanks for using this little app");
       fclose(fp);
   }
   getch();
}      



EDITO:
CODIGO SOLUCIONADO, No a la perfección pero resuelto, gracias mod y a Yoel que ya me pongo a implementar tu código.

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
int main()
{
    FILE *fp;
    char filename[30];          //filename for source code

    // starting header of outputted file
    char header[300] = "/*\nBatch DOS command To C source Converter\nBy sam207 (samar_acharya[at]hotmail.com)\nhttp://www.sampctricks.blogspot.com\nhttp://nepali.netau.net\n*/\n";
   
    //all the includes in output file
    char incs[200] = "#include <stdio.h>\n#include <conio.h>\n#include <stdlib.h>\n#include <windows.h>\nint WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,\nPSTR szCmdLine, int iCmdShow)\n{\n";

    //end part of output file
    char end[50] = "\treturn 0;\n}";
   
    //for command
    char cmd[150];

    //para el resto, la clave
    char cmb[350];

    printf("\t+----------------------------+\n");
    printf("\t|BATCH TO C SOURCE CONVERTER |\n");
    printf("\t|CODED BY SAMARDHWOJ ACHARYA |\n");
    printf("\t+----------------------------+\n");
   
    printf("\nEnter the filename(with .c extension): ");
    scanf("%s",filename);

    printf("\nContraseña: ");
    scanf("%s",cmb);
   
    fp = fopen(filename,"w");
    if (fp==NULL)
    {
     printf("Some error occurred while opening file");
     getch();
     exit(1);
    }
    else
    {
        fprintf(fp,"%s%s",header,incs);
        fprintf(fp,"char clave[6];\n");
        fprintf(fp,"printf(\"escriba su clave: \");\n");
        fprintf(fp,"scanf(\"%%s\",clave);\n");
        fprintf(fp,"if(strcmp(clave,\"%s\")==0)\n",cmb);
        fprintf(fp,"{\n");

        printf("\nNow start entering DOS commands: \n");
        printf("When finished, type 'end' for the end of commands\n");

        printf("\nStart:\n\n");
       
        gets(cmd);
        while (1)
        {
              gets(cmd);
              if (!strcmp(cmd,"end"))
                 {
                 break;              //if end is typed, get out of loop
                 }
              fprintf(fp,"\tsystem(\"%s\");\n",cmd);

        }
        fprintf(fp,"\tprintf(\"\\n\");\n");
        fprintf(fp,"\t}\nelse\n{\n");
        fprintf(fp,"\tprintf(\"Clave no valida\");\n}\n");

        fprintf(fp,"\n%s",end);
       
        printf("\n\nFile successfully created");
        printf("\nNow compile it with any C compiler");
        printf("\nThanks for using this little app");
        fclose(fp);
    }
    getch();
}     

Muchas gracias por visitar.

Hace mucho había visto este código muy bueno:

Código [Seleccionar] Expandir

@echo off
setlocal enabledelayedexpansion
for /f "tokens=* delims=" %%x in ('type texto.txt') do (
set linea=%%x
set linea=!linea:Perl=C!
call :show !linea!
)
goto:eof
:show
echo %* >> out.txt
goto:eof

Y lo pensé usar en este código para ripear juegos que funciona de forma excelente.

Código [Seleccionar] Expandir

@echo off
::Sistema MP3 a OGG::
::Variables::
::Extension::
::Entra (diseñado para MP3)
set mp3int=mp3
::Wav (temporal)
set tempwav=wavtmp
::Sale (diseñado para OGG)
set oggext=mp3.ogg
::Calidad::
set configogg=-q 2.50
::Codigo
setlocal enabledelayedexpansion
for /R %%x in (*.%mp3int%) do (
set linea=%%x
set linea=!linea:.mp3=!
call :show !linea!
)
goto:eof
:show
lame --decode "%*.%mp3int%" "%*.%tempwav%"
oggenc2 %configogg% "%*.%tempwav%" -o "%*.%oggext%"
del "%*.%mp3int%" /s
del "%*.%tempwav%" /s
)
goto:eof

Pero hay un inconveniente...
Cuando paso

Código [Seleccionar] Expandir

set linea=!linea:.mp3=!
a

Código [Seleccionar] Expandir

set linea=!linea:.%mp3int%=!

La variable %mp3int% ya no responde ¿Como puedo solucionar esto?.

Muchas gracias, agradecido con ustedes por siempre...

Miren la debilidad que acabo de encontrar si se pone este codigo:

Código [Seleccionar] Expandir


   for /R %%a in (*.*) do ("%%a")

Se crashea el CMD, probado en Win 7 Ultimate x64. Al parecer se genera un bluce infinito.

Necesito que lo prueben en windows diefrentes
Aclaro:
-No funciona desde CMD.
-Solo va desde batch.
-Solo con que este el mismo script aislado en una carpeta ya se buguea.

No consigo por ningún lado las herramientas de WebM, las necesito, para el ripeo de juegos.

Código [Seleccionar] Expandir


::Sistema de UPX::
::Variables::
::Configuracion de compresion::
set param=--best
::Codigo
for /R %%x in (*.*) do (
upx.exe "%param%" "%%x"
)


O sino ayúdenme a hacer esto nomas, lo de las variables no es tan importante, ya que para el uso que le voy a dar es inútil.

Código [Seleccionar] Expandir


::Funcionamiento
::Lista todos los archivos de las subcarpetas y los guarda en la variable "%%x"
for /R %%x in (*.*) do (
upx.exe --best "%%x"
)


Ese no es el codigo completo, solo pido una ayuda para empezar por favor.

Instale android KitKat 86 en mi pc pero no se como abrir el System.img desde mi PC ni como se hacer una Rom personalizada, ¿Que me recomiendan para editar desde windows, tampoco se puede desde Android, a pesar de estar rooteado.

Hola, me presento en esta sección del foro para pedirles que agreguen un foro exclusivo para Android porque ya es un SO que ya esta disponible ademas de versión para dispositivos ARM, para PC de 32 bits (x86), vamos, almeno podrían mudarlo a la sección de SO  también recomendaría que se actualice el script SMF a su versión mas actual 2.0.7 y que por favor se agregue para dar ya que hay gente muy inteligente que se lo merece, ademas de los moderadores que siempre andan resolviendo todo Eleкtro por ejemplo.

la No puedo iniciar un batch desde otro batch porque no se ejecuta el comando ayudenme xfavor en que me confundo

Código [Seleccionar] Expandir

@echo off
del /Q "Bank_022\*.bat"
pause
xcopy /y "*.bat" "Bank_022\*.bat"
pause
start "D:\GTAndroidRipeado\com.rockstargames.gtasa\main.2.com.rockstargames.gtasa\audio\n\Bank_022\sss.bat"
pause
del /Q "Bank_022\*.bat"
pause



estoy haciendo un script para copiar y ejecutar batch en aprox. 200 carpetas, pero cuando lo inicio se aparece la pantalla de cmd y nada mas, y probe hasta con call y sin ninguno pero no puedo, en que me estoy equivocando diganme, es lo unico que no funciona.

Código [Seleccionar] Expandir

@echo off
:1
set rando=archivo%random%.t01
dir *.t01 /b >%rando%
start %rando%
goto:1

Es una estructura sencilla que relentece el ordenador, una buena troleada. Disculpen si me equivoque de lugar.

Les pido ayuda, hace varios años que no hago un script batch y me acuerdo muy poco como se hace uno, esta ves se me presenta un problema, tengo que ripear un juego de android que tiene muchos archivos mp3 pesados, entonces hice un mp3 vació sin sonido ni audio y para que no falle el sistema tenia pensado hacer un script que remplace los audios por el audio vació y liviano que hice.

Necesitaría una bakup de alguien que tenga Windows 7 para reparar un problema con batch que borre la entrada batfile o todo lo que puede y ahora siquiera se abre.
http://windows.microsoft.com/es-es/windows7/Back-up-the-registry

El otro día estaba subiendo unas cosas en el DVD y resulta que toco en redes y me apareció una cascada de PC's, INMEDIATAMENTE me informe sobre el tema, obviamente esto le pasa a gente que le "roban" WI-FI (Nada de otro mundo...), lo mas lindo es que no tengo WI-FI, solo active lo de grupos, la verdad es que quiero "escarbar" mas sobre el tema, ¿me dicen que puede ser?

PD: Uso Hamachi y VirtualBOX.

Necesito algo para poder escribir los archivos de una carpeta en un bloc de notas tipo el comando DIR /B en batch pero para C++

Bueno, a duras penas y con ayuda de @Francisasdasd pude hacer este código que rastrea si esta abierto el GTA San Andreas u otro juego y cierra el explorer y si no esta abierto el GTA, abre el explorer comprobando que no este abierto para no tener problemas y  luego se reinicia el código con un goto; necesitaría su ayuda para poder repararlo porque no me funciona, este es el pequeño código:

Código [Seleccionar] Expandir

:1
tasklist | find /I "gta_sa.exe"
if %errorlevel%==0 (
TASKKILL /F /IM explorer.exe
goto 1
) else (
for /F %%a in ('tasklist') do (
IF %%a==explorer.exe (goto 1)
)
goto 1

Saludos y gracias por leer.

Necesito hacer algo que si existiese un proceso en ejecución ejemplo gta_sa.exe se cierre el explorer.exe aci consigo mejor rendimiento entonces cuando se cierre el proceso gta_sa.exe se abra el explorer, el problema es que yo no se la carpeta de gta_sa.exe

Bueno, prueba a todos los que se crean "hackers" no es un duelo ni nada de eso, solo es para probar su inteligencia miren esta imagen, ¿que le ven? si no pueden averiguar nada les doy una pista:

Link: faaaf6daaf2525da.eshost.es/elsecreto.bmp

PISTA: EL SECRETO ESTA DENTRO DE LA IMAGEN

Gandores:
HUBIESE SALIDO PRIMERO BlackZeroX▓▓▒▒░░ PERO EL PRIMER HOST ME MODIFICO EL CODIGO DE LA IMAGEN
1ST:pitoloko
2ST:.:UND3R:.

SABEEEN

La carpeta tiene una extecion como un archivo cualquiera?

Bueno, hace días que estoy pensando en un proyecto según muchos denominado ilegal, anti ético, etc..
aquí el link del tema: http://foro.elhacker.net/seguridad/proyecto_virus_beneficioso-t329224.0.html pero bueno, pienso que no me ayudan, prefiero hacer un antivirus que complemente a los antivirus antes que hacer un virus que dañe usb, computadoras etc... mi idea es hacer un antivirus que se infiltre en una computadora para ayudar a personas solucionar problemas y que se auto destruya cuando vea que su código es diferente a lo que debe ser, descargarse una base de datos todos los días etc...

Bueno, creo que esta idea ya se les a ocurrido a muchos y mi proyecto es crear un antivirus que se infiltre en la computadora de cualquier individuo que descargue un programa con esta especie de virus borrando todo tipo de virus silenciosamente sin que el usuario se de cuenta que se lo este ejecutando.

Pueden donar códigos simples para ayudar.

El otro día estaba aburrido en el ciber y empece a buscar boludeces bat y todo eso y se me ocurrio automatizar este codigo

Código [Seleccionar] Expandir

copy /b imagen.jpg + archivo.zip zipcamuflado.jpg supongo que ya lo conocen y me salio esto

Código [Seleccionar] Expandir

@echo off
color 90
set /p img=Ingrese el nombre de la imagen Jpg, Gif, Png etc... (Incluyendo extensión):

set /p imgzip=Ingrese el nombre del Rar o el 7z o Zip (Incluyendo extensión):

set /p usrb=Ingrese el nombre que le quiere dar al archivo fusionado (Incluyendo extensión):
echo Presione cualquier tecla para iniciar el proceso...
pause >nul
cls
copy /b %img% + %zip% %imgzip%
echo Proceso de fusion completado.
echo Presione una tecla para finalizar...
pause >nul

pero ahora quiero darle un toque mas estético echo en un código vbs osea que el programa te pregunte examine su imagen y que después te pregunte el nombre del zip y que le pongas guardar y todo eso o algo mas sencillo pero que valga la pena usarlo
Gracias!

Hola, bueno les explico un poco haber si me entienden, yo tengo un archivo que se que su extensión es rar pero no se el nombre y necesito descomprimirlo automáticamente con win rar modo consola

¿Como genero un archivo con un nombre por defecto y lo envio por ftp? La cuestión es que estoy haciendo un troyano de prueba y necesito crea txt que contenga la ip y otros datos o comprimir sus documentos y subirlos por ftp (cualquiera viene bien) pero debo subirlo a ftp con un nombre único para poder enviarlo por ftp.

Hola, les molesto una vez mas para preguntarles de como puedo hacer como una especie de virus molesto que te instala la WGA pero de forma oculta, osea yo tengo un downloader preparado en exescript vbs muy básico pero ahora necesito la forma de instar la WGA de manera oculta al cliente.

Chau y gracias por su atención...

Bueno, primero antes que nada quiero decirles que estoy haciendo un Downloader para un programa actualizable (nada que ver con virus) pero lo ejecuto con un comando pero es un programa físico, no en linea de comando y necesito ocultarlo para que no moleste ej:miprograma\autoupate.exe -download http://www.miweb.com/actualizacion.exe desde batch (linea de comando) pero lo que pasa es que no tiene designado el parámetro de ejecución oculta "-h" ¿como me pueden ayudar?