int main(int argc, char **argv)
{
QCoreApplication a(argc, argv);
GetOpt opts;
QString alphabet;
QString inputFilename;
QString outputFilename;
opts.addOption('f', "input", &inputFilename);
opts.addOption('o', "output", &outputFilename);
opts.addOption('a', "alphabet", &alphabet);
if (!opts.parse())
return 1;
if (alphabet.isNull())
alphabet = "english";
if (inputFilename.isNull())
inputFilename = "gaddaginput.raw";
if (outputFilename.isNull())
outputFilename = "output.gaddag";
QString alphabetFile = QString("../data/alphabets/%1.quackle_alphabet").arg(alphabet);
UVcout << "Using alphabet file: " << QuackleIO::Util::qstringToString(alphabetFile) << endl;
GaddagFactory factory(QuackleIO::Util::qstringToString(alphabetFile));
QFile file(inputFilename);
if (!file.exists())
{
UVcout << "Input gaddag does not exist: " << QuackleIO::Util::qstringToString(inputFilename) << endl;
return false;
}
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
{
UVcout << "Could not open " << QuackleIO::Util::qstringToString(inputFilename) << endl;
return false;
}
QTextStream stream(&file);
stream.setCodec(QTextCodec::codecForName("UTF-8"));
while (!stream.atEnd())
{
QString originalQString;
stream >> originalQString;
if (stream.atEnd())
break;
if (!factory.pushWord(QuackleIO::Util::qstringToString(originalQString)))
UVcout << "not encodable without leftover: " << QuackleIO::Util::qstringToString(originalQString) << endl;
}
UVcout << "Sorting " << factory.wordCount() << " words..." << endl;
factory.sortWords();
UVcout << "Generating nodes...";
factory.generate();
UVcout << "Writing index...";
factory.writeIndex(outputFilename.toUtf8().constData());
UVcout << endl;
UVcout << "Wrote " << factory.encodableWords() << " words over " << factory.nodeCount() << " nodes to " << QuackleIO::Util::qstringToString(outputFilename) << "." << endl;
UVcout << "Hash: " << QString(QByteArray(factory.hashBytes(), 16).toHex()).toStdString() << endl;
if (factory.unencodableWords() > 0)
UVcout << "There were " << factory.unencodableWords() << " words left out." << endl;
return 0;
}
void setupOptionsCpp(GetOpt& gopt)
{
gopt.addString(0, "cpp-hpath", ".", "Location for .hpp files");
gopt.addString(0, "cpp-include", "", "Generated #include lines reference this folder");
}
int main(int argc, char *argv[])
{
Ensemble ensemble;
// Note that ensemble is internally converted to pointer-type
SyncFiles syncFiles(ensemble);
std::string noteOpts;
// Annotation *notes=0;
std::string annotText;
std::string outputText;
std::string path;
if( argc == 1 )
{
syncFiles.description();
return 3;
}
GetOpt opt;
opt.opterr=0;
int copt;
std::string str;
std::string str0;
std::string oStr("Ad:Ehl:mMP:p:St:T");
oStr += "<--only-marked>";
oStr += "<--help>";
oStr += "<--line-feed>:";
oStr += "<--note>:";
while( (copt = opt.getopt(argc, argv, oStr.c_str() )) != -1 )
{
if( opt.longOption > 0 )
{
str0=opt.longOption;
if( str0 == "--help" )
{
syncFiles.description();
return 3;
}
if( str0 == "--line-feed" )
{
syncFiles.enableNewLine(opt.optarg);
continue;
}
if( str0 == "--note" )
{
noteOpts=opt.optarg;
continue;
}
if( str0 == "--only-marked" )
{
syncFiles.isPrintOnlyMarked=true;
continue;
}
}
switch ( copt )
{
case 'A':
//obsolete
break;
case 'd':
{
str0=opt.optarg;
std::string str("_");
size_t p=0;
if( (p=str0.find('/')) < std::string::npos )
str = str0.replace(p, 0, "_") ; // is a range
else if( (p=str0.find('-')) < std::string::npos )
str = str0.replace(p, 0, "_") ; // is a range
else if( hdhC::isNumber(str0) )
str += str0 ; // end time
else
return 3;
syncFiles.setTimeLimit(str) ;
}
break;
case 'E':
syncFiles.enablePrintEnsemble();
break;
case 'h':
syncFiles.description();
return 3;
break;
case 'l':
syncFiles.setTimeLimit(opt.optarg);
break;
case 'm':
syncFiles.enableMixingRefused();
break;
case 'M':
syncFiles.enableModificationTimeTest();
break;
case 'P':
path = opt.optarg ;
syncFiles.setPath(path) ;
break;
case 'p':
syncFiles.setQA_target(opt.optarg) ;
break;
case 'S':
// printing date range of each file in output requested
syncFiles.enablePrintDateRange();
break;
case 't':
{
str0=opt.optarg;
std::string str("/");
size_t p=0;
if( (p=str0.find('-')) < std::string::npos )
str = str0.replace(p, 0, "/") ; // is a range
else if( (p=str0.find('/')) < std::string::npos )
str = str0 ; // is a range separated by '/'
else if( hdhC::isNumber(str0) )
str += str0 ; // end time
else
return 3;
syncFiles.setTimeLimit(str) ;
}
break;
case 'T':
syncFiles.enablePrintTotalTimeRange() ;
break;
default:
std::ostringstream ostr(std::ios::app);
ostr << "syncFiles:getopt() unknown option -" ;
ostr << copt;
ostr << "\nreturned option -" << copt ;
std::cout << ostr.str() << std::endl ;
break;
}
}
// Note= argc counts from 1, but argv[0] == this executable
if( opt.optind == argc )
syncFiles.readInput();
else
syncFiles.readArgv(opt.optind, argc, argv);
// this does all
return syncFiles.run();
}
void
parseOptions(int argc, char *org_argv[], IObjContainer &ioc)
{
GetOpt opt;
opt.opterr=0;
int copt;
std::string str0("null");
std::string str1;
// std::vector<std::string> inputFilename;
std::vector<std::string> outputFilename;
// working with std::string is preferred
std::vector<std::string> argv;
for( int i=0 ; i < argc ; ++i)
argv.push_back( org_argv[i] );
// read options from file?
readOptions(argv);
int sz=argv.size();
// printing is split, so remember
bool isPrintTest=false;
// getopt expects char*[].
char **pargv = new char* [sz+1] ;
for( int i=0 ; i < sz ; ++i )
pargv[i] = const_cast<char*>(argv[i].c_str());
while( (copt = opt.getopt(sz, pargv,
"f:p:t:v:<--cpu-time><--help><--post><--printTest>")) != -1 )
{
if( opt.longOption > 0 )
str0=opt.longOption;
if( opt.longOption && str0 == "--help" )
{
Base::help();
// CellStatistics::help();
FD_interface::help();
InFile::help();
// Oper::help();
// OutFile::help();
QA::help();
// TimeControl::help();
exit(1);
}
if( opt.longOption && str0 == "--cpu-time" )
{
isCPU_time=true;
continue;
}
if( opt.longOption && str0 == "--post" )
{
isPostProc=true;
continue;
}
if( opt.longOption && str0 == "--printTest" )
{
isPrintTest=true;
continue;
}
switch ( copt )
{
case 'f':
::NC_FILENAME = opt.optarg ;
break;
case 'p':
::NC_PATH = opt.optarg ;
break;
case 't':
::TABLE_PATH = opt.optarg ;
break;
default:
// description();
break;
}
}
// Note: pargv are pointers to argv items.
std::vector<std::string> aargv;
for( int i=opt.optind ; i < sz ; ++i)
aargv.push_back( pargv[i] );
argv = aargv ;
delete[] pargv ;
// parse argv for instructions of making objects
// and their linkage.
Parse parse(argv);
std::vector<std::vector<std::string> > linkList
= parse.getLinkList();
if( isPrintTest )
parse.printList(); // exits
// objects are created
makeObject(linkList, ioc);
// apply parameters to objects
setObjProperties(linkList, ioc);
linkObj(linkList, ioc);
scanGdRelation(linkList, ioc);
return ;
}
int main(int argc, char **argv) {
QCoreApplication a(argc, argv);
GetOpt opts;
QString alphabet;
opts.addOption('a', "alphabet", &alphabet);
if (!opts.parse())
return 1;
if (alphabet.isNull())
alphabet = "english";
Quackle::AlphabetParameters *alphas = 0;
QString alphabetFile = QString("../data/alphabets/%1.quackle_alphabet").arg(alphabet);
UVcout << "Using alphabet file: " << QuackleIO::Util::qstringToString(alphabetFile) << endl;
QuackleIO::FlexibleAlphabetParameters *flexure = new QuackleIO::FlexibleAlphabetParameters;
flexure->load(alphabetFile);
alphas = flexure;
QString leavesFilename = "superleaves.raw";
QFile file(leavesFilename);
if (!file.exists())
{
UVcout << "leaves file does not exist: " << QuackleIO::Util::qstringToString(leavesFilename) << endl;
return false;
}
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
{
UVcout << "Could not open " << QuackleIO::Util::qstringToString(leavesFilename) << endl;
return false;
}
QTextStream stream(&file);
stream.setCodec(QTextCodec::codecForName("UTF-8"));
ofstream out("encoded");
int encodableLeaves = 0;
int unencodableLeaves = 0;
while (!stream.atEnd()) {
QString leaveQString;
stream >> leaveQString;
double value;
stream >> value;
//UVcout << "value: " << value << endl;
UVString leaveString = QuackleIO::Util::qstringToString(leaveQString);
if (stream.atEnd())
break;
//UVcout << "read original string: " << originalString << endl;
UVString leftover;
Quackle::LetterString encodedLeave = alphas->encode(leaveString, &leftover);
if (leftover.empty())
{
unsigned char leavelength = encodedLeave.length();
out.write((char*)(&leavelength), 1);
out.write(encodedLeave.begin(), encodedLeave.length());
unsigned short int intvalue = (value + 128) * 256;
//UVcout << "intvalue: " << intvalue << endl;
out.write((char*)(&intvalue), 2);
++encodableLeaves;
}
else
{
//UVcout << "not encodable without leftover: " << originalString << endl;
++unencodableLeaves;
}
}
file.close();
delete alphas;
UVcout << "encodable leaves: " << encodableLeaves << ", unencodable leaves: " << unencodableLeaves << endl;
}
int MiniDawgMaker::executeFromArguments()
{
GetOpt opts;
QString alphabet;
opts.addOption('a', "alphabet", &alphabet);
if (!opts.parse())
return 1;
if (alphabet.isNull())
alphabet = "english";
Quackle::AlphabetParameters *alphas = 0;
QString alphabetFile = QString("../data/alphabets/%1.quackle_alphabet").arg(alphabet);
UVcout << "Using alphabet file: " << QuackleIO::Util::qstringToString(alphabetFile) << endl;
QuackleIO::FlexibleAlphabetParameters *flexure = new QuackleIO::FlexibleAlphabetParameters;
flexure->load(alphabetFile);
alphas = flexure;
root.t = false;
root.insmallerdict = false;
root.playability = 0;
root.c = QUACKLE_BLANK_MARK;
root.pointer = 0;
root.lastchild = true;
QString smallerDictFilename = "smaller.raw";
QFile smallerDict(smallerDictFilename);
if (!smallerDict.exists())
{
UVcout << "smaller dictionary does not exist: " << QuackleIO::Util::qstringToString(smallerDictFilename) << endl;
return false;
}
if (!smallerDict.open(QIODevice::ReadOnly | QIODevice::Text))
{
UVcout << "Could not open " << QuackleIO::Util::qstringToString(smallerDictFilename) << endl;
return false;
}
QTextStream smallerStream(&smallerDict);
smallerStream.setCodec(QTextCodec::codecForName("UTF-8"));
while (!smallerStream.atEnd())
{
QString originalQString;
smallerStream >> originalQString;
//UVcout << "this word is in the smaller dictionary: " << QuackleIO::Util::qstringToString(originalQString) << endl;
smallerMap[originalQString] = true;
}
QString playabilityFilename = "playabilities.raw";
QFile playability(playabilityFilename);
if (!playability.exists())
{
UVcout << "playability does not exist: " << QuackleIO::Util::qstringToString(playabilityFilename) << endl;
return false;
}
if (!playability.open(QIODevice::ReadOnly | QIODevice::Text))
{
UVcout << "Could not open " << QuackleIO::Util::qstringToString(playabilityFilename) << endl;
return false;
}
QTextStream playabilityStream(&playability);
playabilityStream.setCodec(QTextCodec::codecForName("UTF-8"));
while (!playabilityStream.atEnd())
{
int pb;
playabilityStream >> pb;
QString originalQString;
playabilityStream >> originalQString;
//UVcout << "playability: " << QuackleIO::Util::qstringToString(originalQString) << " " << pb << endl;
playabilityMap[originalQString] = pb;
}
QString dawgFilename = "dawginput.raw";
QFile file(dawgFilename);
if (!file.exists())
{
UVcout << "dawg does not exist: " << QuackleIO::Util::qstringToString(dawgFilename) << endl;
return false;
}
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
{
UVcout << "Could not open " << QuackleIO::Util::qstringToString(dawgFilename) << endl;
return false;
}
QTextStream stream(&file);
stream.setCodec(QTextCodec::codecForName("UTF-8"));
int encodableWords = 0;
int unencodableWords = 0;
while (!stream.atEnd())
{
QString originalQString;
stream >> originalQString;
bool inSmaller = smallerMap[originalQString];
int pb = playabilityMap[originalQString];
if (stream.atEnd())
break;
UVString originalString = QuackleIO::Util::qstringToString(originalQString);
//UVcout << "read original string: " << originalString;
//if (!inSmaller) UVcout << "#";
//UVcout << endl;
UVString leftover;
Quackle::LetterString encodedWord = alphas->encode(originalString, &leftover);
if (leftover.empty())
{
//for (Quackle::LetterString::iterator it = encodedWord.begin(); it != encodedWord.end(); ++it)
//UVcout << "got encoded letter: " << (int)(*it) << endl;
root.pushword(encodedWord, inSmaller, pb);
++encodableWords;
}
else
{
UVcout << "not encodable without leftover: " << originalString << endl;
++unencodableWords;
}
}
file.close();
delete alphas;
UVcout << "encodable words: " << encodableWords << ", unencodable words: " << unencodableWords << endl;
nodelist.push_back(&root);
root.print("");
UVcout << "nodelist.size(): " << nodelist.size() << endl;
minimize();
ofstream out("output.dawg", ios::out | ios::binary);
for (unsigned int i = 0; i < nodelist.size(); i++) {
//cout << nodelist[i]->c << " " << nodelist[i]->pointer << " " << nodelist[i]->t << " " << nodelist[i]->lastchild << endl;
Node* n = nodelist[i];
unsigned int p;
if (nodelist[i]->deleted)
{
p = (unsigned int)(nodelist[i]->cloneof->pointer);
// n = nodelist[i]->cloneof;
}
else
p = (unsigned int)(nodelist[i]->pointer);
char bytes[7];
unsigned char n1 = (p & 0x00FF0000) >> 16;
unsigned char n2 = (p & 0x0000FF00) >> 8;
unsigned char n3 = (p & 0x000000FF);
unsigned char n4 = n->c - QUACKLE_FIRST_LETTER;
unsigned int pb = n->playability;
unsigned char n5 = (pb & 0x00FF0000) >> 16;
unsigned char n6 = (pb & 0x0000FF00) >> 8;
unsigned char n7 = (pb & 0x000000FF);
if (n->t) {
n4 |= 32;
}
if (n->lastchild) {
n4 |= 64;
}
if (n->insmallerdict) {
n4 |= 128;
}
bytes[0] = n1; bytes[1] = n2; bytes[2] = n3; bytes[3] = n4;
bytes[4] = n5; bytes[5] = n6; bytes[6] = n7;
out.write(bytes, 7);
}
}
