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