void wc(FILE *ofile, FILE *infile, char *inname) {
char *code;
int c;
size_t n = 0;
code = malloc(1000);
int char_count = 0;
int line_count = 0;
int word_count = 0;
char path[1024];
char result[1024];
int fd = fileno(ofile);
while ((c = fgetc(ofile)) != EOF)
{
code[n++] = (char) c;
}
code[n] = '\0';
char_count = count_characters(code);
line_count = count_lines(code);
word_count = count_words(code);
sprintf(path, "/proc/self/fd/%d",fd);
memset(result, 0, sizeof(result));
readlink(path, result, sizeof(result)-1);
printf(" %d\t%d\t%d\t%s\t%s\n", line_count, word_count, char_count, result, path);
}
uint32_t string_length(NewString *s)
{
if (s->length == -1)
{
s->length = count_characters(s->size, s->text);
}
return s->length;
}
int threads_test()
{
int cnt = 0;
int err;
pthread_t pid;
int likwid_pin = count_characters(getenv("LIKWID_PIN"), ',');
int max_cpus = sysconf(_SC_NPROCESSORS_CONF);
int max = likwid_pin;
if (likwid_pin == 0)
{
max = max_cpus;
}
while (cnt < max) {
err = pthread_create(&pid, NULL, dummy_function, NULL);
cnt++;
}
return cnt;
}
int main (int argc, char *argv[]) {
int char_count = 0;
int line_count = 0;
int word_count = 0;
if(argv[2])
{
if(access(argv[2],F_OK) != -1)
{
wc(fopen(argv[2], "r"),"","");
}
else
{
char_count = count_characters(argv[2]);
line_count = count_lines(argv[2]);
word_count = count_words(argv[2]);
printf(" %d\t%d\t%d\t%s\n", line_count, char_count, word_count, argv[2]);
}
}
else
{
printf("No argument passed");
}
return 0;
}
/**
* make_guess:
* @analyser: An analyser whose buffer is to be analysed.
*
* Finds encoding of @buffer and stores it in @analyser->result.
*
* Returns: Zero on success, nonzero error code when the encoding was not
* determined.
**/
static EncaErrno
make_guess(EncaAnalyserState *analyser)
{
const unsigned short int *const *const weights = analyser->lang->weights;
const unsigned short int *const significant = analyser->lang->significant;
size_t *const counts = analyser->counts;
size_t *const order = analyser->order;
double *const ratings = analyser->ratings;
const EncaAnalyserOptions *const options = &(analyser->options);
unsigned char *buffer = analyser->buffer;
size_t size = analyser->size;
static int ascii = ENCA_CS_UNKNOWN; /* ASCII charset id */
size_t fchars; /* characters filtered out */
size_t i, cs;
/* Initialize when we are called the first time. */
if (ascii == ENCA_CS_UNKNOWN) {
ascii = enca_name_to_charset("ascii");
assert(ascii != ENCA_CS_UNKNOWN);
}
/* Count characters. */
count_characters(analyser);
/* Pure ascii file (but may be qp-encoded!). */
if (!analyser->bin && !analyser->up) {
if (options->multibyte_enabled) {
if (try_test_list(analyser, ENCA_MULTIBYTE_TESTS_ASCII))
return 0;
}
if (options->interpreted_surfaces && looks_like_qp(analyser)) {
/* Quoted printables => recompute aliases and recount characters. */
buffer = analyser->buffer;
size = analyser->size;
count_characters(analyser);
}
if (!analyser->bin && !analyser->up) {
/* Plain ascii. */
analyser->result.charset = ascii;
analyser->result.surface |= enca_eol_surface(buffer, size,
analyser->counts);
return 0;
}
}
/* Binary encodings (binary noise is handled later). */
if (analyser->bin && options->multibyte_enabled) {
if (try_test_list(analyser, ENCA_MULTIBYTE_TESTS_BINARY))
return 0;
}
/* When interpreted surfaces are not allowed and sample contains binary data,
* we can give it up right here. */
if (!options->interpreted_surfaces && analyser->bin)
return ENCA_EGARBAGE;
/* Multibyte 8bit sample (utf-8), this has to be tested before
* filtering too -- no language independent multibyte encoding can be
* assumed to survive it. */
if (!analyser->bin && analyser->up && options->multibyte_enabled) {
if (try_test_list(analyser, ENCA_MULTIBYTE_TESTS_8BIT))
return 0;
}
/* Now it can still be a regular 8bit charset (w/ or w/o noise), language
* dependent MBCS (w/ or w/o noise), ascii w/ noise or just garbage. */
/* When the buffer must be treated as const and filters are enabled
* (and we didn't created a copy earlier), create a copy and store
* original into buffer2 */
if (options->const_buffer
&& options->filtering
&& analyser->buffer2 == NULL) {
analyser->buffer2 = buffer;
analyser->size2 = size;
analyser->buffer = memcpy(enca_malloc(size), buffer, size);
buffer = analyser->buffer;
}
/* Filter out blocks of binary data and box-drawing characters. */
fchars = 0;
if (options->filtering) {
if (analyser->bin) {
fchars = filter_binary(buffer, size, FILL_CHARACTER);
if (fchars)
analyser->result.surface |= ENCA_SURFACE_EOL_BIN;
}
fchars += enca_filter_boxdraw(analyser, FILL_CHARACTER);
}
/* At least something should remain after filtering. */
if (size - fchars < sqrt((double)size))
return ENCA_EFILTERED;
/* Detect surface. */
analyser->result.surface |= enca_eol_surface(buffer, size, counts);
/* When sample has been damaged by filters, recount characters. */
if (fchars) {
count_characters(analyser);
if (!analyser->up) {
analyser->result.charset = ascii;
/* FIXME: What if it's ASCII + box-drawing characters? */
analyser->result.surface |= ENCA_SURFACE_EOL_BIN;
return 0;
}
}
/* Check multibyte 8bit sample (utf-8) again.
* Chances are filtering helped it, even if it most probably destroyed it. */
if (analyser->up && options->multibyte_enabled) {
if (try_test_list(analyser, ENCA_MULTIBYTE_TESTS_8BIT_TOLERANT))
return 0;
}
/* When no regular charsets are present (i.e. language is `none')
* nothing of the following procedure has sense so just quit. */
if (analyser->ncharsets == 0)
return ENCA_ENOCS8;
/* How many significant characters we caught? */
if (!check_significant(analyser))
return ENCA_ESIGNIF;
/* Try pair analysis first. */
if (enca_pair_analyse(analyser))
return 0;
/* Regular, language dependent 8bit charsets.
*
* When w_rs is relative occurence of character s in charset r we multiply
* count[s] with factor (the sum in denominator is so-called significancy)
*
* w
* rs
* ----------------
* ___
* \
* eps + > w
* /___ rs
* r
*/
if (weights) {
for (cs = 0; cs < analyser->ncharsets; cs++) {
ratings[cs] = 0.0;
for (i = 0; i < 0x100; i++) {
ratings[cs] += weights[cs][i]/(significant[i] + EPSILON)*counts[i];
}
}
} else {
assert(analyser->lang->ratinghook);
analyser->lang->ratinghook(analyser);
}
/* Find winner and second best. */
enca_find_max_sec(analyser);
/* Run langauge specific hooks. */
if (analyser->ncharsets > 1 && analyser->lang->hook)
analyser->lang->hook(analyser);
/* Now we have found charset with the best relative ratings
but we need an absolute test to detect total garbage. */
if (options->test_garbageness && weights
&& test_garbage(analyser))
return ENCA_EGARBAGE;
/* Do we have a winner? */
if (analyser->ncharsets == 1) {
analyser->result.charset = analyser->charsets[order[0]];
return 0;
}
if (ratings[order[0]]/(ratings[order[1]] + EPSILON)
< options->threshold + EPSILON) {
/* Unfortunately no, but in ambiguous mode have the last chance. */
if (options->ambiguous_mode && weights)
return ambiguous_hook(analyser);
return ENCA_EWINNER;
}
analyser->result.charset = analyser->charsets[order[0]];
return 0;
}
counted_pair(const std::string& s1, const std::string& s2)
: name(s1 + " + " + s2)
{
count_characters(s1);
count_characters(s2);
}
