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; }