passing arrays and reading/writing of files

I'm trying to pass the array to the generate function and use its elements in the function. for some reason it just keeps giving me syntax error for the function prototype and definition. code with comments as to where i made changes and am facing troubles. i tried to debug it but wasn't very successful. the errors are in lines 38, 81, 163. here is the code:

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "eprintf.h"

enum {
    NPREF   = 2,    /* number of prefix words */
    NHASH   = 4093, /* size of state hash table array */
    MAXGEN  = 10000 /* maximum words generated */
};

typedef struct State State;
typedef struct Suffix Suffix;

struct State {  /* prefix + suffix list */
    char    *pref[NPREF];   /* prefix words */
    Suffix  *suf;           /* list of suffixes */
    State   *next;          /* next in hash table */
};

struct Suffix { /* list of suffixes */
    char    *word;          /* suffix */
    Suffix  *next;          /* next in list of suffixes */
};

State   *lookup(char *prefix[], int create);
void    build(char *prefix[], FILE* myfile); //passing the input stream
void    generate(int nwords, int[] random_num, FILE* oufile); // passing the array and the output stream
void    add(char *prefix[], char *word);

State   *statetab[NHASH];   /* hash table of states */

char NONWORD[] = "\n";  /* cannot appear as real word */

//FILE* random_reader;
//FILE* myfile;


/* markov main: markov-chain random text generation */
int main(void)
{
    int i, nwords = MAXGEN;
    char *prefix[NPREF];        /* current input prefix */

    FILE* random_reader;
    FILE* myfile;
    FILE* outfile;

    int c;
    int element;
    int random_num[10000];
    char* line;
    int j=0;
    random_reader = fopen("../random_num.txt","r");
    myfile = fopen("../alice30.txt","r");
    outfile = fopen("../output/markov_c_out.txt","w");
    while(fgets(line,20,random_reader)!=NULL)
    {
        sscanf(line,"%o",&element);
        random_num[j]= element;
        j++;
    }

    setprogname("markov");


    for (i = 0; i < NPREF; i++) /* set up initial prefix */
        prefix[i] = NONWORD;
    build(prefix, myfile);
    add(prefix, NONWORD);
    generate(nwords, random_num, outfile); // calling the updated function
    return 0;
}   

const int MULTIPLIER = 31;  /* for hash() */

/* hash: compute hash value for array of NPREF strings */

unsigned int hash(char *s[NPREF])
{
    unsigned int h;
    unsigned char *p;
    int i;

    h = 0;
    for (i = 0; i < NPREF; i++)
        for (p = (uns开发者_运维问答igned char *) s[i]; *p != '\0'; p++)
            h = MULTIPLIER * h + *p;
    return h % NHASH;
}

/* lookup: search for prefix; create if requested. */
/*  returns pointer if present or created; NULL if not. */
/*  creation doesn't strdup so strings mustn't change later. */

State* lookup(char *prefix[NPREF], int create)
{
    int i, h;
    State *sp;

    h = hash(prefix);
    for (sp = statetab[h]; sp != NULL; sp = sp->next) {
        for (i = 0; i < NPREF; i++)
            if (strcmp(prefix[i], sp->pref[i]) != 0)
                break;
        if (i == NPREF)     /* found it */
            return sp;
    }
    if (create) {
        sp = (State *) emalloc(sizeof(State));
        for (i = 0; i < NPREF; i++)
            sp->pref[i] = prefix[i];
        sp->suf = NULL;
        sp->next = statetab[h];
        statetab[h] = sp;
    }
    return sp;
}

/* addsuffix: add to state. suffix must not change later */

void addsuffix(State *sp, char *suffix)
{
    Suffix *suf;

    suf = (Suffix *) emalloc(sizeof(Suffix));
    suf->word = suffix;
    suf->next = sp->suf;
    sp->suf = suf;
}

/* add: add word to suffix list, update prefix */

void add(char *prefix[NPREF], char *suffix)
{
    State *sp;

    sp = lookup(prefix, 1);  /* create if not found */
    addsuffix(sp, suffix);
    /* move the words down the prefix */
    memmove(prefix, prefix+1, (NPREF-1)*sizeof(prefix[0]));
    prefix[NPREF-1] = suffix;
}

/* build: read input, build prefix table */
void build(char *prefix[NPREF], FILE *myfile)
{
    char buf[100], fmt[10];

    /* create a format string; %s could overflow buf */
    sprintf(fmt, "%%%ds", sizeof(buf)-1);
    while (fscanf(myfile, fmt, buf) != EOF)
        add(prefix, estrdup(buf));
}

/* generate: produce output, one word per line */

void generate(int nwords, int[] random_num, FILE* oufile)
{
    State *sp;
    Suffix *suf;
    char *prefix[NPREF], *w;
    int i, nmatch;

    for (i = 0; i < NPREF; i++) /* reset initial prefix */
        prefix[i] = NONWORD;

    for (i = 0; i < nwords; i++) {
        sp = lookup(prefix, 0);
        if (sp == NULL)
            eprintf("internal error: lookup failed");
        nmatch = 0;
        for (suf = sp->suf; suf != NULL; suf = suf->next)
            if (random_num[i] % ++nmatch == 0) //using the elements of the array
                w = suf->word;
        if (nmatch == 0)
            eprintf("internal error: no suffix %d %s", i, prefix[0]);
        if (strcmp(w, NONWORD) == 0)
            break;

        fprintf(outfile, w);
        memmove(prefix, prefix+1, (NPREF-1)*sizeof(prefix[0]));
        prefix[NPREF-1] = w;
    }
}

The prototype for generate should read

void generate(int nwords, int random_num[], FILE* oufile);

in both the declaration and the definition. int[] foo is not valid C syntax.

The other error is because you forgot to declare estrdup. Without a declaration, C assumes that its prototype its return value is int, hence the error

a.c:136: note: expected ‘char *’ but argument is of type ‘int’

Good to see someone is reading The Practice of Programming, it's one of my favorites :)