Matrix DataCollector::readPMatrixFromText(string filename)
{
unsigned int rows, columns;
countLines(filename, rows, columns);
ifstream infile; //input file stream object
infile.open(filename);
if (!infile) {
cerr << "Bad input! Can't open " << filename << endl;
exit(1);
}
Matrix P(rows, columns);
unsigned int i = 0;
unsigned int j = 0;
string line;
string token;
while (!infile.eof())
{
getline(infile, line, '\n');
stringstream ss(line);
j = 0;
while (getline(ss, token, ','))
{
P(i, j) = stod(token);
j++;
//cout << price << "\t";
}
i++;
}
return P;
}
void drawFrame()
{
u8* bufAdr=gfxGetFramebuffer(GFX_TOP, GFX_LEFT, NULL, NULL);
int i, j;
for(i=1;i<400;i++)
{
for(j=1;j<240;j++)
{
u32 v=(j+i*240)*3;
bufAdr[v]=(pcCos(i+cnt)+4096)/32;
bufAdr[v+1]=(pcCos(j-256+cnt)+4096)/64;
bufAdr[v+2]=(pcCos(i+128-cnt)+4096)/32;
}
}
gfxDrawText(GFX_TOP, GFX_LEFT, NULL, "ftPONY v0.0003 gamma\n", 240-fontDefault.height*1, 10);
u32 ip = gethostid();
char bof[256];
sprintf(bof, "IP: %lu.%lu.%lu.%lu\n", ip & 0xFF, (ip>>8)&0xFF, (ip>>16)&0xFF, (ip>>24)&0xFF);
gfxDrawText(GFX_TOP, GFX_LEFT, NULL, bof, 240-fontDefault.height*2, 10);
gfxDrawText(GFX_TOP, GFX_LEFT, NULL, quotes[curQuote], 240-fontDefault.height*3, 10);
i = countLines(superStr);
while(i>240/fontDefault.height-3){cutLine(superStr);i--;}
gfxDrawText(GFX_TOP, GFX_LEFT, NULL, superStr, 240-fontDefault.height*4, 20);
cnt++;
gfxFlushBuffers();
gfxSwapBuffers();
}
// Create a graph from an input file. The format for the input file is specified
// in the graph.h header file
Graph* createGraph(FILE *inputFile)
{
Graph *g = myMalloc(sizeof(Graph));
g->numVertices = countLines(inputFile);
g->numEdges = (countNumWords(inputFile)-(g->numVertices))/2;
// init vertices
g->vertices = myMalloc(sizeof(Vertex) * g->numVertices);
for(int i = 0; i < g->numVertices; i++){
Vertex *vp = g->vertices+i;
vp->label = i+1;
vp->head = NULL;
vp->tail = NULL;
}
// init edges
g->edges = myMalloc(sizeof(Edge) * g->numEdges);
for(int i = 0; i < g->numEdges; i++){
Edge *ep = g->edges+i;
ep->endpoint1 = NULL;
ep->endpoint2 = NULL;
}
//init connector elements
g->connectors = myMalloc(sizeof(ConnectorElement) * g->numEdges * 2);
for(int i = 0; i < g->numEdges*2; i++){
ConnectorElement *connector = g->connectors+i;
connector->adjacentEdge=NULL;
connector->sourceVertex=NULL;
connector->prev=NULL;
connector->next=NULL;
}
hookupGraph(g, inputFile);
rewind(inputFile);
return g;
}
void Analysis::analysis(const char* testFile, const char* compareFile)
{
int n = countLines(testFile);
bool* abandon = new bool[n];
ifstream in(testFile, ios::in);
int number;
int i = 0;
while(!in.eof() && i < n)
{
in >> number;
//printf("number: %d\n", number);
if(number == 0)
abandon[i] = false;
else
abandon[i] = true;
i++;
//if(i >= 7200)
//printf("%d\n", i);
}
in.close();
n = i;
compare(compareFile, abandon, n);
}
/* kill all processes other than the given pid that have the given processName */
void killOtherProcessesWithName(pid_t pid, char* processName) {
/* get the user running the parent process */
char* userName = calloc(MAX_USERNAME_LENGTH + 1, sizeof(char));
getUserNameForPid(pid, userName);
/* build the command */
char* command = calloc(55 + strlen(processName) + strlen(userName),
sizeof(char));
sprintf(command,
"ps aux | grep %s | grep -v gdb | grep -v grep | grep %s",
processName, userName);
/* get the number of processes */
int numPids = countLines(command);
/* get the pids */
int pids[numPids];
getPids(command, pids);
/* for each process pid, if it's not yours, kill it */
int index;
for (index = 0; index < numPids; index++) {
int otherpid = pids[index];
if (otherpid != pid) {
/* printf("Killing procnanny process found with pid %d\n",otherpid); */
if (kill(otherpid, 9) == -1) {
printMessageandExit("Kill error\n", EXIT_FAILURE);
}
}
}
// clean up
free(command);
free(userName);
}
/* ================== buildHead =================
This function creates the header structure that
contains pointers to the tree and the hash table.
It also calls other functions to read in the data
file.
Pre pHeader - pointer to HEAD structure
fileInput - name of the file
Post both the tree and the hash table are
created.
Return pointer to create HEAD structure
*/
HEAD* buildHead (HEAD* pHeader, char* fileInput)
{
// Local Declarations
DATA* newAirport;
FILE* fpIn;
// Statements
fpIn = fopen(fileInput, "r");
if (!fpIn) {
printf("Error opening input file\n");
exit(101);
}
if ((pHeader = (HEAD*) malloc(sizeof(HEAD))))
{
pHeader->pHash = buildHash(2 * countLines(fileInput));
pHeader->pTree = BST_Create(compareCode);
}
else{
printf("Memory allocation error\n");
exit(100);
}
while (getData(pHeader->pTree, fpIn, &newAirport)) {
BST_Insert(pHeader->pTree, newAirport);
insertHash(pHeader->pHash, newAirport);
}
return pHeader;
} // buildHead
void OMXPlayerPlaylist::createPlaylist ()
{
ifstream playlistFile;
string line;
int i;
playlistLength = countLines ();
playlistEntries = new OMXPlayerPlaylistEntry [ playlistLength ];
playlistFile.open ( playlistPath.c_str () );
if ( playlistFile.is_open() )
{
i = 0;
while ( getline ( playlistFile, line ) )
{
// cout << line << '\n';
// playlistEntries [ i ] = OMXPlayerPlaylistEntry ();
createPlaylistEntry ( line, i );
i++;
}
playlistFile.close();
}
else
{
cout << "Unable to open file";
}
}
FileEditor* openFile(gchar* gfilename){
char* filename = (char*)gfilename;
FILE* file = fopen(filename, "r");
FileEditor* edit = malloc(sizeof(FileEditor));
if(file){
edit->nLine = countLines(file);
rewind(file);
edit->content = (char**) malloc(sizeof(char*) * edit->nLine);
for(int i = 0;i < edit->nLine ;i++){
char *line = (char*) malloc(sizeof(char) * 100);
fgets(line,100,file);
//printf("line #%d: %s",i,line);
edit->content[i] = line;
}
rewind(file);
printf("This file has %d lines\n",edit->nLine);
fclose(file);
} else{
printf("Error while opening the file\n");
}
return edit;
}
int main()
{
FILE * fin = NULL;
int ** temps = NULL;
int choice, total = 0;
fin = openFilePrompt();
total = countLines(fin);
temps = fillArray(total, fin);
do
{
choice = menu();
if(choice == 1)
displayMonthData(total, temps);
else if(choice == 2)
displayYearData(total, temps);
else if(choice == 3)
temps = addMoreTemps(temps, &total);
}while (choice != 4);
cleanUp(total, temps);
return 0;
}// end main
// opens the file and stores the strings
//
// input: string of passenger data
// container to store strings
//
int processFile( container* cp, char* fn )
{
char line[80];
FILE* in = fopen( fn,"r" );
int count = 0;
if ( in != NULL )
{
cp->rows = countLines(in);
cp->strings = (char**)malloc(sizeof(char*)*cp->rows);
while ( !feof(in) )
{
if ( fgets( line, 80, in ) )
{
cp->strings[count] = (char*)malloc(sizeof(char)*strlen(line)+1);
strcpy(cp->strings[count],line);
count++;
}
}
}
else
{
printf("Unable to open file %s\n",fn);
exit(0);
}
fclose(in);
return count;
}
void parse(const char *filename)
{
char * line = NULL;
char * token;
size_t len = 0;
int read_len = 0;
int i=0;
// open config file for reading
FILE *conf_file = fopen(filename, "r");
if (conf_file == NULL)
fprintf(stderr, "Unable to open given file");
// get number of users
userNum = countLines(filename);
users = malloc(userNum * sizeof(user));
// for each line in config, add new user struct
while((read_len = getline(&line, &len, conf_file)) != -1) {
token = strtok(line, " ");
strcpy(users[i].name, token);
token = strtok(NULL, " ");
strcpy(users[i].password,token);
i++;
}
fclose(conf_file);
}
static void processFile(Regex* re, SearchOutput* output, OrderedOutput::Chunk* chunk, HighlightBuffer& hlbuf,
const char* path, size_t pathLength, const char* data, size_t size, unsigned int startLine)
{
const char* range = re->rangePrepare(data, size);
const char* begin = range;
const char* end = begin + size;
unsigned int line = startLine;
while (RegexMatch match = re->rangeSearch(begin, end - begin))
{
// discard zero-length matches at the end (.* results in an extra line for every file part otherwise)
if (match.data == end) break;
// update line counter
line += 1 + countLines(begin, match.data);
// print match
const char* lbeg = findLineStart(begin, match.data);
const char* lend = findLineEnd(match.data + match.size, end);
processMatch(re, output, chunk, hlbuf, path, pathLength, (lbeg - range) + data, lend - lbeg, line, lbeg, match.data - lbeg, match.size);
// move to next line
if (lend == end) break;
begin = lend + 1;
}
re->rangeFinalize(range);
}
static void showText(WScreen *scr, int x, int y, int h, int w, const char *text)
{
int width;
int height;
Pixmap pixmap;
Pixmap mask;
WMFont *font = scr->info_text_font;
int side = 0;
int ty;
int bx, by;
if (scr->balloon->contents)
XFreePixmap(dpy, scr->balloon->contents);
width = getMaxStringWidth(font, text) + 16;
height = countLines(text) * WMFontHeight(font) + 4;
if (height < 16)
height = 16;
if (width < height)
width = height;
if (x + width > scr->scr_width) {
side = RIGHT;
bx = x - width + w / 2;
if (bx < 0)
bx = 0;
} else {
side = LEFT;
bx = x + w / 2;
}
if (bx + width > scr->scr_width)
bx = scr->scr_width - width;
if (y - (height + SPACE) < 0) {
side |= TOP;
by = y + h - 1;
ty = SPACE;
} else {
side |= BOTTOM;
by = y - (height + SPACE);
ty = 0;
}
pixmap = makePixmap(scr, width, height, side, &mask);
drawMultiLineString(scr->wmscreen, pixmap, scr->black, font, 8, ty + 2, text, strlen(text));
XSetWindowBackgroundPixmap(dpy, scr->balloon->window, pixmap);
scr->balloon->contents = pixmap;
XResizeWindow(dpy, scr->balloon->window, width, height + SPACE);
XShapeCombineMask(dpy, scr->balloon->window, ShapeBounding, 0, 0, mask, ShapeSet);
XFreePixmap(dpy, mask);
XMoveWindow(dpy, scr->balloon->window, bx, by);
XMapRaised(dpy, scr->balloon->window);
scr->balloon->mapped = 1;
}
void main(int argc, char *argv[])
{
/*file pointers*/
FILE * fp_sc = NULL;
FILE * fp_dict = NULL;
/*check argument count*/
if (argc != 3) {
printf("Usage : source_file dict_file\n");
printf("ERROR - wrong amount of arguments!\n");
return WRONG_ARGUMENTS;
}
fp_sc = fopen(argv[1], "r+");
if (fp_sc == NULL) {
printf("ERROR - cannot open source file at %s.\n", argv[1]);
return CANNOT_OPEN_SOURCE_FILE;
}
/* we dont need anything more than read*/
fp_dict = fopen(argv[2], "r");
if (fp_dict == NULL) {
fclose(fp_sc);
printf("ERROR - cannot open dictionary file at %s.\n", argv[3]);
return CANNOT_OPEN_DICTIONARY_FILE;
}
/*dictionary format is :
<word> : <synonim>*/
word_amount = countLines(fp_dict);
size_t allocation_size = sizeof(char) * WORD_SIZE * word_amount;
/* the word search array will contain all the words that we found in the dict file*/
char *word_search_array = malloc(allocation_size);
/*incase we loose the mem location , we need to free it in the end*/
const char *word_search_start = word_search_array;
/*init the word search array*/
if (inint_word_search_array(fp_dict, word_search_start) == ERROR_BAD_FORMAT) {
return ERROR_BAD_FORMAT;
}
char *after_replace = NULL;
fseek(fp_sc, 0, SEEK_SET);
printf("Starting to replace words\n".);
replace_words(fp_sc, fp_dict, word_search_array, &after_replace);
printf("Finished replacing words\n.");
freopen(argv[1], "w", fp_sc);
fputs(after_replace, fp_sc);
/*free our allocated memory*/
printf("Finished copying the data to the file.\nFreeing the memory and files.");
free(after_replace);
free(word_search_start);
fclose(fp_dict);
fclose(fp_sc);
}
TreeNode *buildTreeFromFile(FILE *fp)
{
int numWords = countLines(fp);
char **lexiconArray = buildArrayFromFile(fp, numWords);
TreeNode *root = initNodeWithValue(lexiconArray[numWords/2], 0);
buildTreeFromArray(lexiconArray, numWords/2, root, 1);
buildTreeFromArray(lexiconArray+numWords/2+1, numWords - numWords/2 - 1, root, 1);
return root;
}
void TEditor::setSelect( ushort newStart, ushort newEnd, Boolean curStart )
{
ushort p;
if( curStart != 0 )
p = newStart;
else
p = newEnd;
uchar flags = ufUpdate;
if( newStart != selStart || newEnd != selEnd )
if( newStart != newEnd || selStart != selEnd )
flags = ufView;
if( p != curPtr )
{
if( p > curPtr )
{
ushort l = p - curPtr;
memmove( &buffer[curPtr], &buffer[curPtr + gapLen], l);
curPos.y += countLines(&buffer[curPtr], l);
curPtr = p;
}
else
{
ushort l = curPtr - p;
curPtr = p;
curPos.y -= countLines(&buffer[curPtr], l);
memmove( &buffer[curPtr + gapLen], &buffer[curPtr], l);
}
drawLine = curPos.y;
drawPtr = lineStart(p);
curPos.x = charPos(drawPtr, p);
delCount = 0;
insCount = 0;
setBufSize(bufLen);
}
selStart = newStart;
selEnd = newEnd;
update(flags);
}
struct ctgInfo *getCtgInfo(char *ooDir, char *chrom, char *contig)
/* Get contig info on dir. */
{
struct ctgInfo *ci;
char fileName[512];
AllocVar(ci);
ci->chrom = chrom;
ci->contig = contig;
sprintf(fileName, "%s/%s/%s/%s", ooDir, chrom, contig, "geno.lst");
ci->cloneCount = countLines(fileName);
return ci;
}
//Ham doc du lieu tu file test
void readTestData(Rating **B, int *len, char* filename)
{
int nRating = countLines(filename);
Rating *T = calloc(nRating, sizeof(Rating));
FILE *fp = fopen(filename, "r");
if (fp == NULL)
{
perror("fopen() in readTestData()");
exit(1);
}
int uID, mID, j=0;
long t;
float rate;
int mIndex;
if (dataFormat == ML100K)
for (int i=0; i<nRating; i++)
{
fscanf(fp, "%d%d%f%ld", &uID, &mID, &rate, &t);
mIndex = indexOfMovieID(mID);
if (mIndex < nMovies && mIndex >= 0 && uID <= nUsers)
{
T[j].uID = uID-1;
T[j].mID = mIndex;
T[j].R = rate;
j++;
}
}
else if (dataFormat == ML10M)
for (int i=0; i<nRating; i++)
{
fscanf(fp, "%d::%d::%f::%ld", &uID, &mID, &rate, &t);
mIndex = indexOfMovieID(mID);
if (mIndex < nMovies && mIndex >= 0&& uID <= nUsers)
{
T[j].uID = uID-1;
T[j].mID = mIndex;
T[j].R = rate;
j++;
}
}
*B = T;
*len = j; //Vi chi xet nhung phan tu hop le
fclose(fp);
}
//Ham danh chi so movie
void indexMovie()
{
nMovies = countLines(moviesData);
MI = calloc(nMovies, sizeof(int));
FILE *fp = fopen(moviesData, "r");
char buf[1024];
for (int i=0; i<nMovies; i++)
{
fgets(buf, 1024, fp);
sscanf(buf, "%d", &MI[i]);
}
fclose(fp);
}
//Ham doc du lieu tu file training
void readData(float ***outArr, int nMovies, int nUsers, char* filename)
{
nMovies = countLines(moviesData);
MI = calloc(nMovies, sizeof(int));
FILE *fp = fopen(moviesData, "r");
char buf[1024];
for (int i=0; i<nMovies; i++)
{
fgets(buf, 1024, fp);
sscanf(buf, "%d", &MI[i]);
}
fclose(fp);
fp = fopen(filename, "r");
if (fp == NULL)
{
perror("fopen()");
exit(1);
}
float **A;
A = calloc(nMovies, sizeof(float*));
for (int i=0; i<nMovies; i++)
A[i] = calloc(nUsers, sizeof(float));
int uID, mID;
long t;
float rate;
int mIndex;
// FILE *fp1 = fopen(moviesData, "r");
//fclose(fp1);
while (!feof(fp))
{
if (dataFormat == ML100K)
fscanf(fp, "%d%d%f%ld", &uID, &mID, &rate, &t);
else if (dataFormat == ML10M)
fscanf(fp, "%d::%d::%f::%ld", &uID, &mID, &rate, &t);
mIndex = indexOfMovieID(mID);
if (mIndex < nMovies && uID <= nUsers)
A[mIndex][uID-1] = rate;
}
*outArr = A;
}
int main (int argc, char* argv[])
{
int count;
if (argc == 1) {
// no argument => count lines of standard input
count = countLines(std::cin);
}
else {
// count number of lines of all files passed as argument
std::ifstream in;
count = 0;
for (int i=1; i<argc; ++i) {
std::ifstream file(argv[i]);
if (!file) {
std::cerr << "failed to open " << argv[i] << "\n";
}
else {
count += countLines(file);
}
}
}
std::cout << count << std::endl;
}
/* determine if a given processName exists */
int ifProcessExists( char *processName ){
char* userName = calloc(MAX_USERNAME_LENGTH + 1, sizeof(char));
getUserNameForPid(getpid(), userName);
/* build the command */
char* command = calloc(55 + strlen(processName) + strlen(userName),
sizeof(char));
sprintf(command,
"ps aux | grep %s | grep -v gdb | grep -v grep | grep %s",
processName, userName);
/* get the number of processes */
int numPids = countLines(command);
return numPids;
}
static void showText(WScreen *scr, int x, int y, int h, int w, const char *text)
{
int width;
int height;
Pixmap pixmap;
WMFont *font = scr->info_text_font;
if (scr->balloon->contents)
XFreePixmap(dpy, scr->balloon->contents);
width = getMaxStringWidth(font, text) + 8;
/*width = WMWidthOfString(font, text, strlen(text))+8; */
height = countLines(text) * WMFontHeight(font) + 4;
if (x < 0)
x = 0;
else if (x + width > scr->scr_width - 1)
x = scr->scr_width - width;
if (y - height - 2 < 0) {
y += h;
if (y < 0)
y = 0;
} else {
y -= height + 2;
}
if (scr->window_title_texture[0])
XSetForeground(dpy, scr->draw_gc, scr->window_title_texture[0]->any.color.pixel);
else
XSetForeground(dpy, scr->draw_gc, scr->light_pixel);
pixmap = XCreatePixmap(dpy, scr->root_win, width, height, scr->w_depth);
XFillRectangle(dpy, pixmap, scr->draw_gc, 0, 0, width, height);
drawMultiLineString(scr->wmscreen, pixmap, scr->window_title_color[0], font, 4, 2, text, strlen(text));
XResizeWindow(dpy, scr->balloon->window, width, height);
XMoveWindow(dpy, scr->balloon->window, x, y);
XSetWindowBackgroundPixmap(dpy, scr->balloon->window, pixmap);
XClearWindow(dpy, scr->balloon->window);
XMapRaised(dpy, scr->balloon->window);
scr->balloon->contents = pixmap;
scr->balloon->mapped = 1;
}
void getWordFirstRound(FILE*file, wordAndHints *newWordAndHint){
static alreadyRandom = 0;
int i, j, counter=0;
char temporaria[BUFSIZ];
rewind(file);
i = countLines();
if(!alreadyRandom) {
srand(time(NULL));
alreadyRandom = 1;
}
j=rand()%i;
for(counter=1;counter<j;counter++){
fgets(temporaria,BUFSIZ,file);
}
newWordAndHint->word = (char*) malloc(50*sizeof(char));
newWordAndHint->hints[0] = (char*) malloc(50*sizeof(char));
newWordAndHint->hints[1] = (char*) malloc(50*sizeof(char));
newWordAndHint->hints[2] = (char*) malloc(50*sizeof(char));
char temp[5];
fscanf(file,"%s", (newWordAndHint->word));
fscanf(file,"%s", temp);
newWordAndHint->dificulty = temp[0];
// hints in random order
i=3;
j=rand()%i;
int temp2 = j;
fscanf(file,"%s", (newWordAndHint->hints[j]));
while(j == temp2) {
j=rand()%i;
}
fscanf(file,"%s", (newWordAndHint->hints[j]));
if(j!=2 && temp2 != 2) {
j = 2;
} else { if(j!=1 && temp2 != 1) {
j = 1;
} else {
j = 0;
}}
fscanf(file,"%s", (newWordAndHint->hints[j]));
// printf("\na palavra e %s\n", newWordAndHint->word);
}
void AksenMain(void) {
starting();
do {
if (akt_time() >= timeoutAt) {
setMotPow(0,0);
break;
}
if(kurven == 8 && sensor[MID_MID] == 1 && sensor[MID_LEFT] == 1 && sensor[MID_RIGHT] == 1){
setMotPow(0,0);
break;
}
followLine();
countLines();
manage(start);
}while(1);
while(1);
}
void TEditor::setBufLen( ushort length )
{
bufLen = length;
gapLen = bufSize - length;
selStart = 0;
selEnd = 0;
curPtr = 0;
delta.x = 0;
delta.y = 0;
curPos = delta;
limit.x = maxLineLength;
limit.y = countLines( &buffer[gapLen], bufLen ) + 1;
drawLine = 0;
drawPtr = 0;
delCount = 0;
insCount = 0;
modified = False;
update(ufView);
}
void drawError(gfxScreen_t screen, char* title, char* body, int offset)
{
int i;
int numLines=countLines(body);
int width=numLines*8+32;
int height=300;
int x=240-width-12+offset, y=4;
//main frame
for(i=0; i<9; i++)gfxDrawRectangle(screen, GFX_LEFT, ENTRY_BGCOLOR, x+roundLutError[i], y+i, width-roundLutError[i]*2, 1);
gfxDrawRectangle(screen, GFX_LEFT, ENTRY_BGCOLOR, x, y+9, width, height-9*2);
for(i=0; i<9; i++)gfxDrawRectangle(screen, GFX_LEFT, ENTRY_BGCOLOR, x+roundLutError[i], y+height-1-i, width-roundLutError[i]*2, 1);
//content
gfxDrawText(screen, GFX_LEFT, &fontTitle, title, x+width-6-16, y+6);
gfxDrawText(screen, GFX_LEFT, &fontDescription, body, x+width-5-16-13, y+8);
}
Matrix DataCollector::readQMatrixFromText(string filename)
{
unsigned int rows, columns;
countLines(filename, rows, columns);
ifstream infile; //input file stream object
infile.open(filename);
if (!infile) {
cerr << "Bad input! Can't open " << filename << endl;
exit(1);
}
Matrix Q(rows, 1);
unsigned int i = 0;
string line;
while (getline(infile, line, '\n'))
{
Q(i++, 0) = stod(line);
}
return Q;
}
int main(void)
{
int rfd, flags, i, count;
char buffer[SIZE];
char** arr;
flags = O_RDONLY;
rfd = open(INPUT, flags);
count = countLines(buffer, rfd);
lseek(rfd, 0, SEEK_SET); //rewind the file, http://linux.die.net/man/2/lseek
arr = (char**) malloc(count * sizeof(char*));
for(i = 0; i < count; i++)
{
arr[i] = (char*) malloc((hash+1) * sizeof(char));
}
i = 0;
while(readLine(buffer, SIZE, rfd) >= hash)
{
strcpy(arr[i], buffer);
i++;
}
for(i = 0; i < count; i++)
{
crack(arr[i]);
free(arr[i]);
arr[i] = NULL;
}
free(arr);
arr = NULL;
close(rfd);
return 1;
}
int main(int argc, char *argv[])
{
FILE *fp = fopen(argv[2], "r");
int height = countLines(fp);
int width = numCharsPerLine(fp);
WBCell **cells = initializeCells(fp, height, width);
fclose(fp);
// printCells(cells, height, width);
FILE *lexiconFilePtr = fopen(LEXICON_FILENAME, "r");
TreeNode *lexTree = buildTreeFromFile(lexiconFilePtr);
fclose(lexiconFilePtr);
solvePuzzle(lexTree, cells, height, width, atoi(argv[1]));
freeCells(cells, height, width);
freeTree(lexTree);
return 0;
}
