struct tnode *addword(struct tnode *p, char *word, int line)
{
int cond;
struct lnode *l;
if (p == NULL) {
p = talloc();
p->left = p->right = NULL;
p->word = str_dup(word);
l = p->lines = lnodealloc();
l->line = line;
l->next = NULL;
} else if ((cond = strcmp(word, p->word)) == 0) {
l = p->lines;
while (l->next) {
l = l->next;
}
l->next = lnodealloc();
l = l->next;
l->line = line;
l->next = NULL;
}
else if (cond < 0) /* less than into left subtree */
p->left = addword(p->left, word, line);
else /* greater than into right subtree */
p->right = addword(p->right, word, line);
return p;
}
static void* addword_thread(addword_thread_param_pack_t* args) { /* thread for adding word */
int i;
for(i = 0; i < args->m_nwords; i++) {
addword((char*)args->m_words[i]);
}
return NULL;
}
static struct tnode *treeadd(struct tnode *p, char *w, char *uw, int line) {
int cond;
if (p == NULL) {
// Create new tnode
p = talloc();
p->word = mystrdup(w);
p->words = lwalloc();
p->words->word = mystrdup(uw);
p->words->next = NULL;
p->wordcount = 1;
p->lines = lalloc();
p->lines->linenum = line;
p->lines->next = NULL;
p->right = NULL;
p->left = NULL;
} else if ((cond = strncmp(w, p->word, MAXWORDSIZE)) == 0) {
// Update existing tnode
addword(p, uw);
addline(p, line);
} else if (cond < 0)
// Traverse left-hand side of tree
p->left = treeadd(p->left, w, uw, line);
else
// Traverse right-hand side of tree
p->right = treeadd(p->right, w, uw, line);
return p;
}
int main()
{
trie *root=createNode();
char str[100];
int total=0;
s(total);
while(total--)
{
scanf("%s",str);
addword(root,str);
}
printf("Enter word to search \n");
ss(str);
printf("Word : %s Instances : %d\n ",str,countwords(root,str));
printf("ENter word to remove\t");
ss(str);
removeword(root,str);
printf("Enter word to search \n");
ss(str);
printf("Word : %s Instances : %d\n ",str,countwords(root,str));
return 0;
}
int ladderLength_1(string beginWord, string endWord, unordered_set<string>& wordList) {
queue<string> beingVisited;
wordList.insert(endWord);
addword(beginWord, wordList, beingVisited);
int level = 2;
while(!beingVisited.empty()){
int size = beingVisited.size();
for(int i = 0; i < size; ++i){
string word = beingVisited.front();
beingVisited.pop();
if(word == endWord){
return level;
}
addword(word, wordList, beingVisited);
}
++level;
}
return 0;
}
int main()
{
int n,k,z;
char str[30];
init(root);
n=scan();
while(n--)
{
scanf("%s",str);
addword(root,str);
}
k=scan();
for(z=1;z<=k;z++)
{
scanf("%s",str);
printf("Case #%d:\n",z);
printprefixes(root,str);
}
}
int main(int argc, char **argv)
{
int n = 0;
char word[MAXWORD+1];
int line = 1;
struct tnode *root = NULL;
while (getword(word, MAXWORD) != EOF) {
if (strcmp(word, "\n") == 0) {
line++;
continue;
}
root = addword(root, word, line);
}
treeprint(root);
return 0;
}
int load(char *path, DictList *list, int max) {
char line[256];
char * nlc;
int count = 0;
FILE * fd = NULL;
DictWord * toadd = NULL;
fd = fopen(path, "r");
if (fd == NULL) {
return 0;
}
while (fgets(line, 255, fd)) {
count++;
nlc = strchr(line, '\n');
if (nlc != NULL)
*nlc = '\0';
toadd = (DictWord *)malloc(sizeof(DictWord));
if (toadd == NULL)
return -1;
toadd->word = strdup(line);
toadd->index = count;
addword(toadd, list);
/* printf("%-8d> %s\n", list->nval, line); */
if (max > 0 && count >= max) {
break;
}
if (feof(fd)) {
break;
}
}
return 1;
}
node* treefromfile()
{
node *ptree=NULL;
char word[25],meaning[100],str[120],*i;
int flags=0;
file_ptr=fopen("C:\dict.txt","r");
if(file_ptr==NULL)
ptree=NULL;
else
{
while(!feof(file_ptr))
{
i=fgets(str,120,file_ptr);
if(i==NULL)
{
break;
}
seperateword(str,word,meaning);
if(flags==0)
{
ptree=maketree(word,meaning);
flags=1;
}
else
{
addword(ptree,word,meaning);
}
}
fclose(file_ptr);
}
return ptree;
}
Trie(vector<string>& words)
{
root = new TrieNode();
for(auto s: words)
addword(s);
}
/*
* Play a single game
* Reset the word lists from last game
* Keep track of the running stats
*/
void
playgame(void)
{
int i, *p, *q;
time_t t;
char buf[MAXWORDLEN + 1];
ngames++;
npwords = 0;
pwordsp = pwords;
nmwords = 0;
mwordsp = mwords;
time(&start_t);
q = &wordpath[MAXWORDLEN + 1];
p = wordpath;
while (p < q)
*p++ = -1;
showboard(board);
startwords();
if (setjmp(env)) {
badword();
goto timesup;
}
while (1) {
if (get_line(buf) == NULL) {
if (feof(stdin))
clearerr(stdin);
break;
}
time(&t);
if (t - start_t >= tlimit) {
badword();
break;
}
if (buf[0] == '\0') {
int remaining;
remaining = tlimit - (int) (t - start_t);
(void)snprintf(buf, sizeof(buf),
"%d:%02d", remaining / 60, remaining % 60);
showstr(buf, 1);
continue;
}
if (strlen(buf) < (size_t)minlength) {
badword();
continue;
}
p = wordpath;
while (p < q && *p != -1)
*p++ = -1;
usedbits = 0;
if (checkword(buf, -1, wordpath) < 0)
badword();
else {
if (debug) {
(void) printf("[");
for (i = 0; wordpath[i] != -1; i++)
(void) printf(" %d", wordpath[i]);
(void) printf(" ]\n");
}
for (i = 0; i < npwords; i++) {
if (strcmp(pword[i], buf) == 0)
break;
}
if (i != npwords) { /* already used the word */
badword();
showword(i);
}
else if (!validword(buf))
badword();
else {
int len;
if (npwords == maxpwords - 1) {
maxpwords += MAXPWORDS;
pword = realloc(pword,
maxpwords * sizeof(char *));
if (pword == NULL) {
cleanup();
errx(1, strerror(ENOMEM));
}
}
len = strlen(buf) + 1;
if (pwordsp + len >= &pwords[maxpspace]) {
maxpspace += MAXPSPACE;
pwords = realloc(pwords, maxpspace);
if (pwords == NULL) {
cleanup();
errx(1, strerror(ENOMEM));
}
}
pword[npwords++] = pwordsp;
memcpy(pwordsp, buf, len);
pwordsp += len;
addword(buf);
}
}
}
timesup: ;
/*
* Sort the player's words and terminate the list with a null
* entry to help out checkdict()
*/
qsort(pword, npwords, sizeof(pword[0]), compar);
pword[npwords] = NULL;
/*
* These words don't need to be sorted since the dictionary is sorted
*/
checkdict();
tnmwords += nmwords;
tnpwords += npwords;
results();
}
/*
* Reads a single file (ie until get() returns EOF)
*/
static void read_file(paragraph *** ret, input * in, indexdata * idx)
{
token t;
paragraph par;
word wd, **whptr, **idximplicit;
tree234 *macros;
wchar_t utext[2], *wdtext;
int style, spcstyle;
int already;
int iswhite, seenwhite;
int type;
struct stack_item {
enum {
stack_nop = 0, /* do nothing (for error recovery) */
stack_ualt = 1, /* \u alternative */
stack_style = 2, /* \e, \c, \cw */
stack_idx = 4, /* \I, \i, \ii */
stack_hyper = 8, /* \W */
stack_quote = 16, /* \q */
} type;
word **whptr; /* to restore from \u alternatives */
word **idximplicit; /* to restore from \u alternatives */
} *sitem;
stack parsestk;
word *indexword=NULL, *uword=NULL, *iword=NULL;
word *idxwordlist;
rdstring indexstr;
int index_downcase=0, index_visible=0, indexing=0;
const rdstring nullrs = { 0, 0, NULL };
wchar_t uchr;
t.text = NULL;
macros = newtree234(macrocmp);
already = FALSE;
/*
* Loop on each paragraph.
*/
while (1)
{
int start_cmd = c__invalid;
par.words = NULL;
par.keyword = NULL;
whptr = &par.words;
/*
* Get a token.
*/
if (!already)
{
dtor(t), t = get_token(in);
}
already = FALSE;
if (t.type == tok_eof)
break;
/*
* Parse code paragraphs separately.
*/
if (t.type == tok_cmd && t.cmd == c_c && !isbrace(in))
{
par.type = para_Code;
par.fpos = t.pos;
while (1)
{
dtor(t), t = get_codepar_token(in);
wd.type = word_WeakCode;
wd.breaks = FALSE; /* shouldn't need this... */
wd.text = ustrdup(t.text);
wd.alt = NULL;
wd.fpos = t.pos;
addword(wd, &whptr);
dtor(t), t = get_token(in);
if (t.type == tok_white)
{
/*
* The newline after a code-paragraph line
*/
dtor(t), t = get_token(in);
}
if (t.type == tok_eop || t.type == tok_eof)
break;
else if (t.type != tok_cmd || t.cmd != c_c)
{
error(err_brokencodepara, &t.pos);
addpara(par, ret);
while (t.type != tok_eop) /* error recovery: */
dtor(t), t = get_token(in); /* eat rest of paragraph */
goto codeparabroken; /* ick, but such is life */
}
}
addpara(par, ret);
codeparabroken:
continue;
}
while (t.type == tok_cmd && macrolookup(macros, in, t.text, &t.pos))
{
dtor(t), t = get_token(in);
}
/*
* This token begins a paragraph. See if it's one of the
* special commands that define a paragraph type.
*
* (note that \# is special in a way, and \nocite takes no
* text)
*/
par.type = para_Normal;
if (t.type == tok_cmd)
{
int needkw=0;
int is_macro = FALSE;
par.fpos = t.pos;
switch (t.cmd)
{
default:
needkw = -1;
break;
case c__invalid:
error(err_badparatype, t.text, &t.pos);
needkw = 4;
break;
case c__comment:
if (isbrace(in))
break; /* `\#{': isn't a comment para */
do
{
dtor(t), t = get_token(in);
}
while (t.type != tok_eop && t.type != tok_eof);
continue; /* next paragraph */
/*
* `needkw' values:
*
* 1 -- exactly one keyword
* 2 -- at least one keyword
* 4 -- any number of keywords including zero
* 8 -- at least one keyword and then nothing else
* 16 -- nothing at all! no keywords, no body
* 32 -- no keywords at all
*/
case c_A:
needkw = 2;
par.type = para_Appendix;
break;
case c_B:
needkw = 2;
par.type = para_Biblio;
break;
case c_BR:
needkw = 1;
par.type = para_BR;
start_cmd = c_BR;
break;
case c_C:
needkw = 2;
par.type = para_Chapter;
break;
case c_H:
needkw = 2;
par.type = para_Heading;
par.aux = 0;
break;
case c_IM:
needkw = 2;
par.type = para_IM;
start_cmd = c_IM;
break;
case c_S:
needkw = 2;
par.type = para_Subsect;
par.aux = t.aux;
break;
case c_U:
needkw = 32;
par.type = para_UnnumberedChapter;
break;
/* For \b and \n the keyword is optional */
case c_b:
needkw = 4;
par.type = para_Bullet;
break;
case c_n:
needkw = 4;
par.type = para_NumberedList;
break;
case c_cfg:
needkw = 8;
par.type = para_Config;
start_cmd = c_cfg;
break;
case c_copyright:
needkw = 32;
par.type = para_Copyright;
break;
case c_define:
is_macro = TRUE;
needkw = 1;
break;
/* For \nocite the keyword is _everything_ */
case c_nocite:
needkw = 8;
par.type = para_NoCite;
break;
case c_preamble:
needkw = 32;
par.type = para_Preamble;
break;
case c_rule:
needkw = 16;
par.type = para_Rule;
break;
case c_title:
needkw = 32;
par.type = para_Title;
break;
case c_versionid:
needkw = 32;
par.type = para_VersionID;
break;
}
if (needkw > 0)
{
rdstring rs = { 0, 0, NULL };
int nkeys = 0;
filepos fp;
/* Get keywords. */
dtor(t), t = get_token(in);
fp = t.pos;
while (t.type == tok_lbrace)
{
/* This is a keyword. */
nkeys++;
/* FIXME: there will be bugs if anyone specifies an
* empty keyword (\foo{}), so trap this case. */
while (dtor(t), t = get_token(in),
t.type == tok_word ||
t.type == tok_white ||
(t.type == tok_cmd && t.cmd == c__nbsp) ||
(t.type == tok_cmd && t.cmd == c__escaped))
{
if (t.type == tok_white ||
(t.type == tok_cmd && t.cmd == c__nbsp))
rdadd(&rs, ' ');
else
rdadds(&rs, t.text);
}
if (t.type != tok_rbrace)
{
error(err_kwunclosed, &t.pos);
continue;
}
rdadd(&rs, 0); /* add string terminator */
dtor(t), t = get_token(in); /* eat right brace */
}
rdadd(&rs, 0); /* add string terminator */
/* See whether we have the right number of keywords. */
if ((needkw & 48) && nkeys > 0)
error(err_kwillegal, &fp);
if ((needkw & 11) && nkeys == 0)
error(err_kwexpected, &fp);
if ((needkw & 5) && nkeys > 1)
error(err_kwtoomany, &fp);
if (is_macro)
{
/*
* Macro definition. Get the rest of the line
* as a code-paragraph token, repeatedly until
* there's nothing more left of it. Separate
* with newlines.
*/
rdstring macrotext = { 0, 0, NULL };
while (1)
{
dtor(t), t = get_codepar_token(in);
if (macrotext.pos > 0)
rdadd(¯otext, L'\n');
rdadds(¯otext, t.text);
dtor(t), t = get_token(in);
if (t.type == tok_eop)
break;
}
macrodef(macros, rs.text, macrotext.text, fp);
continue; /* next paragraph */
}
par.keyword = rdtrim(&rs);
/* Move to EOP in case of needkw==8 or 16 (no body) */
if (needkw & 24)
{
/* We allow whitespace even when we expect no para body */
while (t.type == tok_white)
dtor(t), t = get_token(in);
if (t.type != tok_eop && t.type != tok_eof &&
(start_cmd == c__invalid ||
t.type != tok_cmd || t.cmd != start_cmd))
{
error(err_bodyillegal, &t.pos);
/* Error recovery: eat the rest of the paragraph */
while (t.type != tok_eop && t.type != tok_eof &&
(start_cmd == c__invalid ||
t.type != tok_cmd || t.cmd != start_cmd))
dtor(t), t = get_token(in);
}
if (t.type == tok_cmd)
already = TRUE; /* inhibit get_token at top of loop */
addpara(par, ret);
continue; /* next paragraph */
}
}
}
/*
* Now read the actual paragraph, word by word, adding to
* the paragraph list.
*
* Mid-paragraph commands:
*
* \K \k
* \c \cw
* \e
* \i \ii
* \I
* \u
* \W
* \date
* \\ \{ \}
*/
parsestk = stk_new();
style = word_Normal;
spcstyle = word_WhiteSpace;
indexing = FALSE;
seenwhite = TRUE;
while (t.type != tok_eop && t.type != tok_eof)
{
iswhite = FALSE;
already = FALSE;
/* Handle implicit paragraph breaks after \IM, \BR etc */
if (start_cmd != c__invalid &&
t.type == tok_cmd && t.cmd == start_cmd)
{
already = TRUE; /* inhibit get_token at top of loop */
break;
}
if (t.type == tok_cmd && t.cmd == c__escaped)
{
t.type = tok_word; /* nice and simple */
t.aux = 0; /* even if `\-' - nonbreaking! */
}
if (t.type == tok_cmd && t.cmd == c__nbsp)
{
t.type = tok_word; /* nice and simple */
sfree(t.text);
t.text = ustrdup(L" "); /* text is ` ' not `_' */
t.aux = 0; /* (nonbreaking) */
}
switch (t.type)
{
case tok_white:
if (whptr == &par.words)
break; /* strip whitespace at start of para */
wd.text = NULL;
wd.type = spcstyle;
wd.alt = NULL;
wd.aux = 0;
wd.fpos = t.pos;
wd.breaks = FALSE;
/*
* Inhibit use of whitespace if it's (probably the
* newline) before a repeat \IM / \BR type
* directive.
*/
if (start_cmd != c__invalid)
{
dtor(t), t = get_token(in);
already = TRUE;
if (t.type == tok_cmd && t.cmd == start_cmd)
break;
}
if (indexing)
rdadd(&indexstr, ' ');
if (!indexing || index_visible)
addword(wd, &whptr);
if (indexing)
addword(wd, &idximplicit);
iswhite = TRUE;
break;
case tok_word:
if (indexing)
rdadds(&indexstr, t.text);
wd.type = style;
wd.alt = NULL;
wd.aux = 0;
wd.fpos = t.pos;
wd.breaks = t.aux;
if (!indexing || index_visible)
{
wd.text = ustrdup(t.text);
addword(wd, &whptr);
}
if (indexing)
{
wd.text = ustrdup(t.text);
addword(wd, &idximplicit);
}
break;
case tok_lbrace:
error(err_unexbrace, &t.pos);
/* Error recovery: push nop */
sitem = mknew(struct stack_item);
sitem->type = stack_nop;
stk_push(parsestk, sitem);
break;
case tok_rbrace:
sitem = stk_pop(parsestk);
if (!sitem)
error(err_unexbrace, &t.pos);
else
{
if (sitem->type & stack_ualt)
{
whptr = sitem->whptr;
idximplicit = sitem->idximplicit;
}
if (sitem->type & stack_style)
{
style = word_Normal;
spcstyle = word_WhiteSpace;
}
if (sitem->type & stack_idx ) {
indexword->text = ustrdup(indexstr.text);
if (index_downcase)
ustrlow(indexword->text);
indexing = FALSE;
rdadd(&indexstr, L'\0');
index_merge(idx, FALSE, indexstr.text, idxwordlist);
sfree(indexstr.text);
}
if (sitem->type & stack_hyper)
{
wd.text = NULL;
wd.type = word_HyperEnd;
wd.alt = NULL;
wd.aux = 0;
wd.fpos = t.pos;
wd.breaks = FALSE;
if (!indexing || index_visible)
addword(wd, &whptr);
if (indexing)
addword(wd, &idximplicit);
}
if (sitem->type & stack_quote)
{
wd.text = NULL;
wd.type = toquotestyle(style);
wd.alt = NULL;
wd.aux = quote_Close;
wd.fpos = t.pos;
wd.breaks = FALSE;
if (!indexing || index_visible)
addword(wd, &whptr);
if (indexing)
{
rdadd(&indexstr, L'"');
addword(wd, &idximplicit);
}
}
}
sfree(sitem);
break;
case tok_cmd:
switch (t.cmd)
{
case c__comment:
/*
* In-paragraph comment: \#{ balanced braces }
*
* Anything goes here; even tok_eop. We should
* eat whitespace after the close brace _if_
* there was whitespace before the \#.
*/
dtor(t), t = get_token(in);
if (t.type != tok_lbrace)
{
error(err_explbr, &t.pos);
} else
{
int braces = 1;
while (braces > 0)
{
dtor(t), t = get_token(in);
if (t.type == tok_lbrace)
braces++;
else if (t.type == tok_rbrace)
braces--;
else if (t.type == tok_eof)
{
error(err_commenteof, &t.pos);
break;
}
}
}
if (seenwhite)
{
already = TRUE;
dtor(t), t = get_token(in);
if (t.type == tok_white)
{
iswhite = TRUE;
already = FALSE;
}
}
break;
case c_q:
dtor(t), t = get_token(in);
if (t.type != tok_lbrace)
{
error(err_explbr, &t.pos);
} else
{
wd.text = NULL;
wd.type = toquotestyle(style);
wd.alt = NULL;
wd.aux = quote_Open;
wd.fpos = t.pos;
wd.breaks = FALSE;
if (!indexing || index_visible)
addword(wd, &whptr);
if (indexing)
{
rdadd(&indexstr, L'"');
addword(wd, &idximplicit);
}
sitem = mknew(struct stack_item);
sitem->type = stack_quote;
stk_push(parsestk, sitem);
}
break;
case c_K:
case c_k:
case c_R:
case c_W:
case c_L:
case c_date:
/*
* Keyword, hyperlink, or \date. We expect a
* left brace, some text, and then a right
* brace. No nesting; no arguments.
*/
wd.fpos = t.pos;
wd.breaks = FALSE;
if (t.cmd == c_K)
wd.type = word_UpperXref;
else if (t.cmd == c_k)
wd.type = word_LowerXref;
else if (t.cmd == c_R)
wd.type = word_FreeTextXref;
else if (t.cmd == c_W)
wd.type = word_HyperLink;
else if (t.cmd == c_L)
wd.type = word_LocalHyperLink;
else
wd.type = word_Normal;
dtor(t), t = get_token(in);
if (t.type != tok_lbrace)
{
if (wd.type == word_Normal)
{
time_t thetime = time(NULL);
struct tm *broken = localtime(&thetime);
already = TRUE;
wdtext = ustrftime(NULL, broken);
wd.type = style;
} else
{
error(err_explbr, &t.pos);
wdtext = NULL;
}
} else
{
rdstring rs = { 0, 0, NULL };
while (dtor(t), t = get_token(in),
t.type == tok_word || t.type == tok_white)
{
if (t.type == tok_white)
rdadd(&rs, ' ');
else
rdadds(&rs, t.text);
}
if (wd.type == word_Normal)
{
time_t thetime = time(NULL);
struct tm *broken = localtime(&thetime);
wdtext = ustrftime(rs.text, broken);
wd.type = style;
} else
{
wdtext = ustrdup(rs.text);
}
sfree(rs.text);
if (t.type != tok_rbrace)
{
error(err_kwexprbr, &t.pos);
}
}
wd.alt = NULL;
wd.aux = 0;
if (!indexing || index_visible)
{
wd.text = ustrdup(wdtext);
addword(wd, &whptr);
}
if (indexing)
{
wd.text = ustrdup(wdtext);
addword(wd, &idximplicit);
}
sfree(wdtext);
if (wd.type == word_FreeTextXref || wd.type == word_HyperLink || wd.type == word_LocalHyperLink)
{
/*
* Hyperlinks are different: they then
* expect another left brace, to begin
* delimiting the text marked by the link.
*/
dtor(t), t = get_token(in);
/*
* Special cases: \W{}\c, \W{}\e, \W{}\cw
*/
sitem = mknew(struct stack_item);
sitem->type = stack_hyper;
if (t.type == tok_cmd &&
(t.cmd == c_e || t.cmd == c_c || t.cmd == c_cw))
{
if (style != word_Normal)
error(err_nestedstyles, &t.pos);
else
{
style = (t.cmd == c_c ? word_Code :
t.cmd == c_cw ? word_WeakCode : word_Emph);
spcstyle = tospacestyle(style);
sitem->type |= stack_style;
}
dtor(t), t = get_token(in);
}
if (t.type != tok_lbrace)
{
error(err_explbr, &t.pos);
sfree(sitem);
} else
{
stk_push(parsestk, sitem);
}
}
break;
case c_c:
case c_cw:
case c_e:
type = t.cmd;
if (style != word_Normal)
{
error(err_nestedstyles, &t.pos);
/* Error recovery: eat lbrace, push nop. */
dtor(t), t = get_token(in);
sitem = mknew(struct stack_item);
sitem->type = stack_nop;
stk_push(parsestk, sitem);
}
dtor(t), t = get_token(in);
if (t.type != tok_lbrace)
{
error(err_explbr, &t.pos);
} else
{
style = (type == c_c ? word_Code :
type == c_cw ? word_WeakCode : word_Emph);
spcstyle = tospacestyle(style);
sitem = mknew(struct stack_item);
sitem->type = stack_style;
stk_push(parsestk, sitem);
}
break;
case c_i:
case c_ii:
case c_I:
type = t.cmd;
if (indexing)
{
error(err_nestedindex, &t.pos);
/* Error recovery: eat lbrace, push nop. */
dtor(t), t = get_token(in);
sitem = mknew(struct stack_item);
sitem->type = stack_nop;
stk_push(parsestk, sitem);
}
sitem = mknew(struct stack_item);
sitem->type = stack_idx;
dtor(t), t = get_token(in);
/*
* Special cases: \i\c, \i\e, \i\cw
*/
wd.fpos = t.pos;
if (t.type == tok_cmd &&
(t.cmd == c_e || t.cmd == c_c || t.cmd == c_cw))
{
if (style != word_Normal)
error(err_nestedstyles, &t.pos);
else
{
style = (t.cmd == c_c ? word_Code :
t.cmd == c_cw ? word_WeakCode : word_Emph);
spcstyle = tospacestyle(style);
sitem->type |= stack_style;
}
dtor(t), t = get_token(in);
}
if (t.type != tok_lbrace)
{
sfree(sitem);
error(err_explbr, &t.pos);
} else
{
/* Add an index-reference word with no text as yet */
wd.type = word_IndexRef;
wd.text = NULL;
wd.alt = NULL;
wd.aux = 0;
wd.breaks = FALSE;
indexword = addword(wd, &whptr);
/* Set up a rdstring to read the index text */
indexstr = nullrs;
/* Flags so that we do the Right Things with text */
index_visible = (type != c_I);
index_downcase = (type == c_ii);
indexing = TRUE;
idxwordlist = NULL;
idximplicit = &idxwordlist;
/* Stack item to close the indexing on exit */
stk_push(parsestk, sitem);
}
break;
case c_u:
uchr = t.aux;
utext[0] = uchr;
utext[1] = 0;
wd.type = style;
wd.breaks = FALSE;
wd.alt = NULL;
wd.aux = 0;
wd.fpos = t.pos;
if (!indexing || index_visible)
{
wd.text = ustrdup(utext);
uword = addword(wd, &whptr);
} else
uword = NULL;
if (indexing)
{
wd.text = ustrdup(utext);
iword = addword(wd, &idximplicit);
} else
iword = NULL;
dtor(t), t = get_token(in);
if (t.type == tok_lbrace)
{
/*
* \u with a left brace. Until the brace
* closes, all further words go on a
* sidetrack from the main thread of the
* paragraph.
*/
sitem = mknew(struct stack_item);
sitem->type = stack_ualt;
sitem->whptr = whptr;
sitem->idximplicit = idximplicit;
stk_push(parsestk, sitem);
whptr = uword ? &uword->alt : NULL;
idximplicit = iword ? &iword->alt : NULL;
} else
{
if (indexing)
rdadd(&indexstr, uchr);
already = TRUE;
}
break;
default:
if (!macrolookup(macros, in, t.text, &t.pos))
error(err_badmidcmd, t.text, &t.pos);
break;
}
int use_dict() {
FILE *fp;
char lang[150], word[80] = "";
char j, f, buf[120], sys[] = "|\033[31me\033[m:編籍字典";
int i = 0;
setutmpmode(DICT);
if(!HAS_PERM(PERM_SYSOP))
sys[0]=0;
clear();
sprintf(buf,"\033[45m ●\033[1;44;33m"
" %-14s\033[3;45m ● ", dict);
strcpy(&buf[100],"\033[m\n");
for(;;) {
move(0, 0);
sprintf(lang, " 請輸入關鍵字串(%s) 或指令(h,t,a)\n", dict);
outs(lang);
sprintf(lang, "[\033[32m<關鍵字>\033[m|\033[32mh\033[m:help|\033[32m"
"t\033[m:所有資料|\033[32ma\033[m:新增資料%s]\n:", sys);
outs(lang);
getdata(2, 0, ":", word, 18, DOECHO);
outs("資料搜尋中請稍候....");
strcpy(word,lower(word));
if(word[0] == 0)
return 0;
clear();
move(4, 0);
outs(buf);
if(strlen(word) == 1) {
if(word[0] == 'a') {
clear();
move(4,0);
outs(buf);
addword(word);
continue;
} else if(word[0] == 't')
word[0] = 0;
else if(word[0] == 'h') {
more("etc/dict.hlp",YEA);
clear();
continue;
} else if(word[0]=='e') {
vedit(database,NA, NULL);
clear();
continue;
} else {
outs("字串太短,請輸入多一點關鍵字");
continue;
}
}
if((fp = fopen(database,"r"))) {
i = 0;
while(fgets(lang,150,fp) != NULL) {
if(lang[65] == '[') {
lang[65] = 0;
f = 1;
} else
f = 0;
if(strstr(lower(lang),word)) {
if(f == 1)
lang[65] = '[';
outs(lang);
i++;
if(!((i+1)%17)) {
move(23, 0);
outs("\033[45m "
"任意鍵繼續 Q:離開 "
"\033[m ");
j = igetch();
if(j == 'q')
break;
else {
clear();
move(4,0);
outs(buf);
}
}
}
}
}
fclose(fp);
if(i == 0) {
getdata(5, 0, "沒這個資料耶,新增嗎?(y/N)", lang, 3, LCECHO);
if(lang[0] == 'y') {
clear();
move(4,0);
outs(buf);
addword(word);
}
}
}
}
void prog()
{
char word[25],meaning[100],hword[25];
int menuchoice,rep,l,h;
node *temp;
node *t;
FILE *fp;
clrscr();
temp=treefromfile();
if(temp==NULL)
{
printf("File does not exist or dictionary is empty...");
getch();
}
while(1)
{
clrscr();
menuchoice=showmenu();
// scanf("%d",&menuchoice);
switch(menuchoice)
{
case 1:{
frame();
printf("\nEnter word : \n");
scanf("%s",word);
printf("\nEnter meaning : " );
flushall();
gets(meaning);
if(temp==NULL)
{
temp=maketree(word,meaning);
}
else
{
addword(temp,word,meaning);
}
break;
}
case 2:{
frame();
if(temp==NULL)
{
printf("\nThe dictionary is empty...\n");
}
else
{
printf("\nFind meaning of : \n");
flushall();
gets(word);
t=csearch(temp,word);
if(t==NULL)
{
printf("\nWord not found...\n");
printf("\nDo you want to add this word to database: \n1>yes\n2>No\n");
scanf("%d",&rep);
if(rep==1)
{
frame();
printf("\nEnter word : %s\n",word);
//scanf("%s",word);
printf("\nEnter meaning : " );
flushall();
gets(meaning);
if(temp==NULL)
{
temp=maketree(word,meaning);
}
else
{
addword(temp,word,meaning);
}
}
else
{
printf("\nReturning to main menu...\n");
}
}
else
{
printf("\n%s : ",t->word);
puts(t->meaning);
}
}
getch();
break;
}
case 3:{
frame();
if(temp==NULL)
printf("Dictionary is empty...");
else
displayall(temp);
getch();
break;
}
case 4:{
clrscr();
printf("\n\n\tEnter word: ");
scanf("%s",word);
printf("\n\tEnter meaning: ");
gets(meaning);
change(temp,word,meaning);
break;
}
case 5:
{
clrscr();
frame();
printf("\nHow many last searched words to be displayed:");
scanf("%d",&h);
fp=fopen("c:\\history.txt","r" );
if(fp==NULL)
{
printf("\nUnable to read history file...\n");
printf("\n\n\tThere is no history of searched words...\n");
}
else
{
gotoxy(1,20);
for(l=0;l<15;l++)
{
printf("||||");
}
gotoxy(1,1);
printf("\n\t\tHISTORY\n\n");
printf("\nLast %d words which were searched are:\n\n",h);
for(l=0;l<h;l++)
{
fscanf(fp,"%s",hword);
printf("\t%d>\t%s",l+1,hword);
}
}
fclose(fp);
getch();
break;
}
case 6:{
filefromtree(temp);
end();
exit(1);
break;
}
default:{
printf("Wrong!! Enter Again");
delay(1000);
prog();
break;
}
}
}
}
// Render a single triangle to memory.
void testTriangle() {
// Like above, we allocate/lock/map some videocore memory
// I'm just shoving everything in a single buffer because I'm lazy
// 8Mb, 4k alignment
unsigned int handle = mem_alloc(mbox, 0x800000, 0x1000, MEM_FLAG_COHERENT | MEM_FLAG_ZERO);
if (!handle) {
printf("Error: Unable to allocate memory");
return;
}
uint32_t bus_addr = mem_lock(mbox, handle);
uint8_t *list = (uint8_t*) mapmem(bus_addr, 0x800000);
uint8_t *p = list;
// Configuration stuff
// Tile Binning Configuration.
// Tile state data is 48 bytes per tile, I think it can be thrown away
// as soon as binning is finished.
addbyte(&p, 112);
addword(&p, bus_addr + 0x6200); // tile allocation memory address
addword(&p, 0x8000); // tile allocation memory size
addword(&p, bus_addr + 0x100); // Tile state data address
addbyte(&p, 30); // 1920/64
addbyte(&p, 17); // 1080/64 (16.875)
addbyte(&p, 0x04); // config
// Start tile binning.
addbyte(&p, 6);
// Primitive type
addbyte(&p, 56);
addbyte(&p, 0x32); // 16 bit triangle
// Clip Window
addbyte(&p, 102);
addshort(&p, 0);
addshort(&p, 0);
addshort(&p, 1920); // width
addshort(&p, 1080); // height
// State
addbyte(&p, 96);
addbyte(&p, 0x03); // enable both foward and back facing polygons
addbyte(&p, 0x00); // depth testing disabled
addbyte(&p, 0x02); // enable early depth write
// Viewport offset
addbyte(&p, 103);
addshort(&p, 0);
addshort(&p, 0);
// The triangle
// No Vertex Shader state (takes pre-transformed vertexes,
// so we don't have to supply a working coordinate shader to test the binner.
addbyte(&p, 65);
addword(&p, bus_addr + 0x80); // Shader Record
// primitive index list
addbyte(&p, 32);
addbyte(&p, 0x04); // 8bit index, trinagles
addword(&p, 3); // Length
addword(&p, bus_addr + 0x70); // address
addword(&p, 2); // Maximum index
// End of bin list
// Flush
addbyte(&p, 5);
// Nop
addbyte(&p, 1);
// Halt
addbyte(&p, 0);
int length = p - list;
assert(length < 0x80);
// Shader Record
p = list + 0x80;
addbyte(&p, 0x01); // flags
addbyte(&p, 6*4); // stride
addbyte(&p, 0xcc); // num uniforms (not used)
addbyte(&p, 3); // num varyings
addword(&p, bus_addr + 0xfe00); // Fragment shader code
addword(&p, bus_addr + 0xff00); // Fragment shader uniforms
addword(&p, bus_addr + 0xa0); // Vertex Data
// Vertex Data
p = list + 0xa0;
// Vertex: Top, red
addshort(&p, (1920/2) << 4); // X in 12.4 fixed point
addshort(&p, 200 << 4); // Y in 12.4 fixed point
addfloat(&p, 1.0f); // Z
addfloat(&p, 1.0f); // 1/W
addfloat(&p, 1.0f); // Varying 0 (Red)
addfloat(&p, 0.0f); // Varying 1 (Green)
addfloat(&p, 0.0f); // Varying 2 (Blue)
// Vertex: bottom left, Green
addshort(&p, 560 << 4); // X in 12.4 fixed point
addshort(&p, 800 << 4); // Y in 12.4 fixed point
addfloat(&p, 1.0f); // Z
addfloat(&p, 1.0f); // 1/W
addfloat(&p, 0.0f); // Varying 0 (Red)
addfloat(&p, 1.0f); // Varying 1 (Green)
addfloat(&p, 0.0f); // Varying 2 (Blue)
// Vertex: bottom right, Blue
addshort(&p, 1360 << 4); // X in 12.4 fixed point
addshort(&p, 800 << 4); // Y in 12.4 fixed point
addfloat(&p, 1.0f); // Z
addfloat(&p, 1.0f); // 1/W
addfloat(&p, 0.0f); // Varying 0 (Red)
addfloat(&p, 0.0f); // Varying 1 (Green)
addfloat(&p, 1.0f); // Varying 2 (Blue)
// Vertex list
p = list + 0x70;
addbyte(&p, 0); // top
addbyte(&p, 1); // bottom left
addbyte(&p, 2); // bottom right
// fragment shader
p = list + 0xfe00;
addword(&p, 0x958e0dbf);
addword(&p, 0xd1724823); /* mov r0, vary; mov r3.8d, 1.0 */
addword(&p, 0x818e7176);
addword(&p, 0x40024821); /* fadd r0, r0, r5; mov r1, vary */
addword(&p, 0x818e7376);
addword(&p, 0x10024862); /* fadd r1, r1, r5; mov r2, vary */
addword(&p, 0x819e7540);
addword(&p, 0x114248a3); /* fadd r2, r2, r5; mov r3.8a, r0 */
addword(&p, 0x809e7009);
addword(&p, 0x115049e3); /* nop; mov r3.8b, r1 */
addword(&p, 0x809e7012);
addword(&p, 0x116049e3); /* nop; mov r3.8c, r2 */
addword(&p, 0x159e76c0);
addword(&p, 0x30020ba7); /* mov tlbc, r3; nop; thrend */
addword(&p, 0x009e7000);
addword(&p, 0x100009e7); /* nop; nop; nop */
addword(&p, 0x009e7000);
addword(&p, 0x500009e7); /* nop; nop; sbdone */
// Render control list
p = list + 0xe200;
// Clear color
addbyte(&p, 114);
addword(&p, 0xff000000); // Opaque Black
addword(&p, 0xff000000); // 32 bit clear colours need to be repeated twice
addword(&p, 0);
addbyte(&p, 0);
// Tile Rendering Mode Configuration
addbyte(&p, 113);
addword(&p, bus_addr + 0x10000); // framebuffer addresss
addshort(&p, 1920); // width
addshort(&p, 1080); // height
addbyte(&p, 0x04); // framebuffer mode (linear rgba8888)
addbyte(&p, 0x00);
// Do a store of the first tile to force the tile buffer to be cleared
// Tile Coordinates
addbyte(&p, 115);
addbyte(&p, 0);
addbyte(&p, 0);
// Store Tile Buffer General
addbyte(&p, 28);
addshort(&p, 0); // Store nothing (just clear)
addword(&p, 0); // no address is needed
// Link all binned lists together
for(int x = 0; x < 30; x++) {
for(int y = 0; y < 17; y++) {
// Tile Coordinates
addbyte(&p, 115);
addbyte(&p, x);
addbyte(&p, y);
// Call Tile sublist
addbyte(&p, 17);
addword(&p, bus_addr + 0x6200 + (y * 30 + x) * 32);
// Last tile needs a special store instruction
if(x == 29 && y == 16) {
// Store resolved tile color buffer and signal end of frame
addbyte(&p, 25);
} else {
// Store resolved tile color buffer
addbyte(&p, 24);
}
}
}
int render_length = p - (list + 0xe200);
// Run our control list
printf("Binner control list constructed\n");
printf("Start Address: 0x%08x, length: 0x%x\n", bus_addr, length);
v3d[V3D_CT0CA] = bus_addr;
v3d[V3D_CT0EA] = bus_addr + length;
printf("V3D_CT0CS: 0x%08x, Address: 0x%08x\n", v3d[V3D_CT0CS], v3d[V3D_CT0CA]);
// Wait for control list to execute
while(v3d[V3D_CT0CS] & 0x20);
printf("V3D_CT0CS: 0x%08x, Address: 0x%08x\n", v3d[V3D_CT0CS], v3d[V3D_CT0CA]);
printf("V3D_CT1CS: 0x%08x, Address: 0x%08x\n", v3d[V3D_CT1CS], v3d[V3D_CT1CA]);
v3d[V3D_CT1CA] = bus_addr + 0xe200;
v3d[V3D_CT1EA] = bus_addr + 0xe200 + render_length;
while(v3d[V3D_CT1CS] & 0x20);
printf("V3D_CT1CS: 0x%08x, Address: 0x%08x\n", v3d[V3D_CT1CS], v3d[V3D_CT1CA]);
v3d[V3D_CT1CS] = 0x20;
// just dump the frame to a file
FILE *f = fopen("frame.data", "w");
fwrite(list + 0x10000, (1920*1080*4), 1, f);
fclose(f);
printf("frame buffer memory dumpped to frame.data\n");
// Release resources
unmapmem((void *) list, 0x800000);
mem_unlock(mbox, handle);
mem_free(mbox, handle);
}
