static void Manual(const char *examples_dir)
{
for (;;)
{
char line[2048];
if (fgets(line, 2048, stdin) == NULL)
{
if (ferror(stdin))
{
fprintf(stderr, "Error during reading stdin. Bailing out.\n");
exit(1);
}
else
{
return;
}
}
if (strstr(line, EXAMPLE_INCLUDE_TOKEN))
{
char *filename = strstr(line, EXAMPLE_INCLUDE_TOKEN) + strlen(EXAMPLE_INCLUDE_TOKEN);
Chomp(filename);
IncludeExampleFile(examples_dir, filename);
}
else
{
fputs(line, stdout);
}
}
}
// converts a space separated quality string into a compressed quality string
// NOTE: this function has horrible amounts of overhead, but lean and mean code that I had before
// failed some of the unit tests.
void CRegexUtilities::ConvertQualities(string& qualities, CMosaikString& compQualities) {
string::iterator strIte = qualities.end() - 1;
while ( *strIte == ' ' ) {
qualities.erase( strIte );
strIte--;
}
vector<string> columns;
vector<string>::const_iterator sIter;
char* pQualities = (char*)qualities.c_str();
Chomp(pQualities);
back_insert_iterator<vector<string> > backiter(columns);
SplitString(backiter, " ", pQualities);
const unsigned int numQualities = (unsigned int)columns.size();
compQualities.Reserve(numQualities);
compQualities.SetLength(numQualities);
unsigned char* pCompQualities = (unsigned char*)compQualities.Data();
for(sIter = columns.begin(); sIter != columns.end(); ++sIter, ++pCompQualities) {
if(sIter->empty()) continue;
*pCompQualities = GetUnsignedChar((char*)sIter->c_str());
}
}
int main() {
wait_for_light(LIGHT_SENS);
//shake();
//startingT();
start();
shut_down_in(119);
Abyssal_Voyage();
Chomp();
now();
Acquired_Taste();
Devour();
Tougue_Lash();
Acquired_Taste();
//dance();
now();
}
int main(void)
{
CString *mystr;
char c;
mystr = Init_CString("Hello!");
printf("Init:\n str:%s len:%d\n", mystr->str, mystr->len);
c = Chomp(mystr);
printf("Chomp %c:\n str:%s len:%d\n", c, mystr->str, mystr->len);
mystr = Append_Chars_To_CString(mystr, " world!");
printf("Append:\n str:%s len:%d\n", mystr->str, mystr->len);
Delete_CString(mystr);
return 0;
}
std::string LoadTestUnits(TestUnitNode& node, std::istream& is, TestObserver* pObserver, int indent = 0)
{
static const std::regex re("(\\s*)([cCsS])(\\d+):(.+)");
std::string line;
std::getline(is, line);
while (is)
{
line = Chomp(line);
std::smatch sm;
if (!std::regex_match(line, sm, re))
{
if (line.empty() || line == "Test setup error: unknown type")
return "";
pObserver->test_message(Severity::Info, line);
std::getline(is, line);
continue;
}
if (sm[1].length() < indent)
return line;
unsigned id = GetArg<unsigned>(sm[3]);
TestUnit::Type type = GetTestUnitType(sm[2]);
std::string name = sm[4];
bool enable = GetTestUnitEnable(sm[2]);
node.children.push_back(TestUnit(id, type, normalize_type(name), enable));
if (type == TestUnit::TestSuite)
line = LoadTestUnits(node.children.back(), is, pObserver, sm[1].length() + 1);
else
std::getline(is, line);
}
return "";
}
int ParseLine(TCHAR *pszLine, CONFIG *pConfig)
{
int len;
int start;
TCHAR *pszToken;
int iToken;
Chomp(pszLine);
start = GetToken(0, pszLine, &len, &pszToken);
if (start == -1) // empty line or comment line
return 0;
iToken = LookupToken(pszToken);
free(pszToken);
switch (iToken)
{
case TOK_DLL_NAME:
return ParseConfigDLLName(pszLine+start+len, pConfig);
case TOK_PROCESS_NAME:
return ParseConfigProcessName(pszLine+start+len, pConfig);
case TOK_PID:
return ParseConfigPID(pszLine+start+len, pConfig);
case TOK_VERBOSE:
return ParseConfigVerbose(pszLine+start+len, pConfig);
case TOK_START:
return ParseConfigStart(pszLine+start+len, pConfig);
case TOK_WRITE:
return ParseConfigWrite(pszLine+start+len, pConfig);
case TOK_SEARCH_AND_WRITE:
return ParseConfigSearchAndWrite(pszLine+start+len, pConfig);
case TOK_PAUSE:
return ParseConfigPause(pszLine+start+len, pConfig);
case TOK_CONFIRM:
return ParseConfigConfirm(pszLine+start+len, pConfig);
case TOK_DUMP:
return ParseConfigDump(pszLine+start+len, pConfig);
case TOK_INJECT_DLL:
return ParseConfigInjectDLL(pszLine+start+len, pConfig);
case TOK_REJECT_DLL:
return ParseConfigRejectDLL(pszLine+start+len, pConfig);
case TOK_INFO:
return ParseConfigInfo(pszLine+start+len, pConfig);
case TOK_READONLY:
return ParseConfigReadOnly(pszLine+start+len, pConfig);
case TOK_SUSPEND:
return ParseConfigSuspend(pszLine+start+len, pConfig);
case TOK_RESUME:
return ParseConfigResume(pszLine+start+len, pConfig);
case TOK_PRINT:
return ParseConfigPrint(pszLine+start+len, pConfig);
case TOK_ADJUST_TOKE_PRIVILEGES:
return ParseConfigAdjustTokenPrivileges(pszLine+start+len, pConfig);
case TOK_STRINGS:
return ParseConfigStrings(pszLine+start+len, pConfig);
case TOK_DISABLE_CONSOLE_OUTPUT:
return ParseConfigDisableConsoleOutput(pszLine+start+len, pConfig);
case TOK_OUTPUT_TO_FILE:
return ParseConfigOutputToFile(pszLine+start+len, pConfig);
case TOK_PLUGIN:
return ParseConfigPlugin(pszLine+start+len, pConfig);
case TOK_REPEAT:
return ParseConfigRepeat(pszLine+start+len, pConfig);
case TOK_TEST_FUNCTION:
return ParseConfigTestFunction(pszLine+start+len, pConfig);
case TOK_INJECT_CODE:
return ParseConfigInjectCode(pszLine+start+len, pConfig);
}
return -1;
}
HRESULT Update(double deltaTime)
{
HRESULT hr = S_OK;
if (g_endgame)
return EndgameUpdate(deltaTime);
// TODO: Optimize for cache coherency
// We could attempt to store chains of nodes linearly in memory. That would make the update loop for nodes in those chains
// super fast (since the most chains could probably fit in one cache line). But it would involve a lot of mem moves and
// could introduce some complexity. Since we're already under 1ms average, I'd say let's not do it.
// Sort into buckets
BeginCounter(&binningCounter);
{
float pixelsPerVert = float((g_width * g_height) / g_numActiveNodes);
float binDiameterPixels = sqrt(pixelsPerVert); // conservative
g_binNHeight = binDiameterPixels / g_height;
g_binNWidth = binDiameterPixels / g_width;
g_binCountX = uint(ceilf(1.0f / g_binNWidth) )+2; // Add a boundary around the outside
g_binCountY = uint(ceilf(1.0f / g_binNHeight))+2;
uint xiter = g_binUpdateIter % g_numBinSplits;
uint yiter = g_binUpdateIter / g_numBinSplits;
g_binRangeX[0] = (g_binCountX * xiter/g_numBinSplits) - 1; // Subtract/Add 1 to each of these ranges for a buffer layer
g_binRangeX[1] = (g_binCountX * (xiter+1)/g_numBinSplits - 1) + 1; // This buffer layer will be overlap for each quadrant
g_binRangeY[0] = (g_binCountY * yiter/g_numBinSplits) - 1; // But without it verts would only target verts in their quadrant
g_binRangeY[1] = (g_binCountY * (yiter+1)/g_numBinSplits - 1) + 1;
g_binStride = g_numSlots / ((g_binRangeX[1] - g_binRangeX[0] + 1) * (g_binRangeY[1] - g_binRangeY[0] + 1));
int bin;
memset(g_slots, EMPTY_SLOT, sizeof(g_slots));
for (uint i = 0; i < g_numNodes; i++)
{
if (g_nodes[i].attribs.hasChild == true) continue; // Only bin the chompable tails
hr = Bin(g_nodes[i].position.getX(), g_nodes[i].position.getY(), &bin);
if (FAILED(hr)) // If this bin isn't backed by memory, we can't be a target this frame
continue;
// Find first empty bin slot
for (uint slot = 0; slot < g_binStride; slot++)
{
if (g_slots[bin*g_binStride + slot] == EMPTY_SLOT)
{
g_slots[bin*g_binStride + slot] = i;
break;
}
}
// If we overflow the bins, the vertex cannot be targeted. Haven't seen any cases yet...
}
g_binUpdateIter = (g_binUpdateIter+1) % (g_numBinSplits*g_numBinSplits);
}
EndCounter(&binningCounter);
// Determine nearest neighbors
BeginCounter(&nearestNeighborCounter);
for (uint i = 0; i < g_numNodes; i++)
{
IFC( FindNearestNeighbor(i) );
}
EndCounter(&nearestNeighborCounter);
BeginCounter(&positionUpdate);
for (uint i = 0; i < g_numNodes; i++)
{
// Do our memory reads here so we can optimize our access patterns
Node& current = g_nodes[i];
Node& target = g_nodes[current.attribs.targetID];
// Get target vector
// For optimal precision, pull our shorts into floats and do all math at full precision...
float2 targetVec;
targetVec.x = target.position.getX() - current.position.getX();
targetVec.y = target.position.getY() - current.position.getY();
float dist = targetVec.getLength();
float2 dir = targetVec;
if (dist != 0)
dir = dir / dist;
// Calculate change in position
float2 offset;
if (current.attribs.hasParent)
{
// This controls wigglyness. Perhaps it should be a function of velocity? (static is more wiggly)
float parentPaddingRadius = g_tailDist;// + (rand() * 2 - 1)*g_tailDist*0.3f;
offset = targetVec - dir * parentPaddingRadius;
}
else
offset = min(targetVec, dir * float(g_speed * deltaTime));
// ... then finally, at the verrrry end, stuff our FP floats into 16-bit shorts
current.position.setX(current.position.getX() + offset.x);
current.position.setY(current.position.getY() + offset.y);
// Check for chomps
if (current.attribs.hasParent == false && dist <= g_tailDist)
Chomp(i);
}
EndCounter(&positionUpdate);
Cleanup:
if (g_numActiveNodes == 1)
return EndgameInit();
return hr;
}
int Filter_numsI(int argc, char **argv)
{
char bufS[FILTBUF_SIZE+1], *cPC;
int ok,nok,prev_ok,b_line,line,outline,pout,extra;
FILTER *filtPO;
filtPO = CreateFilterPO();
if(!ParseArgsI(argc, argv,
"S -not B -stat B -rg D2 -gt D -lt D -col I -out S\
-seed I -ranf D -ranp D\
-rann I -sc I -flag B -icbn B\
-lrg I2 -wlis S -kc B -wst B -wsub B\
-pln B -A I -B I -qu B -vex B -all B -bof I -blk I\
-brg I2 -bnot B -blis S -maxout I -abs B -pfn B\
-pre S -suf S",
filtPO->inname, &filtPO->do_not, &filtPO->do_stat,
&filtPO->min,&filtPO->max, &filtPO->min, &filtPO->max,
&filtPO->col, filtPO->outname,
&filtPO->seed, &filtPO->ranf, &filtPO->ranp,
&filtPO->rann, &filtPO->skipc, &filtPO->do_flag,
&filtPO->do_icbn,
&filtPO->firstl,&filtPO->lastl, filtPO->wlisname,
&filtPO->do_kc, &filtPO->do_wst, &filtPO->do_wsub,
&filtPO->do_pln, &filtPO->do_A, &filtPO->do_B,
&filtPO->do_quiet, &filtPO->do_vex, &filtPO->do_all,
&filtPO->l_bof, &filtPO->l_blk, &filtPO->firstb,&filtPO->lastb,
&filtPO->do_bm_not, filtPO->blk_mlis, &filtPO->maxout,
&filtPO->do_abs, &filtPO->do_pfn,
filtPO->do_pre, filtPO->do_suf,
(int *)NULL))
{
Filter_numsUse();
CHECK_FILTER(filtPO);
return(FALSE);
}
/***
* Check options and set things up
*/
if(!OpenFilterFilesI(filtPO)) {
CHECK_FILTER(filtPO);
return(FALSE);
}
if(!CheckFilterOptionsI(filtPO)) {
CHECK_FILTER(filtPO);
return(FALSE);
}
/***
* Process lines
*/
line = outline = nok = extra = pout = 0;
prev_ok = TRUE;
while(fgets(bufS,FILTBUF_SIZE,filtPO->in) != NULL)
{
if( SkipThisLineI(filtPO, bufS) ) {
continue;
}
line++;
/***
* If start-of-block, calc and save flag
*/
b_line = LineInFiltBlockI(filtPO, line);
if( b_line == 1 ) {
cPC = GetLineStartPC(filtPO, bufS);
ok = IsFiltLineOkI(filtPO, line, cPC, TRUE);
prev_ok = ok;
}
/* Before blocks start */
else if ( b_line < 1 ) {
ok = FALSE;
}
/* In block, but not start; Use previous value, and possibly mask if ok */
else {
ok = prev_ok;
if(ok) {
ok = LineInBlockOkI(filtPO, b_line);
}
}
/* Count ok, and set for any -After extra */
if(ok) {
nok++;
if(filtPO->do_A > 0) {
extra = filtPO->do_A + 1;
}
}
/* Not only stats = per-line output */
if( !filtPO->do_stat) {
pout = FALSE;
if( (filtPO->do_flag) || (ok) || (extra>0) ) {
pout++;
outline++;
}
/* If maxout is set, unset print flag if too many lines */
if( (filtPO->maxout > 0) && (outline > filtPO->maxout) ) {
pout = FALSE;
}
if(pout) {
/***
* Any line prefixes?
*/
if(!NO_S(filtPO->do_pre)) {
fprintf(filtPO->out,"%s\t",filtPO->do_pre);
}
if(filtPO->do_pfn) {
fprintf(filtPO->out,"%s\t",filtPO->inname);
}
if(filtPO->do_pln) {
fprintf(filtPO->out,"%d\t",line);
}
if(filtPO->do_flag) {
fprintf(filtPO->out,"%d\t",ok);
}
/***
* Suffix? Need to strip newline first, else just dump
*/
if(!NO_S(filtPO->do_suf)) {
Chomp(bufS);
fprintf(filtPO->out,"%s\t%s\n",bufS, filtPO->do_suf);
}
else {
fputs(bufS,filtPO->out);
}
}
}
extra--;
}
ReportFilterStats(filtPO, line, nok);
CHECK_FILTER(filtPO);
return(TRUE);
}
