// process a single INI directive
int IniLine(LPTSTR szBuffer, INIFILE *InitData, int fSectionOnly, int fLiveMod, TCHAR **errmsg)
{
register int i, nTokenLength;
unsigned int ptype, fPath;
int fg, bg, bc;
int j, toknum, tokdata, defval, context;
int path_len, min_path_len;
TCHAR szPathName[MAXFILENAME], szPathTest[MAXFILENAME];
unsigned char *dataptr;
void *vdata;
LPTSTR pszToken, delims;
// be sure the line is double-null terminated
szBuffer[ strlen( szBuffer ) + 1 ] = '\0';
// get first token, skip line if empty or all comment
pszToken = skipspace( szBuffer );
// handle section name
if (*pszToken == _TEXT('[')) {
strip_trailing( ++pszToken, _TEXT(" \t]") );
if ( toklist( pszToken, &SectionNames, &toknum ) != 1 )
return -0x100;
// legitimate section name, return corresponding bit
return (-(0x80 >> toknum));
}
void dump_structure(std::ostream& out)
{
std::string class_name = ClassInfo<T>::name;
strip_trailing(class_name, "Entry");
out << "DROP TABLE IF EXISTS " << class_name << ";\n";
out << "CREATE TABLE " << class_name << " (\n";
for (FieldList::const_iterator i = ClassInfo<T>::fields.begin(); i != ClassInfo<T>::fields.end(); ++i)
{
bool is_text = ((*i)->getType() == TYPE_STRING || (*i)->getType()== TYPE_STRING_CONST) &&
(*i)->isArray() && (*i)->getArraySize() == 16; // all string fields have 16 locales
if (is_text && (*i)->getArrayIndex() != 0) // only dump en_US locale
continue;
std::string field_name = (*i)->getName();
if (is_text)
strip_trailing(field_name, "0");
out << '`' << field_name << "` " << (*i)->getTypeName() << " NOT NULL,\n";
}
out << "PRIMARY KEY (" << (*ClassInfo<T>::fields.begin())->getName() << ") );\n";
}
void dump_all(DBCStorage<T> const& store, bool big_file = false)
{
std::string file_name = ClassInfo<T>::name;
strip_trailing(file_name, "Entry");
file_name += ".sql";
std::cerr << "Writing " << file_name << "...";
std::ofstream fs(file_name.c_str());
if (!fs.is_open())
{
std::cerr << "Error creating file " << file_name << std::endl;
return;
}
dump_structure<T>(fs);
dump_data<T>(fs, store, !big_file);
fs.close();
std::cerr << " done.\n";
}
void dump_data(std::ostream& out, DBCStorage<T> const& store, bool ext_insert = true)
{
std::string class_name = ClassInfo<T>::name;
strip_trailing(class_name, "Entry");
if (ext_insert)
out << "INSERT INTO " << class_name << " VALUES\n";
uint32 last_row = store.GetNumRows() - 1;
for (uint32 row = 0; row <= last_row; ++row)
{
T const* entry = store.LookupEntry(row);
if (!entry)
continue;
if (ext_insert)
out << "(";
else
out << "INSERT INTO " << class_name << " VALUES (";
uint32 col = 0;
for (FieldList::const_iterator itr = ClassInfo<T>::fields.begin(); itr != ClassInfo<T>::fields.end(); ++itr, ++col)
{
bool is_text = ((*itr)->getType() == TYPE_STRING || (*itr)->getType()== TYPE_STRING_CONST) &&
(*itr)->isArray() && (*itr)->getArraySize() == 16; // all string fields have 16 locales
if (is_text && (*itr)->getArrayIndex() != 0) // only dump en_US locale
continue;
if (col > 0)
out << ", ";
if (is_text)
out << '\'' << escape_string((*itr)->getValue(const_cast<T*>(entry))) << '\'';
else
out << (*itr)->getValue(const_cast<T*>(entry));
}
if (ext_insert)
out << (row < last_row ? "),\n" : ");\n");
else
out << ");\n";
}
}
/*
* Recursively parse a type hint. Return FALSE if the parse failed.
*/
static int parseTypeHintNode(sipSpec *pt, int out, int top_level, char *start,
char *end, typeHintNodeDef **thnp)
{
char *cp, *name_start, *name_end;
int have_brackets = FALSE;
typeHintNodeDef *node, *children = NULL;
/* Assume there won't be a node. */
*thnp = NULL;
/* Find the name and any opening and closing bracket. */
strip_leading(&start, end);
name_start = start;
strip_trailing(start, &end);
name_end = end;
for (cp = start; cp < end; ++cp)
if (*cp == '[')
{
typeHintNodeDef **tail = &children;
/* The last character must be a closing bracket. */
if (end[-1] != ']')
return FALSE;
/* Find the end of any name. */
name_end = cp;
strip_trailing(name_start, &name_end);
for (;;)
{
char *pp;
int depth;
/* Skip the opening bracket or comma. */
++cp;
/* Find the next comma, if any. */
depth = 0;
for (pp = cp; pp < end; ++pp)
if (*pp == '[')
{
++depth;
}
else if (*pp == ']' && depth != 0)
{
--depth;
}
else if ((*pp == ',' || *pp == ']') && depth == 0)
{
typeHintNodeDef *child;
/* Recursively parse this part. */
if (!parseTypeHintNode(pt, out, FALSE, cp, pp, &child))
return FALSE;
if (child != NULL)
{
/*
* Append the child to the list of children. There
* might not be a child if we have detected a
* recursive definition.
*/
*tail = child;
tail = &child->next;
}
cp = pp;
break;
}
if (pp == end)
break;
}
have_brackets = TRUE;
break;
}
/* We must have a name unless we have empty brackets. */
if (name_start == name_end)
{
if (top_level && have_brackets && children == NULL)
return FALSE;
/* Return the representation of empty brackets. */
node = sipMalloc(sizeof (typeHintNodeDef));
node->type = brackets_node;
}
else
{
char saved;
const char *typing;
/* Isolate the name. */
saved = *name_end;
*name_end = '\0';
/* See if it is an object in the typing module. */
if ((typing = typingModule(name_start)) != NULL)
{
if (strcmp(typing, "Union") == 0)
{
/*
* If there are no children assume it is because they have been
* omitted.
*/
if (children == NULL)
return TRUE;
children = flatten_unions(children);
}
node = sipMalloc(sizeof (typeHintNodeDef));
node->type = typing_node;
node->u.name = typing;
node->children = children;
}
else
{
/* Search for the type. */
node = lookupType(pt, name_start, out);
}
*name_end = saved;
/* Only objects from the typing module can have brackets. */
if (typing == NULL && have_brackets)
return FALSE;
}
*thnp = node;
return TRUE;
}
int main(int argc, register char **argv)
{
register char *curchar;
char cKeyChar;
int nKeyLen;
// initialize
// memset(freqtab, '\0', 256 * sizeof(int));
// memset(&header, '\0', sizeof(header));
for (i = 0; (i < 256); i++)
freqtab[i] = '\0';
// set default encryption key
for (i = 0, cKeyChar = ' '; i < BC_MAX_USER_KEY; i++) {
cKeyChar += (int)szDefKeyOffsets[i];
cEncKey[i] = cKeyChar;
}
header.usSignature = 0xEBBE; // set compression signature
szInputName[0] = szOutputName[0] = '\0';
// check for too few args or "batcomp /?"
if ((argc == 1) || (stricmp(argv[1],"/?") == 0))
usage();
// parse command line
for (argv++ ; argc > 1; argv++, argc--) {
if (**argv == '/') {
switch (toupper((*argv)[1])) {
case 'O':
fOverwrite = 1;
continue;
case 'Q':
fQuiet = 1;
continue;
case 'K':
fKillComments = 1;
continue;
case 'E':
// Set encryption flag, copy key (or as much of it as we need)
fEncrypt = 1;
if ((nKeyLen = (int)strlen(&((*argv)[2]))) > 0)
memcpy(cEncKey, &((*argv)[2]), (nKeyLen > BC_MAX_USER_KEY) ? BC_MAX_USER_KEY : nKeyLen);
continue;
default:
usage();
}
}
if (szInputName[0] == '\0')
strcpy(szInputName, *argv);
else if (szOutputName[0] == '\0')
strcpy(szOutputName, *argv);
else
usage();
}
if (szInputName[0] == 0)
usage();
if (fQuiet == 0)
printf(COPYRIGHT, PROGNAME);
if (szOutputName[0] == 0) {
strcpy(szOutputName, szInputName);
// check if it gets too long?
if ((out_ext = strrchr(szOutputName, '.')) == NULL)
out_ext = szOutputName + strlen(szOutputName);
strcpy(out_ext, ".btm");
}
if (fQuiet == 0)
printf(COMPMSG, szInputName, szOutputName);
// need full filename expansion here??
if (stricmp(szInputName, szOutputName) == 0)
error(ERR_SAMENAME);
// holler if no overwrite and output exists
if ((fOverwrite == 0) && (sopen(szOutputName, (O_RDONLY | O_BINARY), SH_DENYNO) != -1))
error(ERR_OVERWRITE);
// open input, deny read-write mode in case we get fooled and this is output as well!
if ((in = sopen(szInputName, (O_RDONLY | O_BINARY), SH_DENYRW)) == -1)
error(ERR_INPUT_OPEN);
// rewind & read the file header
read(in,(void *)&lCompressed,4);
// check for input file already compressed
if ((lCompressed & 0xFFFF) == 0xBEEB)
error(ERR_ALREADY_COMPRESSED);
// rewind input file
lseek(in,0L,0);
// open output
if ((out = sopen(szOutputName, (O_CREAT | O_TRUNC | O_RDWR | O_BINARY), SH_DENYRW, (S_IREAD | S_IWRITE))) == -1)
error(ERR_OUTPUT_OPEN);
// loop for two passes
for (pass = 1; (pass <= 2); pass++) {
uLines = 0; // clear line count
if (pass == 2) {
// output (unfinished) header
if (fEncrypt) {
// set up encryption key, encrypt common character table
TripleKey(cEncKey);
EncryptDecrypt(NULL, (char _far *)cEncKey, (char _far *)header.cCommon, BC_COM_SIZE);
}
data_out((char *)(&header), sizeof(header), 0, 0);
if (fEncrypt) {
// put common character table back like it was, also
// leaves encryption system in its post-table state
// for use in encrypting text stream
EncryptDecrypt(NULL, (char _far *)cEncKey, (char _far *)header.cCommon, BC_COM_SIZE);
// output dummy (gibberish) data for encryption key
data_out((char *)(&freqtab), BC_MAX_USER_KEY, 0, 0);
}
// set buffer address
dataptr = szOutputBuffer;
}
// back up to start
if (lseek(in, 0L, SEEK_SET) == -1L)
error(ERR_INPUT_SEEK);
while (getline(szInputBuffer) > 0) {
// scan or translate line
// strip trailing whitespace
strip_trailing(szInputBuffer);
// skip blank lines and comments
if (fKillComments && ((szInputBuffer[0] == '\0') || (strnicmp(szInputBuffer,"::",2) == 0)))
continue;
// check for REM
if (fKillComments && ((strnicmp(szInputBuffer, "rem ", 4) == 0) && (strnicmp(szInputBuffer, "rem >", 5) != 0)))
continue;
if (fQuiet == 0)
printf(COMPLINE, ++uLines);
curchar = szInputBuffer;
if (pass == 1) {
// pass 1, scan the line
// accum. char counts
for ( ; (*curchar != '\0'); curchar++)
freqtab[(int)*curchar]++;
} else {
// pass 2, translate the line
// count line length including CR
i = (int)strlen(szInputBuffer);
nTotalBytes += i;
if ((lTotalInput += (i + 1)) >= 0xFFE0L)
error(ERR_TOO_BIG);
// compress & output each character
for ( ; *curchar; curchar++) {
char *comptr;
if ((comptr = memchr(header.cCommon, *curchar, BC_COM_SIZE)) == NULL) {
// not in table, 3 nibbles
nibble_out(0);
nibble_out((char)(*curchar & 0xF));
nibble_out((char)(*curchar >> 4));
} else if (comptr >= max_one_nib) {
// last part of table, 2 nibbles
nibble_out(1);
nibble_out((char)(comptr - max_one_nib));
} else {
// beginning of table, just one nibble
nibble_out((char)(comptr - header.cCommon + 2));
}
}
}
}
