static boolean looksTabular(const struct vcfInfoDef *def, struct vcfInfoElement *el)
/* Return TRUE if def->description seems to contain a |-separated description of columns
* and el's first non-empty string value has the same number of |-separated parts. */
{
if (!def || def->type != vcfInfoString || isEmpty(def->description))
return FALSE;
if (regexMatch(def->description, COL_DESC_REGEX))
{
int descColCount = countChars(def->description, '|') + 1;
if (descColCount >= MIN_COLUMN_COUNT)
{
int j;
for (j = 0; j < el->count; j++)
{
char *val = el->values[j].datString;
if (isEmpty(val))
continue;
int elColCount = countChars(val, '|') + 1;
if (elColCount == descColCount)
return TRUE;
}
}
}
return FALSE;
}
void endBrace()
{
FILE *fp;
char *buffer;
buffer = "}";
fp = fopen("./c_code_temp.c", "a+");
printf("asd %d\n", countChars());
ftruncate(fileno(fp), countChars() - 5);
fprintf(fp, "%s\n", buffer);
fclose(fp);
}
int countColumns(struct slName *list, char *formatType)
/* Return number of columns. */
{
int count = 0;
char *line = list->name;
if (sameString(formatType, cgfFormatTab))
count = countChars(line, '\t') + 1;
else if (sameString(formatType, cgfFormatComma))
count = countChars(line, ',') + 1;
else if (sameString(formatType, cgfFormatSpace))
count = chopByWhite(line, NULL, 0);
else
internalErr();
return count;
}
char *replace(char *input, char *what, char *with)
{
char *out, *tmp, *str, *save, *token;
int num = 0, size = 0;
if ((what == NULL) || (strlen(what) == 0))
return input;
num = countChars((const char *)input, what[0]);
size = (strlen(input) + num + 1);
out = (char *)malloc( size * sizeof(char) );
memset(out, 0, size);
tmp = strdup( (char *)input );
for (str = tmp; ; str = NULL) {
token = strtok_r(str, what, &save);
if (token == NULL)
break;
strcat(out, token);
strcat(out, with);
}
out[ size - 1 ] = 0;
return out;
}
struct bed *loadBedFileWithHeader(char *fileName)
/* Read in a bed file into a bed list, dealing with header for custom track if necessary. */
{
struct bed *bedList = NULL, *bed = NULL;
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *row[12];
int lineSize;
char *line;
/* Skip the headers. */
while(lineFileNext(lf, &line, &lineSize))
{
if(countChars(line, '\t') > 10)
{
lineFileReuse(lf);
break;
}
}
/* Load in the records. */
while(lineFileRow(lf, row))
{
bed = bedLoad12(row);
slAddHead(&bedList, bed);
}
lineFileClose(&lf);
slReverse(&bedList);
return bedList;
}
boolean anyCdnaSeq(char *name, struct dnaSeq **retDna, struct wormCdnaInfo *retInfo)
/* Get a single cDNA sequence. Optionally (if retInfo is non-null) get additional
* info about the sequence. */
{
static FILE *cdnaFa;
static struct snof *cdnaSnof = NULL;
long offset;
char *faComment;
char **pFaComment = (retInfo == NULL ? NULL : &faComment);
if (cdnaSnof == NULL)
{
char buf[512];
cdnaSnof = snofMustOpen(cdnaName);
sprintf(buf, "%s%s", cdnaName, ".fa");
cdnaFa = mustOpen(buf, "rb");
}
if (!snofFindOffset(cdnaSnof, name, &offset))
return FALSE;
fseek(cdnaFa, offset, SEEK_SET);
if (!faReadNext(cdnaFa, name, TRUE, pFaComment, retDna))
return FALSE;
if (retInfo != NULL)
{
/* Kludge - only look up info if format is more or less right. */
int fieldCount = countChars(faComment, '|');
if (fieldCount >= 8)
wormFaCommentIntoInfo(faComment, retInfo);
else
zeroBytes(retInfo, sizeof(*retInfo));
}
return TRUE;
}
int main(){
std::cout << '\n' << getCustomString() << '\n';
std::cout << countChars("This is a sentence", 't') << '\n';
std::cout << countCharsCustom('f') << '\n';
return 0;
}
void writeCode(char *command)
{
FILE *fp;
static bool firstWrite = true;
char *buffer;
fp = fopen("./c_code_temp.c", "a+");
ftruncate(fileno(fp), countChars() - 2);
if (firstWrite == true)
{
buffer = "int main(void) {";
}
if (firstWrite == true)
{
fprintf(fp, "%s\n", buffer);
firstWrite = false;
}
fprintf(fp, "%s\n", command);
fprintf(fp, "}\n");
fclose(fp);
}
struct tabRow *tabRowByChar(struct slName *lineList, char c, char *fileName,
boolean varCol)
/* Convert lines to rows based on character separation. If varCol is TRUE then not
* all rows need to have same number of columns. */
{
struct slName *line;
struct tabRow *rowList = NULL, *row;
if (varCol)
{
for (line = lineList; line != NULL; line = line->next)
{
char *s = line->name;
int rowSize = countChars(s, c) + 1;
row = tabRowNew(rowSize);
chopByChar(s, c, row->columns, rowSize);
slAddHead(&rowList, row);
}
}
else
{
if (lineList)
{
int rowSize = countChars(lineList->name, c) + 1;
int extraSize = rowSize+1;
int ix = 1;
for (line = lineList; line != NULL; line = line->next, ++ix)
{
int oneSize;
row = tabRowNew(rowSize);
oneSize = chopByChar(line->name, c, row->columns, extraSize);
if (oneSize != rowSize)
{
if (oneSize > rowSize)
errAbort("Got more than the expected %d columns line %d of %s",
rowSize, ix, fileName);
else
errAbort("Expecting %d columns got %d, line %d of %s",
rowSize, oneSize, ix, fileName);
}
slAddHead(&rowList, row);
}
}
}
return rowList;
}
static int bigWarnNumLines(char *errMsg)
/* Count number of lines in err msg */
{
int n = countChars(errMsg, '\n');
int sl = strlen(errMsg);
if ((sl > 0) && (errMsg[sl-1]!='\n'))
++n;
return n;
}
char *makeEscapedString(char *in, char toEscape)
/* Return string that is a copy of in, but with all
* toEscape characters preceded by '\'
* When done freeMem result. */
{
int newSize = strlen(in) + countChars(in, toEscape);
char *out = needMem(newSize+1);
escCopy(in, out, toEscape, '\\');
return out;
}
char *makeQuotedString(char *in, char quoteChar)
/* Create a string surrounded by quoteChar, with internal
* quoteChars escaped. freeMem result when done. */
{
int newSize = 2 + strlen(in) + countChars(in, quoteChar);
char *out = needMem(newSize+1);
out[0] = quoteChar;
escCopy(in, out+1, quoteChar, '\\');
out[newSize-1] = quoteChar;
return out;
}
static boolean isGtfGroup(char *group)
/* Return TRUE if group field looks like GTF */
{
if (strstr(group, "gene_id") == NULL)
return FALSE;
if (countChars(group, '"') >= 2)
return TRUE;
if (strstr(group, "transcript_id") != NULL)
return TRUE;
return FALSE;
}
struct mafComp *mafCompFakeFromAliSym(struct dnaSeq *seq)
/* Fake up a mafComp from a dnaSeq with dashes. */
{
struct mafComp *mc;
AllocVar(mc);
mc->src = cloneString(seq->name);
mc->srcSize = mc->size = seq->size - countChars(seq->dna, '-');
mc->strand = '+';
mc->start = 0;
mc->text = cloneString(seq->dna);
return mc;
}
int commaSepCount(char *s)
/* Count number of comma-separated items assuming there can be a terminal non-separating comma
* or not. */
{
if (isEmpty(s))
return 0;
int commaCount = countChars(s, ',');
int sepCount = commaCount;
char lastC = lastChar(s);
if (lastC == ',')
--sepCount;
return sepCount + 1;
}
struct hash *hashPsls(char *pslFileName)
{
struct psl *pslList = NULL, *psl = NULL, *pslSubList = NULL, *pslNext = NULL;
struct hash *pslHash = newHash(15);
char *last = NULL;
char key[128];
char *tmp = NULL;
pslList = pslLoadAll(pslFileName);
/* Fix psl names */
for(psl = pslList; psl != NULL; psl = psl->next)
{
tmp = strrchr(psl->qName, ';');
*tmp = '\0';
tmp = strstr(psl->qName,prefix);
assert(tmp);
/* checks if there are 2 occurrences of ":" in probe name as in full name */
/* if probe name is shortened to fit in the seq table, there is only 1 ":"*/
/* e.g. full: consensus:HG-U133A:212933_x_at; short:HG-U133A:212933_x_at;*/
if (countChars(psl->qName, *prefix) == 2)
{
tmp = strstr(tmp+1,prefix);
assert(tmp);
}
tmp = tmp + strlen(prefix);
safef(psl->qName, strlen(psl->qName), "%s", tmp);
}
/* Sort based on query name. */
slSort(&pslList, pslCmpQuery);
/* For each psl, if it is has the same query name add it to the
sublist. Otherwise store the sublist in the hash and start
another. */
for(psl = pslList; psl != NULL; psl = pslNext)
{
pslNext = psl->next;
if(last != NULL && differentWord(last, psl->qName))
{
hashAddUnique(pslHash, last, pslSubList);
pslSubList = NULL;
}
slAddTail(&pslSubList, psl);
last = psl->qName;
}
/* Add the last sublist */
hashAddUnique(pslHash, last, pslSubList);
return pslHash;
}
int main(){
char str[TAM];
int n;
printf("Introduza a string(max %d car.):", TAM);
gets(str);
n=countChars(str);
printf("\nA string tem %d caracteres.", n);
printInvertString(str, n);
return 0;
}
void InducedSorting::WorkingClass::_setUpBaskets() {
_baskets.resize(_alpSize);
//calc basket size
vector <size_t> countChars(_alpSize, 0);
for(size_t i = 0;i < _str.size(); ++i) {
++countChars[_str[i]];
}
//set up basket size
for(size_t i = 0;i < _alpSize; ++i) {
_baskets[i].resize(countChars[i], SIZE_T_MAX);
}
}
void checkFaOutput(struct htmlPage *page, int expectedCount, boolean lessOk)
/* Check that page contains expected number of sequences. If lessOk is set
* (needed to handle some multiply mapped cases in refSeq) then just check
* that have at least one if expecting any. */
{
if (page != NULL)
{
int count = countChars(page->htmlText, '>');
if (count != expectedCount)
{
if (!lessOk || count > expectedCount || (expectedCount > 0 && count <= 0))
qaStatusSoftError(tablesTestList->status,
"Got %d sequences, expected %d", count, expectedCount);
}
}
}
static void parseFilterColumn(struct vcfFile *vcff, struct vcfRecord *record, char *filterStr)
/* Transform ;-separated filter codes into count + string array. */
{
// We don't want to modify something allocated with vcfFilePooledStr because that uses
// hash element names for storage! So don't make a vcfFilePooledStr copy of filterStr and
// chop that; instead, chop a temp string and pool the words separately.
static struct dyString *tmp = NULL;
if (tmp == NULL)
tmp = dyStringNew(0);
dyStringClear(tmp);
dyStringAppend(tmp, filterStr);
record->filterCount = countChars(filterStr, ';') + 1;
record->filters = vcfFileAlloc(vcff, record->filterCount * sizeof(char **));
(void)chopByChar(tmp->string, ';', record->filters, record->filterCount);
int i;
for (i = 0; i < record->filterCount; i++)
record->filters[i] = vcfFilePooledStr(vcff, record->filters[i]);
}
int main(int argc, char **argv) {
int* freq = countChars(data, (int)strlen(data));
#ifdef DEBUG_MODE
printInputCharTable(freq);
puts("");
#endif
nodeStructure** nodePointers = getFirstNodePointers(freq);
int len =pointerCounter(nodePointers);
#ifdef DEBUG_MODE
printf("\nTotal: %d.\n\n", len);
#endif
nodeStructure *rootNode = makeTree(nodePointers, len);
#ifdef DEBUG_MODE
printf("\nrooot %p found.\n", rootNode);
#endif
#ifdef DEBUG_MODE
// puts("\nnow backwards...\n");
// drawTree(rootNode);
// puts("\n\ncodes:\n");
// printCodes(rootNode);
#endif
puts("\ncodes:\n");
makeCodes(rootNode, 0);
// for(int i = 0; printf("%s\n", (char*)codes[i]), i < 0x100; i++); // it works! 😱
puts("");
printf("%s - %lu bytes\n", data, strlen(data));
bitStreamOut((int)strlen(data), data);
puts("");
return 0;
}
char *expandRelativePath(char *baseDir, char *relPath)
/* Expand relative path to more absolute one. */
{
char *e = baseDir + strlen(baseDir);
int slashCount;
char *rel = relPath;
char *result;
int size, baseSize;
undosPath(baseDir);
undosPath(relPath);
slashCount = countChars(baseDir, '/');
if (baseDir[0] == 0)
slashCount = -1;
while (startsWith("../", rel))
{
if (slashCount < 0)
{
warn("More ..'s in \"%s\" than directories in \"%s\"", relPath, baseDir);
return NULL;
}
else if (slashCount == 0)
e = baseDir;
else
e = findSlashBefore(baseDir, e);
slashCount -= 1;
rel += 3;
}
baseSize = e - baseDir;
size = strlen(rel) + 1;
if (baseSize > 0)
size += baseSize + 1;
if (baseSize > 0)
{
result = needMem(size);
memcpy(result, baseDir, baseSize);
result[baseSize] = '/';
strcpy(result + baseSize + 1, rel);
}
else
result = cloneString(rel);
return result;
}
struct variant *variantFromVcfAnnoRow(struct annoRow *row, char *refAllele, struct lm *lm,
struct dyString *dyScratch)
/* Translate vcf array of words into variant (allocated by lm, overwriting dyScratch
* as temporary scratch string). */
{
char **words = row->data;
char *alStr = vcfGetSlashSepAllelesFromWords(words, dyScratch);
// The reference allele is the first allele in alStr -- and it may be trimmed on both ends with
// respect to the raw VCF ref allele in words[3], so copy vcfRefAllele back out of alStr.
// That ensures that variantNew will get the reference allele that matches the slash-separated
// allele string.
int refLen = strlen(alStr);
char *p = strchr(alStr, '/');
if (p)
refLen = p - alStr;
char vcfRefAllele[refLen + 1];
safencpy(vcfRefAllele, sizeof(vcfRefAllele), alStr, refLen);
unsigned alCount = countChars(alStr, '/') + 1;
return variantNew(row->chrom, row->start, row->end, alCount, alStr, vcfRefAllele, lm);
}
YakMessage* createNamesMessage(char** names, int namesCount) {
YakMessage* msg = (YakMessage*)malloc(sizeof(YakMessage));
int size = countChars(names, namesCount);
msg->header.type = NAMES;
msg->header.version = YAK_VERSION;
msg->header.dataSize = size * (sizeof(char) + sizeof(int));
msg->data = malloc(msg->header.dataSize);
int index = 0;
for(int i=0; i<namesCount; i++) {
int len = strlen(names[i]);
msg->data[index++] = (BYTE)len;
copyStringToData(index, names[i], msg);
index += len;
}
return msg;
}
int main()
{
int sum = 0;
for (int n = 1; n <= 1000; n++) {
#if 0
int ones = n/ 1 % 10;
int tens = n/ 10 % 10;
int hundreds = n/ 100 % 10;
int thousands = n/1000 % 10;
std::cout << n << "\n";
std::cout << "ones: " << ones << "\n";
std::cout << "tens: " << tens << "\n";
std::cout << "hundreds: " << hundreds << "\n";
std::cout << "thousands: " << thousands << "\n";
#endif
std::string result = toString(n);
int length = countChars(result);
sum += length;
std::cout << n << " " << length << " " << sum << ": " << result << "\n";
}
}
char * projectString(char *s, char *ref, char refChar, char insertChar)
/* Insert 'insertChar' in 's' at every position 'ref' has 'refChar'. */
{
int i,j,size = strlen(ref);
char *copy = (char *) needMem(size + 1);
if (strlen(s) != strlen(ref) - countChars(ref, refChar))
errAbort("ERROR from rnautil::projectString: Input string 's' has wrong length.\n");
for (i = 0, j = 0; i < size; i++)
{
if (ref[i] == refChar)
copy[i] = insertChar;
else
{
copy[i] = s[j];
j++;
}
}
return copy;
}
static int delimitedTableSize(struct slName *list, int colDelim)
/* Return number of columns in list delimited by delimiter. Returns
* 0 if count is inconsistent. */
{
struct slName *el;
int expected = 0;
for (el = list; el != NULL; el = el->next)
{
int count = countChars(el->name, colDelim) + 1;
if (expected == 0)
{
expected = count;
}
else
{
if (expected != count)
return 0;
}
}
return expected;
}
void verifyJoinedFormat(char *s)
/* Verify that s consists of lines with two tab-separated fields,
* and that the second field has some n/a and some comma-separated lists. */
{
char *e;
int lineIx = 0;
boolean gotCommas = FALSE, gotNa = FALSE;
while (s != NULL && s[0] != 0)
{
char *row[3];
int fieldCount;
++lineIx;
e = strchr(s, '\n');
if (e != NULL)
*e++ = 0;
if (s[0] != '#')
{
fieldCount = chopTabs(s, row);
if (fieldCount != 2)
{
qaStatusSoftError(tablesTestList->status,
"Got %d fields line %d of joined result, expected 2",
fieldCount, lineIx);
break;
}
if (sameString(row[1], "n/a"))
gotNa = TRUE;
if (countChars(s, ',') >= 2)
gotCommas = TRUE;
}
s = e;
}
if (!gotCommas)
qaStatusSoftError(tablesTestList->status,
"Expected some rows in join to have comma separated lists.");
if (!gotNa)
qaStatusSoftError(tablesTestList->status,
"Expected some rows in joint to have n/a.");
}
/**
* Encodes a set of data with DC's version of huffman encoding..
* @todo Use real streams maybe? or something else than string (operator[] contains a compare, slow...)
*/
void CryptoManager::encodeHuffman(const string& is, string& os) {
// We might as well expect this much data as huffman encoding doesn't go very far...
os.reserve(is.size());
if(is.length() == 0) {
os.append("HE3\x0d");
// Nada...
os.append(7, '\0');
return;
}
// First, we count all characters
u_int8_t csum = 0;
int count[256];
memset(count, 0, sizeof(count));
int chars = countChars(is, count, csum);
// Next, we create a set of nodes and add it to a list, removing all characters that never occur.
list<Node*> nodes;
int i;
for(i=0; i<256; i++) {
if(count[i] > 0) {
nodes.push_back(new Node(i, count[i]));
}
}
nodes.sort(greaterNode());
#ifdef _DEBUG
for(list<Node*>::iterator it = nodes.begin(); it != nodes.end(); ++it) dcdebug("%.02x:%d, ", (*it)->chr, (*it)->weight);
dcdebug("\n");
#endif
walkTree(nodes);
dcassert(nodes.size() == 1);
Node* root = nodes.front();
vector<u_int8_t> lookup[256];
// Build a lookup table for fast character lookups
buildLookup(lookup, root);
delete root;
// Reserve some memory to avoid all those copies when appending...
os.reserve(is.size() * 3 / 4);
os.append("HE3\x0d");
// Checksum
os.append(1, csum);
string::size_type sz = is.size();
os.append((char*)&sz, 4);
// Character count
os.append((char*)&chars, 2);
// The characters and their bitlengths
for(i=0; i<256; i++) {
if(count[i] > 0) {
os.append(1, (u_int8_t)i);
os.append(1, (u_int8_t)lookup[i].size());
}
}
BitOutputStream bos(os);
// The tree itself, ie the bits of each character
for(i=0; i<256; i++) {
if(count[i] > 0) {
bos.put(lookup[i]);
}
}
dcdebug("u_int8_ts: %d\n", os.size());
bos.skipToByte();
for(string::size_type j=0; j<is.size(); j++) {
dcassert(lookup[(u_int8_t)is[j]].size() != 0);
bos.put(lookup[(u_int8_t)is[j]]);
}
bos.skipToByte();
}
void spDbAddVarSplice(char *database, char *inFile, char *outDir)
/* spDbAddVarSplice - This adds information on the varient splices to the sp/uniProt database. */
{
struct sqlConnection *conn = sqlConnect(database);
char query[256];
makeDir(outDir);
FILE *varProtein = openToWrite(outDir, "varProtein.txt");
FILE *varAcc = openToWrite(outDir, "varAcc.txt");
FILE *varDisplayId = openToWrite(outDir, "varDisplayId.txt");
FILE *varAccToTaxon = openToWrite(outDir, "varAccToTaxon.txt");
FILE *varDescription = openToWrite(outDir, "varDescription.txt");
FILE *varGene = openToWrite(outDir, "varGene.txt");
FILE *varGeneLogic = openToWrite(outDir, "varGeneLogic.txt");
struct lineFile *lf = lineFileOpen(inFile, TRUE);
aaSeq seq;
ZeroVar(&seq);
while (faPepSpeedReadNext(lf, &seq.dna, &seq.size, &seq.name))
{
char *row[4];
char *name = seq.name;
if (startsWith("sp|", name)) // Skip over sp| introduced Aug 2009
name += 3;
int rowSize = chopString(name, "-|", row, ArraySize(row));
if (rowSize != 3)
errAbort("Expecting name to be in format accession-N|DISP_ID, got %s\n", name);
char *acc = row[0];
char *version = row[1];
char *displayId = row[2];
int accLen = strlen(acc);
int verLen = strlen(version);
int displayIdLen = strlen(displayId);
/* Do some tests. */
if ((accLen != 6 && accLen != 10) || isdigit(acc[0]) || !isdigit(acc[accLen-1]))
errAbort("wierd accession %s before line %d of %s", acc, lf->lineIx, lf->fileName);
if (!isdigit(version[0]) || verLen > 4)
errAbort("wierd version %s before line %d of %s", version, lf->lineIx, lf->fileName);
if (countChars(displayId, '_') != 1 || displayIdLen < 6 || displayIdLen > 16)
errAbort("wierd displayId %s before line %d of %s", displayId, lf->lineIx, lf->fileName);
if (accLen + 1 + verLen >= sizeof(SpAcc))
errAbort("Need to increase size of SpAcc in spDb.h because of %s-%s - need %d characters but only have %lu", acc, version, accLen + 1 + verLen, sizeof(SpAcc));
/* Print out parsed results. */
fprintf(varAcc, "%s-%s\t%s\t%s\n", acc, version, acc, version);
fprintf(varProtein, "%s-%s\t%s\n", acc, version, seq.dna);
fprintf(varDisplayId, "%s-%s\t%s-%s\n", acc, version, acc, version);
/* Look up taxon of base protein and use it to write to varAccToTaxon table. */
int taxon = spTaxon(conn, acc);
fprintf(varAccToTaxon, "%s-%s\t%d\n", acc, version, taxon);
/*Transfer description. */
char *description = spDescription(conn, acc);
fprintf(varDescription, "%s-%s\t%s\n", acc, version, description);
freez(&description);
/* Transfer gene logic. */
sqlSafef(query, sizeof(query), "select val from geneLogic where acc = '%s'", acc);
char *geneLogic = sqlQuickString(conn, query);
if (geneLogic != NULL)
fprintf(varGeneLogic, "%s-%s\t%s\n", acc, version, geneLogic);
freez(&geneLogic);
/* Transfer genes. */
struct slName *gene, *geneList = spGenes(conn, acc);
for (gene = geneList; gene != NULL; gene = gene->next)
fprintf(varGene, "%s-%s\t%s\n", acc, version, gene->name);
slFreeList(&geneList);
}
carefulClose(&varAcc);
carefulClose(&varProtein);
carefulClose(&varDisplayId);
carefulClose(&varAccToTaxon);
carefulClose(&varDescription);
carefulClose(&varGene);
carefulClose(&varGeneLogic);
sqlDisconnect(&conn);
}
