static void
test_locale (void)
{
int i;
char *s = NULL;
mpfr_t x;
double y;
int count;
for(i = 0; i < numberof(tab_locale) && s == NULL; i++)
s = setlocale (LC_ALL, tab_locale[i]);
if (s == NULL || MPFR_THOUSANDS_SEPARATOR != ',')
return;
mpfr_init2 (x, 113);
mpfr_set_ui (x, 10000, MPFR_RNDN);
y = 100000;
count = mpfr_printf ("(1) 10000=%'Rg 100000=%'g \n", x, y);
check_length (10000, count, 33, d);
count = mpfr_printf ("(2) 10000=%'Rf 100000=%'f \n", x, y);
check_length (10001, count, 47, d);
mpfr_clear (x);
}
int get_prompt(unsigned int *xGuess, unsigned int *yGuess)
{
char line[BUFF_LEN]; /* Line buffer */
char c; /* Temporary for checking single characters */
fgets(line, BUFF_LEN, stdin);
/* NOTE: This will return -1 is EOF */
if(check_length(line) == 0) {
return -1;
/* NOE: This will return 1 if line is > 20 characters */
} else if(check_length(line) == -1) {
/* flush the buffer before continuing */
while((c = getchar()) != '\n') {
/* If there's no new line, get out now! */
if(c==EOF) {
return -1;
}
}
return 1;
}
if(read_two_uints(line, xGuess, yGuess)) {
return 1;
}
return 0;
}
/* Parse Functions */
int parse_rules(FILE *rules, Ship *ships, Grid *board,
unsigned int *numShips)
{
char line[BUFF_LEN]; /* Line buffers */
int i;
/* First line should be two positive integers */
fgets(line, BUFF_LEN, rules);
if(read_two_uints(line, &board->width, &board->height)) {
return rules_invalid();
}
if(board->width <= 0 || board->height <= 0) {
return rules_invalid();
}
/* Second line should be a positive integer representing
* the total number of ships */
fgets(line, BUFF_LEN, rules);
if(!check_length(line)) {
return rules_invalid();
}
if(sscanf(line, "%u", numShips) != 1) {
return rules_invalid();
}
if(*numShips <= 0) {
return rules_invalid();
}
/* Limit size of numShips */
if(*numShips > MAX_SHIPS) {
return rules_invalid();
}
/* All other lines should be a single positive integer */
/* Also, we expect there to be the same number of ships described
* here as defined by the second line of the rules file and saved
* to numShips */
for(i = 0; i < *numShips; i++) {
/* Check if we reached EOF prematurely */
if(fgets(line, BUFF_LEN, rules) == NULL) {
return rules_invalid();
}
/* The line should be < BUFF_LEN */
if(!check_length(line)) {
return rules_invalid();
}
if(sscanf(line, "%u", &ships[i].length) != 1) {
return rules_invalid();
}
if(ships[i].length < 1) {
return rules_invalid();
}
}
return 0;
}
/* http://bugzilla.gnome.org/show_bug.cgi?id=165887 */
void
test_group_remove (void)
{
gchar **names;
gsize len;
GError *error = NULL;
const gchar *data =
"[group1]\n"
"[group2]\n"
"key1=bla\n"
"key2=bla\n"
"[group3]\n"
"key1=bla\n"
"key2=bla\n";
cut_assert (g_key_file_load_from_data (keyfile, data, -1, 0, NULL));
names = g_key_file_get_groups (keyfile, &len);
cut_assert (names);
check_length ("groups", g_strv_length (names), len, 3);
check_name ("group name", names[0], "group1", 0);
check_name ("group name", names[1], "group2", 1);
check_name ("group name", names[2], "group3", 2);
g_key_file_remove_group (keyfile, "group1", &error);
check_no_error (error);
g_strfreev (names);
names = g_key_file_get_groups (keyfile, &len);
cut_assert (names);
check_length ("groups", g_strv_length (names), len, 2);
check_name ("group name", names[0], "group2", 0);
check_name ("group name", names[1], "group3", 1);
g_key_file_remove_group (keyfile, "group2", &error);
check_no_error (error);
g_strfreev (names);
names = g_key_file_get_groups (keyfile, &len);
cut_assert (names);
check_length ("groups", g_strv_length (names), len, 1);
check_name ("group name", names[0], "group3", 0);
g_key_file_remove_group (keyfile, "no such group", &error);
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
g_strfreev (names);
}
int main()
{
//Variables
char input[256];
bool palin;
//Process
while(strcmp(input, "end"))
{
//get some input
printf("Please enter a word to PalinCheck: ");
scanf("%s", input);
//can't assign with spaces so check 6-P2 copy for solution
*input = "gay afasdfsd sfsd fs";
//testing remove spaces
printf("%s\n", input);
remove_spaces(input, check_length(input));
printf("%s \n", input);
//process depending on odd or even characters
int l;
if(check_length(input) % 2 == 0) //even
{
l = check_length(input);
}
else //odd - needs fixing
{
l = check_length(input) - 1;
}
for(int i = 0;i<l/2;i++)
{
char a, b;
a = input[i];
b = input[l-(i+1)];
if(a != b)
{
palin = false;
break;
}
else{ palin = true; }
}
if(palin)
{
printf("Palindrome\n");
}
else if (!palin)
{
printf("Not palindrome\n");
}
}
}
int
pr_SNameToId(prname name, afs_int32 *id)
{
namelist lnames;
idlist lids;
afs_int32 code;
code = check_length(name);
if (code)
return code;
lids.idlist_len = 0;
lids.idlist_val = 0;
lnames.namelist_len = 1;
lnames.namelist_val = malloc(PR_MAXNAMELEN);
stolower(name);
strncpy(lnames.namelist_val[0], name, PR_MAXNAMELEN);
code = ubik_PR_NameToID(pruclient, 0, &lnames, &lids);
if (lids.idlist_val) {
*id = *lids.idlist_val;
xdr_free((xdrproc_t) xdr_idlist, &lids);
} else if (code == 0) {
code = PRINTERNAL;
}
if (lnames.namelist_val)
free(lnames.namelist_val);
return code;
}
void vector_add(vector* vec, void* data, size_t n){
check_length(vec);
vec->data[vec->length] = malloc(n);
vec->sizes[vec->length] = n;
memcpy(vec->data[vec->length], data, n);
vec->length++;
}
int
pr_ListMembers(prname group, namelist *lnames)
{
afs_int32 code;
afs_int32 gid;
int i;
memset(lnames, 0, sizeof(namelist));
/* pr_SNameToId checks the length of group. */
code = pr_SNameToId(group, &gid);
if (code)
return code;
if (gid == ANONYMOUSID)
return PRNOENT;
code = pr_IDListMembers(gid, lnames);
if (code)
return code;
for (i = 0; i < lnames->namelist_len; i++) {
code = check_length(lnames->namelist_val[i]);
if (code)
return code;
}
return code;
}
int dispvar(char **format, va_list ap)
{
int wr;
t_args *arg;
wr = 0;
arg = (t_args*)malloc(sizeof(t_args));
*format += 1;
if (**format != 0)
{
init_arg(&arg);
while (is_flag(**format))
{
check_flags(format, &arg);
check_field(format, &arg, ap);
check_prec(format, &arg, ap);
check_length(format, &arg);
}
wr += print_char(format, &arg, ap);
wr += print_hexa(format, &arg, ap);
wr += print_decimal(format, &arg, ap);
wr += print_octal(format, &arg, ap);
}
free(arg);
return (wr);
}
int ft_printf(const char *format, ...)
{
va_list args;
t_env *env;
va_start(args, format);
env = init_env();
while (format[env->i])
{
if (format[env->i] == '%' && env->flag == 0)
init_flags(env);
if (env->flag == 1 && check_flag(format[env->i]) != 0)
add_flag(env, format[env->i], env->i);
else if (ft_isdigit(format[env->i]) == 1 && env->flag == 1)
env->i = get_width(format, env->i, env);
else if (format[env->i] == '.'
&& env->flag == 1 && ft_isdigit(format[++(env->i)]) == 1)
env->i = get_precision(format, env->i, env);
else if (env->flag == 1 && check_length(format[env->i]) != 0)
add_length(env, format, &(env->i));
else if (env->flag == 1 && check_specifier(format[env->i]) != 0)
process(args, env, format[env->i]);
else
env->size += ft_putchar(format[env->i]);
env->i++;
}
return (env->size);
}
afs_int32
pr_ListEntries(int flag, afs_int32 startindex, afs_int32 *nentries, struct prlistentries **entries, afs_int32 *nextstartindex)
{
afs_int32 code;
int i;
prentries bulkentries;
*nentries = 0;
*entries = NULL;
*nextstartindex = -1;
bulkentries.prentries_val = 0;
bulkentries.prentries_len = 0;
code =
ubik_PR_ListEntries(pruclient, 0, flag, startindex,
&bulkentries, nextstartindex);
if (code)
return code;
for (i = 0; i < bulkentries.prentries_len; i++) {
/* XXX should we try to return all the other entries? */
code = check_length(bulkentries.prentries_val[i].name);
if (code)
goto out;
}
out:
if (code != 0) {
xdr_free((xdrproc_t)xdr_prentries, &bulkentries);
} else {
*nentries = bulkentries.prentries_len;
*entries = bulkentries.prentries_val;
}
return code;
}
int main()
{
int i, j,len; int cnt =0;
bool is_prime_num;
int next_num;
if(!constrcut_prime_check(MAX_NUM))
return -1;;
for(j=1;j<MAX_NUM;j++)
{
next_num = j;
len = check_length(next_num);
is_prime_num = TRUE;
for(i=0;i<len;i++)
{
next_num = next_circular_num(next_num, len);
if(check_prime_with_samples(next_num) == FALSE) {is_prime_num = FALSE; break;}
}
if(is_prime_num)
{
printf("%d\n", j);
cnt ++;
}
}
printf("cnt = %d\n", cnt);
deconstruct_prime_check();
return 0;
}
int
pr_CreateGroup(prname name, prname owner, afs_int32 *id)
{
afs_int32 code;
afs_int32 oid = 0;
afs_int32 flags = 0;
code = check_length(name);
if (code)
return code;
/* pr_SNameToId will check owner's length. */
stolower(name);
if (owner) {
code = pr_SNameToId(owner, &oid);
if (code)
return code;
if (oid == ANONYMOUSID)
return PRNOENT;
}
flags |= PRGRP;
if (*id) {
code = ubik_PR_INewEntry(pruclient, 0, name, *id, oid);
} else {
code = ubik_PR_NewEntry(pruclient, 0, name, flags, oid, id);
}
return code;
}
InputIterator deserialize(InputIterator start, std::size_t length, tcp_mbap & header, boost::system::error_code & error) {
if (!check_length(length, 7, error)) return start;
start = deserialize_be16(start, header.transaction);
start = deserialize_be16(start, header.protocol );
start = deserialize_be16(start, header.length );
start = deserialize_be8 (start, header.unit );
return start;
}
int main(int argc, char *argv[]) {
midi_format format;
FILE *fd;
char buffer[1024];
int trk_len;
int read_count;
int i;
midi_track tracks[5];
// fd = fopen("beethoven_fur_elise.mid", "r");
// fd = fopen("Beethoven_Symphony_No._5_4th.mid", "r");
fd = fopen("clemtine.mid", "r");
if (fd == 0) {
printf("unable to open midi file.\n");
return 1;
}
fread(buffer, 1, 4, fd);
if (!check_file(buffer)) {
printf("not a midi file.\n");
fclose(fd);
return 1;
}
fread(buffer, 1, 4, fd);
if (check_length(buffer)) {
printf("not a valid header length.\n");
fclose(fd);
return 1;
}
fread(buffer, 1, 6, fd);
read_format(buffer, &format);
printf("Midi Info:\n");
printf(" Format: %i\n", format.format);
printf(" Delta Time Ticks: %i\n", format.deltatime_ticks);
printf(" # of Tracks: %i\n", format.number_of_tracks);
// read tracks
for (i = 0; i < format.number_of_tracks; i++) {
fread(buffer, 1, 8, fd);
trk_len = read_track_length(buffer);
printf("Track %i: length = %i\n", i, trk_len);
read_count = fread(buffer, 1, trk_len, fd);
if (read_count != trk_len) {
printf("unable to read track.\n");
fclose(fd);
return 1;
}
read_midi_events(buffer, trk_len, &tracks[i]);
break;
}
fclose(fd);
return 0;
}
int
pr_ListEntry(afs_int32 id, struct prcheckentry *aentry)
{
afs_int32 code;
code = ubik_PR_ListEntry(pruclient, 0, id, aentry);
if (code)
return code;
return check_length(aentry->name);
}
int
pr_RemoveUserFromGroup(prname user, prname group)
{
afs_int32 code;
namelist lnames;
idlist lids;
code = check_length(user);
if (code)
return code;
code = check_length(group);
if (code)
return code;
lnames.namelist_len = 2;
lnames.namelist_val = malloc(2 * PR_MAXNAMELEN);
strncpy(lnames.namelist_val[0], user, PR_MAXNAMELEN);
strncpy(lnames.namelist_val[1], group, PR_MAXNAMELEN);
lids.idlist_val = 0;
lids.idlist_len = 0;
code = pr_NameToId(&lnames, &lids);
if (code)
goto done;
if (lids.idlist_len != 2) {
code = PRINTERNAL;
goto done;
}
if (lids.idlist_val[0] == ANONYMOUSID
|| lids.idlist_val[1] == ANONYMOUSID) {
code = PRNOENT;
goto done;
}
code =
ubik_PR_RemoveFromGroup(pruclient, 0, lids.idlist_val[0],
lids.idlist_val[1]);
done:
if (lnames.namelist_val)
free(lnames.namelist_val);
xdr_free((xdrproc_t) xdr_idlist, &lids);
return code;
}
static void *empty_longtrack_write_raw(
struct disk *d, unsigned int tracknr, struct stream *s)
{
struct track_info *ti = &d->di->track[tracknr];
if (!check_length(s, 105000))
return NULL;
ti->total_bits = 110000;
return memalloc(0);
}
int
pr_IsAMemberOf(prname uname, prname gname, afs_int32 *flag)
{
afs_int32 code;
namelist lnames;
idlist lids;
code = check_length(uname);
if (code)
return code;
code = check_length(gname);
if (code)
return code;
stolower(uname);
stolower(gname);
lnames.namelist_len = 2;
lnames.namelist_val = malloc(2 * PR_MAXNAMELEN);
strncpy(lnames.namelist_val[0], uname, PR_MAXNAMELEN);
strncpy(lnames.namelist_val[1], gname, PR_MAXNAMELEN);
lids.idlist_val = 0;
lids.idlist_len = 0;
code = pr_NameToId(&lnames, &lids);
if (code) {
if (lnames.namelist_val)
free(lnames.namelist_val);
xdr_free((xdrproc_t) xdr_idlist, &lids);
return code;
}
if (lids.idlist_len != 2) {
free(lnames.namelist_val);
xdr_free((xdrproc_t) xdr_idlist, &lids);
return PRINTERNAL;
}
code =
ubik_PR_IsAMemberOf(pruclient, 0, lids.idlist_val[0],
lids.idlist_val[1], flag);
if (lnames.namelist_val)
free(lnames.namelist_val);
xdr_free((xdrproc_t) xdr_idlist, &lids);
return code;
}
void vector_add(vector_p vec, void* data, int n){
check_length(vec);
if (vec->copy_data){
vec->data[vec->length] = malloc(n);
vec->sizes[vec->length] = n;
memcpy(vec->data[vec->length], data, n);
}
else{
vec->data[vec->length] = data;
}
vec->length++;
}
int vector_insert(vector* vec, size_t i, void* data, size_t n){
int x;
check_length(vec);
for(x=vec->length;x>=i;x--){
vec->data[x+1] = vec->data[x];
vec->sizes[x+1] = vec->sizes[x+1];
}
vec->data[i] = malloc(n);
vec->sizes[i] = n;
memcpy(vec->data[i], data, n);
vec->length++;
return 0;
}
int vector_insert(vector_p vec, size_t i, void* data){
size_t x;
if(i > vec->length)
return -1;
check_length(vec);
for(x=vec->length;x>=i;x--){
vec->data[x+1] = vec->data[x];
}
vec->data[i] = data;
vec->length++;
return 0;
}
FileName(char* d, char* p, char* s, char* x, char* i, char* a) {
strcpy( dir, d);
strcpy( prefix, p);
strcpy( stem, s);
strcpy( suffix, x);
strcpy( inverseDir, i);
strcpy( altSuffix, a);
sprintf( pss, "%s%s%s", prefix, stem, suffix);
sprintf( dpss, "%s%s%s%s", dir, prefix, stem, suffix);
sprintf( psa, "%s%s%s", prefix, stem, altSuffix);
sprintf( dpsa, "%s%s%s%s", dir, prefix, stem, altSuffix);
check_length();
}
int read_two_uints(char *line, unsigned int *a, unsigned int *b)
{
if(!check_length(line)) {
return -1;
}
if(sscanf(line, "%u %u", a, b) != 2) {
return -1;
}
/* Check for negative numbers */
if(*a > INT_MAX || *b > INT_MAX) {
return -1;
}
return 0;
}
int
pr_NameToId(namelist *names, idlist *ids)
{
afs_int32 code;
afs_int32 i;
for (i = 0; i < names->namelist_len; i++) {
code = check_length(names->namelist_val[i]);
if (code)
return code;
stolower(names->namelist_val[i]);
}
code = ubik_PR_NameToID(pruclient, 0, names, ids);
return code;
}
int
pr_CreateUser(prname name, afs_int32 *id)
{
afs_int32 code;
code = check_length(name);
if (code)
return code;
stolower(name);
if (*id) {
code = ubik_PR_INewEntry(pruclient, 0, name, *id, 0);
} else {
code = ubik_PR_NewEntry(pruclient, 0, name, 0, 0, id);
}
return code;
}
static void *protec_longtrack_write_raw(
struct disk *d, unsigned int tracknr, struct stream *s)
{
struct track_info *ti = &d->di->track[tracknr];
while (stream_next_bit(s) != -1) {
ti->data_bitoff = s->index_offset_bc - 31;
if ((s->word != 0x4454a525) || !check_sequence(s, 1000, 0x33))
continue;
if (!check_length(s, 107200))
break;
ti->total_bits = 110000; /* long enough */
return memalloc(0);
}
return NULL;
}
/*
* Like ubik_PR_IDToName, but enforces that the output prnames are
* interpretable as C strings (i.e., NUL-terminated).
*/
int
string_PR_IDToName(struct ubik_client *client, afs_int32 flags,
idlist *ids, namelist *names)
{
afs_int32 code;
int i;
code = ubik_PR_IDToName(client, flags, ids, names);
if (code)
return code;
for (i = 0; i < names->namelist_len; i++) {
code = check_length(names->namelist_val[i]);
if (code)
return code;
}
return code;
}
static void *bat_longtrack_write_raw(
struct disk *d, unsigned int tracknr, struct stream *s)
{
struct track_info *ti = &d->di->track[tracknr];
while (stream_next_bit(s) != -1) {
ti->data_bitoff = s->index_offset_bc - 31;
if ((s->word != 0xaaaa8945) || !check_sequence(s, 6826, 0x00))
continue;
if (!check_length(s, 109500))
break;
ti->total_bits = 110000;
return memalloc(0);
}
return NULL;
}
static void *zoom_prot_write_raw(
struct disk *d, unsigned int tracknr, struct stream *s)
{
struct track_info *ti = &d->di->track[tracknr];
while (stream_next_bit(s) != -1) {
ti->data_bitoff = s->index_offset_bc - 15;
if (!check_sequence(s, 1000, 0xaa))
continue;
if (!check_length(s, 102000))
break;
ti->total_bits = 102386;
return memalloc(0);
}
return NULL;
}
