fork download
copy 
  1. #include<stdio.h>
  2. #include<string.h>
  3. #include<limits.h>
  4. #include<stdint.h>
  5.  
  6. #define BUFSIZE 48
  7. #define NUMENCDATA 4
  8.  
  9. void printb(unsigned int v) {
  10.   unsigned int mask = (int)1 << (sizeof(v) * CHAR_BIT - 1);
  11.   do putchar(mask & v ? '1' : '0');
  12.   while (mask >>= 1);
  13. }
  14.  
  15. void putb(unsigned int v) {
  16.   putchar('0'), putchar('b'), printb(v), putchar('\n');
  17. }
  18.  
  19. static const size_t sixbase = 0b111111;
  20. static const size_t eigbase = 0b11111111;
  21. static const char table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  22.  
  23. enum State { First = 1, Second = 2, Third = 3, Finish = 4 };
  24. typedef struct {
  25.     size_t bytes;
  26.     size_t eqNum;
  27.     uint8_t org[3];
  28.     enum State state;
  29. } FSM;
  30.  
  31. static FSM initState = { 0, 0, {0}, First };
  32.  
  33.  
  34. void FSM_init(FSM *self) {
  35.     *self = initState;
  36. }
  37.  
  38. void FSM_stack(FSM *self, uint8_t c) {
  39.     size_t stack = (size_t)c;
  40.     switch (self->state) {
  41.         case First:
  42.             self->bytes = (stack << 16);
  43.             self->state = Second;
  44.             self->org[0] = c;
  45.             break;
  46.         case Second:
  47.             self->bytes = self->bytes | (stack << 8) ;
  48.             self->state = Third;
  49.             self->org[1] = c;
  50.             break;
  51.         case Third:
  52.             self->bytes = self->bytes | stack;
  53.             self->state = Finish;
  54.             self->org[2] = c;
  55.             break;
  56.         case Finish:
  57.             fprintf(stderr,"スタックがいっぱいです。\n");
  58.             break;
  59.     }
  60. }
  61.  
  62. void FSM_encode_flush(FSM *self) {
  63.     uint8_t res[NUMENCDATA];
  64.     if(self->state == Finish) { 
  65.         for(size_t it = 0; it != NUMENCDATA; ++it) {
  66.             res[it] = table[(self->bytes & (sixbase << (18 - 6 * it))) >> (18 - 6 * it)];
  67.         }
  68.         fwrite(res, sizeof(uint8_t), 2, stdout);
  69.         if(self->eqNum == 2) { 
  70.             printf("==");
  71.         }
  72.         if(self->eqNum == 1) {
  73.             fwrite(res+2, sizeof(uint8_t), 1, stdout);
  74.             printf("=");
  75.         }
  76.         if(self->eqNum == 0) {
  77.             fwrite(res+2, sizeof(uint8_t), 2, stdout);
  78.         }
  79. //        printf(" : ");
  80. //        printf("%c%c%c :",self->org[0], self->org[1], self->org[2]);
  81. //        putb(self->bytes);
  82.         *self = initState;
  83.     }
  84. }
  85.  
  86. void FSM_pre_terminal_proc(FSM *self) {
  87.     switch (self->state) {
  88.         case First:
  89.             break;
  90.         case Second:
  91.             self->eqNum = 2;
  92.             FSM_stack(self,0);
  93.             FSM_stack(self,0);
  94.             break;
  95.         case Third:
  96.             self->eqNum = 1;
  97.             FSM_stack(self,0);
  98.             break;
  99.         case Finish:
  100.             break;
  101.     }
  102.     return;
  103. }
  104.  
  105.  
  106. void b64enc(FILE *fp) {
  107.     FSM fsm;
  108.     FSM_init(&fsm);
  109.     uint8_t buf[BUFSIZE];
  110.     size_t nread;
  111.     while((nread = fread(buf, sizeof(uint8_t), BUFSIZE, fp)) > 0) {
  112.         for(size_t it = 0; it != nread; ++it) {
  113.             FSM_stack(&fsm, buf[it]);
  114.             FSM_encode_flush(&fsm);
  115.         }
  116.         if(feof(fp)) {
  117.             FSM_pre_terminal_proc(&fsm);
  118.             FSM_encode_flush(&fsm);
  119.         }
  120.         printf("\n");
  121.     }
  122.  
  123. }
  124.  
  125.  
  126. int main(void) {
  127.     FILE *fp;
  128.     if( fopen_s(&fp,"base64s.c", "rb") < 0) {
  129.         fprintf(stderr, "ファイルを開けませんでした!\n");
  130.         return 1;
  131.     }
  132.     b64enc(fp);
  133.     fclose(fp);
  134.     return 0;
  135. }
  136. //
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
prog.c: In function ‘main’:
prog.c:128:9: warning: implicit declaration of function ‘fopen_s’; did you mean ‘fopen’? [-Wimplicit-function-declaration]
     if( fopen_s(&fp,"base64s.c", "rb") < 0) {
         ^~~~~~~
         fopen
At top level:
prog.c:20:21: warning: ‘eigbase’ defined but not used [-Wunused-const-variable=]
 static const size_t eigbase = 0b11111111;
                     ^~~~~~~
/usr/bin/ld: /home/MeWhrN/cc7MeZdH.o: in function `main':
prog.c:(.text.startup+0x26): undefined reference to `fopen_s'
collect2: error: ld returned 1 exit status
stdout
copy 
Standard output is empty
https://ideone.com/7wolLZ
language:
C (gcc 8.3)
created:
3 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!