int stat(const char *file, struct stat *_s)
{
if(_s) zeromem(_s, sizeof(struct stat));
if(!file || !_s) return -1;
FSTATS fs;
if( GetFileStats(file, &fs, (unsigned int*)__errno_location()) )
{
__set_errno(ENOENT);
return -1;
}
zeromem(_s, sizeof(struct stat));
_s->st_size = fs.size;
return 0;
}
int GetID3(ID3 *id3, const char *path)
{
FSTATS fs;
unsigned int err;
if (GetFileStats(path, &fs, &err) == -1) return -1;
int fp = _open(path, A_ReadOnly + A_BIN, P_READ, &err);
if (fp == -1) return -1;
char head[ID3_HEAD_LEN];
if (_read(fp, head, ID3_HEAD_LEN, &err) < ID3_HEAD_LEN) //empty?
{
_close(fp, &err);
return -1;
}
//get tag version
enum id3_ver_enum {id3_v1, id3_v2};
int id3_ver;
if (strncmp(head, ID3_V1_HEAD, ID3_HEAD_LEN) != 0)
{
id3_ver = id3_v1;
_close(fp, &err);
return -1;
}
else if (strncmp(head, ID3_V2_HDR, ID3_HEAD_LEN) != 0)
{
id3_ver = id3_v2;
}
else
{
_close(fp, &err);
return -1;
}
//read id3v2 header
if (id3_ver == id3_v2)
{
ID3_V2_HEADER header;
strncpy(header.head, head, ID3_HEAD_LEN);
header.head[ID3_HEAD_LEN] = '\0';
char *buffer = malloc(ID3_V2_HDR_SIZE);
_read(fp, buffer, ID3_V2_HDR_SIZE - ID3_HEAD_LEN, &err);
header.ver = buffer[0];
header.rev = buffer[1];
header.flags = buffer[2];
header.size = ID3_V2_4_BitCock(buffer + 3);
//header.size = (buffer[6] & 0xFF) | ((buffer[5] & 0xFF) << 7 ) | ((buffer[4] & 0xFF) << 14 ) | ((buffer[3] & 0xFF) << 21 );
//only v2.4
unsigned int frame_lenght;
if (header.ver != 0x04)
{
mfree(buffer);
_close(fp, &err);
return 0;
}
frame_lenght = 0x0A;
mfree(buffer);
buffer = malloc(header.size + 5);
_read(fp, buffer, header.size + 4, &err);
zeromem(id3, sizeof(ID3));
unsigned int tag_lenght;
unsigned int frame_id = 0;
int helper;
unsigned int i = 0;
while (i < header.size && frame_id < ID3_V2_FRAME_COUNT)
{
if (buffer[i] >= 'A' && buffer[i] <= 'Z')
{
helper = ID3_V2_Helper(buffer + i);
if (helper != -1)
{
if (helper == 5) //wtf?
{
tag_lenght = ID3_V2_4_BitCock(buffer + i + ID3_V2_4_FRAME_LEN) - 5;
i += frame_lenght + 5;
}
else
{
tag_lenght = ID3_V2_4_BitCock(buffer + i + ID3_V2_4_FRAME_LEN) - 1;
i += frame_lenght + 1;
}
id3->tag[helper] = AllocWS(tag_lenght + 1);
utf8_2ws(id3->tag[helper], buffer + i, tag_lenght);
frame_id++;
i += tag_lenght - 1;
}
}
i++;
}
mfree(buffer);
}
_close(fp, &err);
return 1;
}
EXP_CREATE_ARCHIVE ()
{
const char **CurFile;
#else /* !TARGET_EMBEDDED */
int main (int ArgCount, const char **Args)
{
int CurArg;
const char *DestFile = NULL;
BOOLEAN NoNames = FALSE;
#endif /* !TARGET_EMBEDDED */
int Result = RESULT_GENERAL_ERROR;
#ifdef ENABLE_DUMP
BOOLEAN Dump = FALSE;
#endif /* ENABLE_DUMP */
ARCHIVE Archive;
// Check the sizes of basic integer types.
if (sizeof (I1) != 1 || sizeof (I2) != 2 || sizeof (I4) != 4 || sizeof (SI1) != 1 || sizeof (SI2) != 2 || sizeof (SI4) != 4 || sizeof (OFFSET) < sizeof (SI4))
{
Error (NULL, "Generic type size error!");
return RESULT_STRANGE_ERROR;
}
// Initialize.
memset (&Archive, 0, sizeof (Archive));
#ifdef TARGET_EMBEDDED
ErrorFunction = ErrorMessage;
#endif /* TARGET_EMBEDDED */
#ifdef TARGET_EMBEDDED
for (CurFile = ObjectFiles; *CurFile; CurFile++)
{
FILE *File = fopen (*CurFile, "rb");
if (File)
{
SIZE Size;
fseek (File, 0, SEEK_END);
Size = ftell (File);
rewind (File);
{
I1 *Data = malloc (Size);
if (Data)
{
if (fread (Data, Size, 1, File) == 1)
{
// Create a new object file inside the current archive.
OBJECT_FILE *ObjectFile = calloc (1, sizeof (OBJECT_FILE));
if (!ObjectFile)
{
Error (*CurFile, "Out of memory.");
break;
}
ObjectFile->Parent = &Archive;
ObjectFile->Data = Data;
ObjectFile->Size = Size;
ObjectFile->FileName = *CurFile;
GetFileStats (*CurFile, ObjectFile->FileStats);
Append (Archive.ObjectFiles, ObjectFile);
// Update the statistics of the archive accordingly.
if (StatFileIsNewer (ObjectFile->FileStats, Archive.FileStats))
StatCopyAttributes (Archive.FileStats, ObjectFile->FileStats);
// Try to import the object file's contents.
ArImportObjectFile (ObjectFile);
}
else
Error (*CurFile, "Unable to read file.");
}
else
Error (*CurFile, "Not enough memory to load file.");
}
fclose (File);
}
else
Error (*CurFile, "Unable to open file.");
}
#else /* !TARGET_EMBEDDED */
#include "main_opt.inc"
#endif /* !TARGET_EMBEDDED */
{
OBJECT_FILE *FirstFile = GetFirst (Archive.ObjectFiles);
if (FirstFile)
{
// Set the destination file, in case it has not been set yet.
if (!DestFile)
{
// alloca should not fail in any case, so we don't generate an error message.
DestFile = alloca (strlen (FirstFile->FileName) + 2 + 1);
if (DestFile)
{
strcpy ((char *) DestFile, FirstFile->FileName);
strcat ((char *) DestFile, ".a");
}
}
#ifdef ENABLE_DUMP
if (Dump)
DumpArchive (stdout, NULL, &Archive);
#endif /* ENABLE_DUMP */
// Create the symbol table information.
CreateSymbolTable (&Archive);
// Create other necessary information.
FillExportHelpFields (&Archive);
if (DestFile && (GetArchiveFileSize (&Archive) > 0))
{
// Write the archive.
FILE *File = fopen (DestFile, "wb");
if (File)
{
BOOLEAN ThisResult;
if ((ThisResult = ExportArchiveFile (&Archive, File, NoNames)))
{
if (Result == RESULT_GENERAL_ERROR)
Result = RESULT_OK;
}
else
Result = RESULT_EXPORT_ERROR;
fclose (File);
if (!ThisResult)
remove (DestFile);
}
else
Error (DestFile, "Unable to create file.");
}
else
Result = RESULT_EXPORT_ERROR;
}
else
Error (DestFile, "Cannot create empty archive.");
}
Cleanup: ATTRIBUTE_UNUSED
// Final Cleanup.
FreeArchive (&Archive);
return Result;
}
int InitLGP(void)
{
FSTATS fs;
unsigned int err;
char path[256];
strcpy(path, dir_path);
strcat(path, "\\");
strcat(path, "71.txt");
if (GetFileStats(path, &fs, &err) == -1) return 0;
int fp = _open(path, A_ReadOnly + A_BIN, P_READ, &err);
if (fp == -1) return 0;
char *buffer = malloc(fs.size + 1);
buffer[fs.size] = '\0';
_read(fp, buffer, fs.size, &err);
char tmp[128];
char tmp_id[4];
unsigned int tmp_id_len = 0;
unsigned int wait_num = 1;
unsigned int pos = 0, len = 0;
while (pos <= fs.size)
{
if (buffer[pos] == '\n' || buffer[pos] == '\r' || buffer[pos] == '\0')
{
if (len)
{
_71_lgp = realloc(_71_lgp, sizeof(_71_LGP) * (_71_lgp_total + 1));
_71_lgp[_71_lgp_total].str = malloc(len + 1);
tmp[len] = '\0';
strcpy(_71_lgp[_71_lgp_total].str, tmp);
sscanf(tmp_id, "%d", &(_71_lgp[_71_lgp_total].id));
len = 0;
tmp_id_len = 0;
wait_num = 1;
_71_lgp_total++;
}
}
else
{
if (wait_num)
{
if (buffer[pos] != ',')
tmp_id[tmp_id_len++] = buffer[pos];
else
{
tmp_id[tmp_id_len] = '\0';
wait_num = 0;
}
}
else
{
tmp[len++] = buffer[pos];
}
}
pos++;
}
mfree(buffer);
_close(fp, &err);
return 1;
}
