Diff for "Lucifen Library"

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <stdint.h>
   4 #include <string.h>
   5 
   6 #include <set>
   7 #include <map>
   8 #include <vector>
   9 
  10 std::vector<std::map<uint32_t, uint32_t>> maps;
  11 
  12 std::map<uint32_t, std::string> examples;
  13 
  14 //deduplicate identical strings within each scene even if they have different addresses
  15 bool deduplciate = true;
  16 std::set<uint32_t> seen;
  17 
  18 int main(int argc, char ** argv)
  19 {
  20     int strings = 0;
  21     int totalspace = 0;
  22     for(int i = 0; i < argc; i++)
  23     {
  24         maps.clear();
  25         seen.clear();
  26         
  27         auto f = fopen(argv[i], "rb");
  28         if(!f) continue;
  29         char magic[4];
  30         int n = fread(magic, 1, 4, f);
  31         if(n != 4 or strncmp(magic, "SOB0", 4) != 0) continue;
  32         uint32_t table_size;
  33         fread(&table_size, 4, 1, f);
  34         uint32_t table_end = table_size + 0x8;
  35         int header_count = 0;
  36         //int j = 0;
  37         while(ftell(f) < table_end)
  38         {
  39             //printf("Header %d at %08X:\n", j++, ftell(f));
  40             uint32_t word_pairs;
  41             fread(&word_pairs, 4, 1, f);
  42             std::map<uint32_t, uint32_t> newmap;
  43             for(int i = 0; i < word_pairs; i++)
  44             {
  45                 uint32_t key;
  46                 uint32_t value;
  47                 fread(&key, 4, 1, f);
  48                 fread(&value, 4, 1, f);
  49                 newmap[key] = value;
  50                 //printf("%08X: %08X\n", key, value);
  51             }
  52             maps.push_back(newmap);
  53             header_count += 1;
  54         }
  55         if(maps.size() < 5)
  56         {
  57             puts("not enough maps");
  58             exit(0);
  59         }
  60         fseek(f, table_end, SEEK_SET);
  61         uint32_t strings_start;
  62         uint32_t strings_end;
  63         fread(&strings_start, 4, 1, f);
  64         fread(&strings_end, 4, 1, f);
  65         totalspace += strings_end-strings_start;
  66         uint32_t header_end = ftell(f);
  67         uint32_t code_end = strings_start+header_end;
  68         //printf("String range: %08X~%08X\n", strings_start, strings_end);
  69         
  70         // can't tell if text is content text until a command tries to use it? I think?
  71         std::string text_memory;
  72         uint32_t text_memory_addr;
  73         
  74         bool justdidtext = false;
  75         
  76         // no idea if commands have proper inline arguments in this bytecode lol
  77         while(ftell(f) < code_end)
  78         {
  79             uint32_t address = ftell(f)-header_end;
  80             uint32_t command;
  81             fread(&command, 4, 1, f);
  82             
  83             if((command & 0xFFF00000) == 0x01800000 and maps[4].count(address) and maps[4][address] >= strings_start and maps[4][address] < strings_end)
  84             {
  85                 //printf("Found command that uses string: ");
  86                 //printf("%08X: %08X (%08X) / ", address, command, maps[4][address], argv[i]);
  87                 //printf("|%08X|:(|%08X|) [%s]\n", address+header_end, maps[4][address]+header_end, argv[i]);
  88                 strings++;
  89                 fseek(f, maps[4][address]+header_end, SEEK_SET);
  90                 int c = fgetc(f);
  91                 
  92                 if(c == 0) // 00 XX XX <string
  93                     fseek(f, 2, SEEK_CUR);
  94                 else // <string>
  95                     fseek(f, -1, SEEK_CUR);
  96                 
  97                 auto start = ftell(f);
  98                 while((c = fgetc(f)) != 0);
  99                 auto end = ftell(f);
 100                 char * text = (char *)malloc(end-start);
 101                 fseek(f, start, SEEK_SET);
 102                 fread(text, 1, end-start, f);
 103                 std::string str = std::string(text);
 104                 if(!examples.count(command))
 105                     examples[command] = str;
 106                 
 107                 //if(str != "")
 108                 //    printf("%08X text %s\n", command, text);
 109                     //printf("%s\n", text);
 110                     //printf("%08X: %08X %s\n", address+header_end, command, text);
 111                 
 112                 text_memory = str;
 113                 text_memory_addr = maps[4][address];
 114                 
 115                 free(text);
 116                 justdidtext = true;
 117             }
 118             else
 119             {
 120                 // I have NO CERTAINTY that this is correct
 121                 if((command == 0x000001C8 or command == 0x000001CF) and text_memory != "" and (!deduplciate or !seen.count(text_memory_addr)))
 122                 {
 123                     puts(text_memory.data());
 124                     if(deduplciate) seen.insert(text_memory_addr);
 125                 }
 126                 
 127                 justdidtext = false;
 128             }
 129             fseek(f, address+header_end+4, SEEK_SET);
 130         }
 131         
 132         fclose(f);
 133     }
 134     //printf("Total space for strings: %d\n", totalspace);
 135     //printf("Total strings: %d\n", strings);
 136     //for(auto &[k, v] : examples)
 137     //{
 138     //    printf("%08X: %s\n", k, v.data());
 139     //}
 140 }

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <stdint.h>
   4 #include <string.h>
   5 
   6 #include <set>
   7 #include <map>
   8 
   9 std::map<uint32_t, std::string> map; // resume table?
  10 std::set<uint32_t> set; // resume table?
  11 
  12 bool is_upper_jis_surrogate(int c)
  13 {
  14     return (c >= 0x80 and c <= 0xA1) or (c >= 0xE0 and c <= 0xFF);
  15 }
  16 
  17 int main(int argc, char ** argv)
  18 {
  19     //int strings = 0;
  20     for(int i = 0; i < argc; i++)
  21     {
  22         map.clear();
  23         set.clear();
  24         
  25         auto f = fopen(argv[i], "rb");
  26         if(!f) continue;
  27         char magic[4];
  28         int n = fread(magic, 1, 4, f);
  29         if(n != 4 or strncmp(magic, "TOB0", 4) != 0) continue;
  30         uint32_t header_size;
  31         uint32_t header_elements;
  32         fread(&header_size, 4, 1, f);
  33         fread(&header_elements, 4, 1, f);
  34         
  35         for(int j = 0; j < header_elements; j++)
  36         {
  37             uint8_t size;
  38             fread(&size, 1, 1, f);
  39             
  40             char * text = (char *)malloc(size-4);
  41             fread(text, 1, size-4, f);
  42             
  43             uint32_t value;
  44             fread(&value, 4, 1, f);
  45             map[value] = text;
  46             
  47             free(text);
  48         }
  49         if(ftell(f) != header_size+4)
  50         {
  51             puts("desynchronized"), puts(argv[i]);
  52             exit(0);
  53         }
  54         
  55         
  56         uint32_t table_size;
  57         uint32_t table_elements;
  58         fread(&table_size, 4, 1, f);
  59         fread(&table_elements, 4, 1, f);
  60         uint32_t table_end = table_size + header_size + 4;
  61         while(ftell(f) < table_end)
  62         {
  63             //printf("Header at %08X\n", ftell(f));
  64             uint32_t word;
  65             fread(&word, 4, 1, f);
  66             set.insert(word);
  67         }
  68         
  69         fseek(f, table_end, SEEK_SET);
  70         
  71         std::string text = "";
  72         //uint32_t start = ftell(f);
  73         while(1)
  74         {
  75             auto c = fgetc(f);
  76             bool closefile = feof(f) or ferror(f) or c < 0;
  77             if(closefile)
  78             {
  79                 if(text != "")
  80                     printf("%s\n", text.data());
  81                 break;
  82             }
  83             if(c == 0x5B) // STOP MAKING INHERENTLY ASCII INCOMPATIBLE FORMATS REEEEEEEEEEEEEEEEEEEEEEE
  84             {
  85                 c = fgetc(f);
  86                 c = fgetc(f);
  87                 c = fgetc(f);
  88                 c = fgetc(f);
  89                 c = fgetc(f);
  90                 c = fgetc(f);
  91                 
  92                 uint32_t skip;
  93                 int n = fread(&skip, 4, 1, f);
  94                 fseek(f, -4, SEEK_CUR);
  95                 fseek(f, skip, SEEK_CUR);
  96                 
  97                 if(n < 1)
  98                 {
  99                     if(text != "")
 100                         printf("%s\n", text.data());
 101                     break;
 102                 }
 103                 
 104                 if(text != "")
 105                 {
 106                     //printf("%08X \"%s\"\n", start, text.data());
 107                     printf("%s\n", text.data());
 108                 }
 109                 text = "";
 110                 
 111                 //start = ftell(f);
 112             }
 113             else
 114             {
 115                 text += c;
 116                 if(is_upper_jis_surrogate(c))
 117                     text += fgetc(f);
 118             }
 119         }
 120         
 121         fclose(f);
 122     }
 123     //printf("Total strings: %d\n", strings);
 124     //for(auto &[k, v] : examples)
 125     //{
 126     //    printf("%08X: %s\n", k, v.data());
 127     //}
 128 }