/** Reads each character of the file into a buffer if they are all valid @param fp the input file @return the buffer of the entire file */ char *readFile( FILE *fp ) { int capacity = 5; char *buffer = malloc( capacity ); int len = 0; char a; while( !feof( fp ) ) { fscanf( fp, "%c", &a ); if ( validChar( a ) ) { if ( capacity == ( len + 1 ) ) { capacity += capacity; buffer = ( char* )realloc( buffer, capacity ); buffer[ capacity ] = '\0'; } buffer[ len ] = a; len++; } else { fprintf( stderr, "usage: pack <input.txt> <compressed.raw> [wordfile.txt]\n" ); exit( 1 ); } } return buffer; }
//reads a max 32 char string from uart, supporting delete chars. static char* readString(void) { static char rx[33]; char tmp; BYTE i = 0; while((tmp = uart_getc()) != '\n' && tmp != '\r') { if (tmp == 0x7f) { if (i > 0) { rx[--i] = 0; uart_putc(tmp); } continue; } if (i < sizeof(rx) - 1) { if (validChar(tmp)) { rx[i++] = tmp; uart_putc(tmp); } } } rx[i] = 0; return rx; }
/* * Start the game play. This function is terminated when the board is filled, or * when a player has won. */ void play() { //X goes first char turn = 'X'; //current number of moves int moves = 0; //draw the board initializeGame(); //go until we find a winner or the board is filled while(!winner() && moves < 9) { //the current user input char c; int row, col; //wait until we get a valid charter while(!validChar(c = getchar())); //map the character to a row and column if(c == 'q' || c == 'w' || c == 'e') { //first row row = 0; } else if(c == 'a' || c == 's' || c == 'd') { //second row row = 1; } else { //third row row = 2; } //column check if(c == 'q' || c == 'a' || c == 'z') { //first col col = 0; } else if(c == 'w' || c == 's' || c == 'x') { //second col col = 1; } else { //third col col = 2; } //check if that space is free, otherwise loop goes again if (grid[row][col] == '\0') { //mark that spot grid[row][col] = turn; //draw it an change turns if (turn == 'X') { drawX(row,col); turn = 'O'; } else if (turn == 'O') { drawO(row,col); turn = 'X'; } //add the the move count moves++; } } //after the game is over, wait for the user to press any key to end getchar(); }
WordList *readWordList( char const *fname ) { FILE* f = fopen(fname, "r"); WordList* list = malloc(sizeof(WordList)); list->capacity = (WORD_MAX + 1); list->words = malloc(sizeof(Word) * list->capacity); // Number of characters we're currently using. list->len = 0; int wordLen; char s[WORD_MAX+1]; // = {wordLen = '\0'}; for (int i = 0; fscanf(f, "%d", &wordLen) == 1; i++) { fgetc(f); //skip space after the number if (i >= MAX_WORDS) { fprintf(stderr, "Invalid word file\n"); exit(EXIT_FAILURE); } if (wordLen > WORD_MAX || wordLen < WORD_MIN) { fprintf(stderr, "Invalid word file\n"); exit(EXIT_FAILURE); } for (int i = 0; i < wordLen; i++) { fscanf(f, "%c", &(s[i])); if (!validChar(s[i])){ fprintf(stderr, "Invalid character code: %x\n", (unsigned char)s[i]); exit(EXIT_FAILURE); } } s[wordLen] = '\0'; strcpy(list->words[list->len], s); list->len++; if (list->len >= list->capacity / 2){ list->capacity *= 2; list->words = realloc(list->words, sizeof(Word) * list->capacity + 2); } } addHardCodes(list); qsort(list->words, list->len, sizeof(Word), myComp); fclose(f); return list; }
int verifyTokens(struct tokenList* tokens) { int i, flag = 0; struct tokenElement* node = tokens->first; for (i = 0; i < tokens->qnt; i++) { if (node->token->text[0] == '\'') { if (validChar(node->token)) node->token->code = tokenToCode(node->token->text,'c'); else flag = 1; } else if (node->token->text[0] == '\"') { if (validString(node->token)) node->token->code = tokenToCode(node->token->text,'s'); else flag = 1; } else if (isalpha(node->token->text[0])) node->token->code = tokenToCode(node->token->text,'i'); else if (isdigit(node->token->text[0])) { if (validNumber(node->token)) node->token->code = tokenToCode(node->token->text,'n'); else flag = 1; } else if (validSeparator(node->token)) node->token->code = tokenToCode(node->token->text,'t'); else flag = 1; node = node->next; } if (!flag) return 1; else return 0; }
/** This function is responsable for building the word list. It reads words form word file given as fname. After reading all the words from the word file, it adds single-character words for each of the 98 valid characters. Finally, it sorts the word list lexicographically so that the index of each word is its code. @fname - name of the file that contains all lists from the word @return - Lists of words from fname, resorted. */ WordList *readWordList( char const *fname ){ //initialize WordList WordList *wordList = (WordList *)malloc( sizeof ( Word ) ); wordList->capacity = 1; wordList->len = 0; wordList->words = ( Word * )malloc( sizeof( wordList->capacity * sizeof( Word ) ) ); //Opens file FILE *fp; if ( ( fp = fopen( fname, "r" ) ) == NULL ){ fprintf(stderr, "Invalid word file\n" ); exit( EXIT_FAILURE ); } //stores char from file before moving into words char nextWord[ WORD_MAX + 1 ]; //Length of word in the file int length; //Counts the number of words that have been added to the file int count = 0; //Loop that runs through file while ( fscanf( fp, "%d", &length ) == 1 ){ //space between number and word char ch = fgetc( fp ); //Produces error if the word length is longer than 20 if ( length > WORD_MAX ){ fprintf(stderr, "Invalid word file\n"); exit( EXIT_FAILURE ); } //Produces error if there is more than 414 words in the list if ( count > LIST_MAX ){ fprintf(stderr, "Invalid word file\n"); exit( EXIT_FAILURE ); } //Checks the characters in the word before adding the word to the file int i = 0; //Loop that runs through each char in the word while ( i < length ){ ch = fgetc( fp ); //Produces error if char is not in acceptable range if ( !validChar( ch ) ){ fprintf(stderr, "Invalid word file\n"); exit( EXIT_FAILURE ); } //Adds char to new word, which will be added to the file nextWord[ i ] = ch; i++; } //Add null terminator to end of word nextWord[ length ] = '\0'; //Words count count ++; //Adds word to the total list of words addWord( wordList, nextWord ); } //Adds additional chars not included in the file list //add chars 0x20 - 0x7e for ( char i = '!'; i <= '~'; i++ ){ strcpy( nextWord, &i ); nextWord[ 1 ] = '\0'; addWord( wordList, nextWord ); count ++; } //add tab strcpy( nextWord, "\t"); addWord( wordList, nextWord ); //add new line strcpy( nextWord, "\n"); addWord( wordList, nextWord ); //add r strcpy( nextWord, "\r"); addWord( wordList, nextWord ); //add space strcpy( nextWord, " "); addWord( wordList, nextWord ); //sort list lexographically qsort( (int *) wordList->words[0], wordList->len, sizeof ( Word ), (int (*)(const void*, const void*) ) strcmp); //Close file fclose(fp); return wordList; }
/** * This function is responsible for building the word list. It reads words from a word file * given as fname. Before reading all the words from the word file, it adds single-character * words for each of the 98 valid characters. Finally, it sorts the word list lexicographically * so that the index of each word is its code. * * @param char const *fname - file name for the word list file * @return Wordlist *list - a pointer to the word list */ WordList *readWordList( char const *fname ) { FILE *fp; WordList *list = (WordList *) malloc( sizeof( WordList ) ); if(( fp = fopen( fname, "r" )) == NULL ){ fprintf(stderr, "Can't open word file: %s\n", fname); exit( EXIT_FAILURE ); } list->capacity = INITIAL_CAPACITY; list->len = 0; list->words = (Word *)malloc( (list->capacity + 1) * sizeof(Word)); // Set to negative value for EOF checking with dangling chars int wordLength = -1; char wordString[WORD_MAX + 1] = {'\0'}; char temp = ' '; addValidChars(list); while ( !feof(fp) ) { // Get word length fscanf(fp, "%d", &wordLength); // If word length is still -1 at this point, the word file has characters left over (possibly just a new line) such that // EOF was not detected. If this is the case then break out of the while loop. if( wordLength == -1){ break; } // Check whether length is within the allowed range for strings in the word list. if(wordLength <= WORD_MAX && wordLength >= WORD_MIN){ // Skip a single space getc(fp); // Get the word and check if each character is valid. for(int j = 0; j < wordLength; j++){ temp = getc(fp); if(validChar(temp)){ wordString[j] = temp; } else { fprintf(stderr, "Invalid word file\n"); exit( EXIT_FAILURE ); } } // Check if enough memory is allocated, if not then resize the word list. if ( list->len >= list->capacity ) { list->capacity *= 2; Word *newList = (Word *)malloc( (list->capacity + 1)* sizeof( Word ) ); memcpy( newList, list->words, list->len * sizeof( Word ) ); free( list->words ); list->words = newList; } // Copy the temporary string into a word in the word list. strcpy(list->words[list->len], wordString); list->len++; // If there are too many words in the list then print an error. if(list->len > MAX_LISTLEN){ fprintf(stderr, "Invalid word file\n"); exit(EXIT_FAILURE); } } else { fprintf(stderr, "Invalid word file\n"); exit(EXIT_FAILURE); } // Reset temporary string and length variables. for(int k = 0; k < WORD_MAX; k++){ wordString[k] = '\0'; } wordLength = -1; } //Sort the word list qsort(list->words, list->len, sizeof( Word ), compareWords) ; //Close the word file fclose(fp); return list; }