// <6 const char * zstring::ucase() { unsigned int i;for(i=0;i<=mem_data.mem_length;i++)mem_data.mem_string[i]=toupper(mem_data.mem_string[i]); return mem_data.mem_string; }
_CRTIMP wchar_t towupper(wchar_t c) #endif { return (wchar_t)toupper(c & 0xff); }
/* * Display a dialog box with a list of options that can be turned on or off * The `flag' parameter is used to select between radiolist and checklist. */ int dialog_checklist (const char *title, const char *prompt, int height, int width, int list_height, int item_no, const char * const * items, int flag) { int i, x, y, box_x, box_y; int key = 0, button = 0, choice = 0, scroll = 0, max_choice, *status; WINDOW *dialog, *list; checkflag = flag; /* Allocate space for storing item on/off status */ if ((status = malloc (sizeof (int) * item_no)) == NULL) { endwin (); fprintf (stderr, "\nCan't allocate memory in dialog_checklist().\n"); exit (-1); } /* Initializes status */ for (i = 0; i < item_no; i++) { status[i] = !strcasecmp (items[i * 3 + 2], "on"); if ((!choice && status[i]) || !strcasecmp (items[i * 3 + 2], "selected")) choice = i + 1; } if (choice) choice--; max_choice = MIN (list_height, item_no); /* center dialog box on screen */ x = (COLS - width) / 2; y = (LINES - height) / 2; draw_shadow (stdscr, y, x, height, width); dialog = newwin (height, width, y, x); keypad (dialog, TRUE); draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr); wattrset (dialog, border_attr); mvwaddch (dialog, height-3, 0, ACS_LTEE); for (i = 0; i < width - 2; i++) waddch (dialog, ACS_HLINE); wattrset (dialog, dialog_attr); waddch (dialog, ACS_RTEE); if (title != NULL && strlen(title) >= width-2 ) { /* truncate long title -- mec */ char * title2 = malloc(width-2+1); memcpy( title2, title, width-2 ); title2[width-2] = '\0'; title = title2; } if (title != NULL) { wattrset (dialog, title_attr); mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' '); waddstr (dialog, (char *)title); waddch (dialog, ' '); } wattrset (dialog, dialog_attr); print_autowrap (dialog, prompt, width - 2, 1, 3); list_width = width - 6; box_y = height - list_height - 5; box_x = (width - list_width) / 2 - 1; /* create new window for the list */ list = subwin (dialog, list_height, list_width, y+box_y+1, x+box_x+1); keypad (list, TRUE); /* draw a box around the list items */ draw_box (dialog, box_y, box_x, list_height + 2, list_width + 2, menubox_border_attr, menubox_attr); /* Find length of longest item in order to center checklist */ check_x = 0; for (i = 0; i < item_no; i++) check_x = MAX (check_x, + strlen (items[i * 3 + 1]) + 4); check_x = (list_width - check_x) / 2; item_x = check_x + 4; if (choice >= list_height) { scroll = choice - list_height + 1; choice -= scroll; } /* Print the list */ for (i = 0; i < max_choice; i++) { print_item (list, items[(scroll+i) * 3 + 1], status[i+scroll], i, i == choice); } print_arrows(dialog, choice, item_no, scroll, box_y, box_x + check_x + 5, list_height); print_buttons(dialog, height, width, 0); wnoutrefresh (list); wnoutrefresh (dialog); doupdate (); while (key != ESC) { key = wgetch (dialog); for (i = 0; i < max_choice; i++) if (toupper(key) == toupper(items[(scroll+i)*3+1][0])) break; if ( i < max_choice || key == KEY_UP || key == KEY_DOWN || key == '+' || key == '-' ) { if (key == KEY_UP || key == '-') { if (!choice) { if (!scroll) continue; /* Scroll list down */ if (list_height > 1) { /* De-highlight current first item */ print_item (list, items[scroll * 3 + 1], status[scroll], 0, FALSE); scrollok (list, TRUE); wscrl (list, -1); scrollok (list, FALSE); } scroll--; print_item (list, items[scroll * 3 + 1], status[scroll], 0, TRUE); wnoutrefresh (list); print_arrows(dialog, choice, item_no, scroll, box_y, box_x + check_x + 5, list_height); wrefresh (dialog); continue; /* wait for another key press */ } else i = choice - 1; } else if (key == KEY_DOWN || key == '+') { if (choice == max_choice - 1) { if (scroll + choice >= item_no - 1) continue; /* Scroll list up */ if (list_height > 1) { /* De-highlight current last item before scrolling up */ print_item (list, items[(scroll + max_choice - 1) * 3 + 1], status[scroll + max_choice - 1], max_choice - 1, FALSE); scrollok (list, TRUE); wscrl (list, 1); scrollok (list, FALSE); } scroll++; print_item (list, items[(scroll + max_choice - 1) * 3 + 1], status[scroll + max_choice - 1], max_choice - 1, TRUE); wnoutrefresh (list); print_arrows(dialog, choice, item_no, scroll, box_y, box_x + check_x + 5, list_height); wrefresh (dialog); continue; /* wait for another key press */ } else i = choice + 1; } if (i != choice) { /* De-highlight current item */ print_item (list, items[(scroll + choice) * 3 + 1], status[scroll + choice], choice, FALSE); /* Highlight new item */ choice = i; print_item (list, items[(scroll + choice) * 3 + 1], status[scroll + choice], choice, TRUE); wnoutrefresh (list); wrefresh (dialog); } continue; /* wait for another key press */ } switch (key) { case 'H': case 'h': case '?': fprintf (stderr, "%s", items[(scroll + choice) * 3]); delwin (dialog); free (status); return 1; case TAB: case KEY_LEFT: case KEY_RIGHT: button = ((key == KEY_LEFT ? --button : ++button) < 0) ? 1 : (button > 1 ? 0 : button); print_buttons(dialog, height, width, button); wrefresh (dialog); break; case 'S': case 's': case ' ': case '\n': if (!button) { if (flag == FLAG_CHECK) { status[scroll + choice] = !status[scroll + choice]; wmove (list, choice, check_x); wattrset (list, check_selected_attr); wprintw (list, "[%c]", status[scroll + choice] ? 'X' : ' '); } else { if (!status[scroll + choice]) { for (i = 0; i < item_no; i++) status[i] = 0; status[scroll + choice] = 1; for (i = 0; i < max_choice; i++) print_item (list, items[(scroll + i) * 3 + 1], status[scroll + i], i, i == choice); } } wnoutrefresh (list); wrefresh (dialog); for (i = 0; i < item_no; i++) { if (status[i]) { if (flag == FLAG_CHECK) { fprintf (stderr, "\"%s\" ", items[i * 3]); } else { fprintf (stderr, "%s", items[i * 3]); } } } } else fprintf (stderr, "%s", items[(scroll + choice) * 3]); delwin (dialog); free (status); return button; case 'X': case 'x': key = ESC; case ESC: break; } /* Now, update everything... */ doupdate (); } delwin (dialog); free (status); return -1; /* ESC pressed */ }
static int makelite(struct distress *dist, char *pm) { struct player *sender; struct player *j; struct planet *l; char c; W_Color lcol; sender = &players[dist->sender]; if (!(*pm)) { return (0); } /* first step is to substitute variables */ while (*pm) { if (*pm == '/') { pm++; if (!pm) continue; if (F_beeplite_flags & LITE_COLOR) { /* color lite -JR */ switch (toupper(*(pm + 1))) { case 'G': lcol = W_Green; break; case 'Y': lcol = W_Yellow; break; case 'R': lcol = W_Red; break; case 'C': lcol = W_Cyan; break; case 'E': lcol = W_Grey; break; case 'W': default: lcol = W_White; break; } } else lcol = W_White; switch (c = *(pm++)) { case 'P': /* push player id into buf */ case 'G': /* push friendly player id into buf */ case 'H': /* push enemy target player id into buf */ case 'p': /* push player id into buf */ case 'g': /* push friendly player id into buf */ case 'h': /* push enemy target player id into buf */ switch (c) { case 'p': j = &players[dist->tclose_j]; break; case 'g': j = &players[dist->tclose_fr]; break; case 'h': j = &players[dist->tclose_en]; break; case 'P': j = &players[dist->close_j]; break; case 'G': j = &players[dist->close_fr]; break; default: j = &players[dist->close_en]; break; } liteplayer(j, lcol); break; case 'B': /* highlites planet nearest sender */ case 'b': l = &planets[dist->close_pl]; liteplanet(l, lcol); break; case 'L': /* highlites planet nearest pointer */ case 'l': l = &planets[dist->tclose_pl]; liteplanet(l, lcol); break; case 'U': /* highlites enemy nearest pointer */ case 'u': j = &players[dist->tclose_en]; liteplayer(j, lcol); break; case 'c': /* highlites sender */ case 'I': case 'i': liteplayer(sender, lcol); break; case 'M': /* highlites me */ case 'm': liteplayer(me, lcol); break; case '0': if (F_beeplite_flags & LITE_SOUNDS) W_Beep(); break; default: /* try to continue ** bad macro character is skipped entirely, ** the message will be parsed without whatever argument has occurred. - jn */ warning("Bad Macro character in distress!"); fprintf(stderr, "Unrecognizable special character in " "distress pass 1: %c\n", *(pm - 1)); break; } } else { pm++; } } return (1); }
int VDScriptInterpreter::Token() { static char hexdig[]="0123456789ABCDEF"; char *s,c; if (tokhold) { int t = tokhold; tokhold = 0; return t; } do { c=*tokstr++; } while(c && isspace((unsigned char)c)); if (!c) { --tokstr; return 0; } // C++ style comment? if (c=='/') if (tokstr[0]=='/') { while(*tokstr) ++tokstr; return 0; // C++ comment } else return '/'; // string? if (c=='"') { const char *s = tokstr; char *t; long len_adjust=0; while((c=*tokstr++) && c!='"') { if (c=='\\') { c = *tokstr++; if (!c) SCRIPT_ERROR(PARSE_ERROR); else { if (c=='x') { if (!isxdigit((unsigned char)tokstr[0]) || !isxdigit((unsigned char)tokstr[1])) SCRIPT_ERROR(PARSE_ERROR); tokstr+=2; len_adjust += 2; } ++len_adjust; } } } tokslit = strheap.Allocate(tokstr - s - 1 - len_adjust); t = *tokslit; while(s<tokstr-1) { int val; c = *s++; if (c=='\\') switch(c=*s++) { case 'a': *t++='\a'; break; case 'b': *t++='\b'; break; case 'f': *t++='\f'; break; case 'n': *t++='\n'; break; case 'r': *t++='\r'; break; case 't': *t++='\t'; break; case 'v': *t++='\v'; break; case 'x': val = strchr(hexdig,toupper(s[0]))-hexdig; val = (val<<4) | (strchr(hexdig,toupper(s[1]))-hexdig); *t++ = val; s += 2; break; default: *t++ = c; } else *t++ = c; } *t=0; if (!c) --tokstr; return TOK_STRING; } // unescaped string? if ((c=='u' || c=='U') && *tokstr == '"') { const char *s = ++tokstr; while((c=*tokstr++) && c != '"') ; if (!c) { --tokstr; SCRIPT_ERROR(PARSE_ERROR); } size_t len = tokstr - s - 1; const VDStringA strA(VDTextWToU8(VDTextAToW(s, len))); len = strA.size(); tokslit = strheap.Allocate(len); memcpy(*tokslit, strA.data(), len); (*tokslit)[len] = 0; return TOK_STRING; } // look for variable/keyword if (isIdentFirstChar(c)) { s = szIdent; *s++ = c; while(isIdentNextChar(c = *tokstr++)) { if (s>=szIdent + MAX_IDENT_CHARS) SCRIPT_ERROR(IDENT_TOO_LONG); *s++ = c; } --tokstr; *s=0; if (!strcmp(szIdent, "declare")) return TOK_DECLARE; else if (!strcmp(szIdent, "true")) return TOK_TRUE; else if (!strcmp(szIdent, "false")) return TOK_FALSE; else if (!strcmp(szIdent, "int")) return TOK_INT; else if (!strcmp(szIdent, "long")) return TOK_LONG; else if (!strcmp(szIdent, "double")) return TOK_DOUBLE; return TOK_IDENT; } // test for number: decimal (123), octal (0123), or hexadecimal (0x123) if (isdigit((unsigned char)c)) { sint64 v = 0; if (c=='0' && tokstr[0] == 'x') { // hex (base 16) ++tokstr; while(isxdigit((unsigned char)(c = *tokstr++))) { v = v*16 + (strchr(hexdig, toupper(c))-hexdig); } } else if (c=='0' && isdigit((unsigned char)tokstr[0])) { // octal (base 8) while((c=*tokstr++)>='0' && c<='7') v = v*8 + (c-'0'); } else { // check for float const char *s = tokstr; while(*s) { if (*s == '.' || *s == 'e' || *s == 'E') { // It's a float -- parse and return. --tokstr; tokdval = strtod(tokstr, (char **)&tokstr); return TOK_DBLVAL; } if (!isdigit((unsigned char)*s)) break; ++s; } // decimal v = (c-'0'); while(isdigit((unsigned char)(c=*tokstr++))) v = v*10 + (c-'0'); } --tokstr; if (v > 0x7FFFFFFF) { toklval = v; return TOK_LONGVAL; } else { tokival = (int)v; return TOK_INTVAL; } } // test for symbols: // // charset: +-*/<>=!&|^[]~;%(), // solitary: +-*/<>=!&|^[]~;%(), // extra: != <= >= == && || // // the '/' is handled above for comment handling if (c=='!') if (tokstr[0] == '=') { ++tokstr; return TOK_NOTEQ; } else return '!'; if (c=='<') if (tokstr[0] == '=') { ++tokstr; return TOK_LESSEQ; } else return '<'; if (c=='>') if (tokstr[0] == '=') { ++tokstr; return TOK_GRTREQ; } else return '>'; if (c=='=') if (tokstr[0] == '=') { ++tokstr; return TOK_EQUALS; } else return '='; if (c=='&') if (tokstr[0] == '&') { ++tokstr; return TOK_AND; } else return '&'; if (c=='|') if (tokstr[0] == '|') { ++tokstr; return TOK_OR; } else return '|'; if (strchr("+-*^[]~;%(),.",c)) return c; SCRIPT_ERROR(PARSE_ERROR); }
void AsUppercaseTokens ( char *Buffer, char *PrefixString) { char *SubBuffer; char *TokenEnd; char *SubString; int i; UINT32 Length; SubBuffer = Buffer; while (SubBuffer) { SubBuffer = strstr (SubBuffer, PrefixString); if (SubBuffer) { TokenEnd = SubBuffer; while ((isalnum ((int) *TokenEnd)) || (*TokenEnd == '_')) { TokenEnd++; } for (i = 0; i < (TokenEnd - SubBuffer); i++) { if ((islower ((int) SubBuffer[i])) && (isupper ((int) SubBuffer[i+1]))) { SubString = TokenEnd; Length = 0; while (*SubString != '\n') { if ((SubString[0] == ' ') && (SubString[1] == ' ')) { Length = SubString - &SubBuffer[i] - 2; break; } SubString++; } if (!Length) { Length = strlen (&SubBuffer[i+1]); } memmove (&SubBuffer[i+2], &SubBuffer[i+1], (Length+1)); SubBuffer[i+1] = '_'; i +=2; TokenEnd++; } } for (i = 0; i < (TokenEnd - SubBuffer); i++) { SubBuffer[i] = (char) toupper ((int) SubBuffer[i]); } SubBuffer = TokenEnd; } } }
char * strToUpper(char *str) { while(*str=toupper(*str)) str++; }
void input_poll(void) { SDL_Event evt; int ino, key; #ifdef __native_client__ { /* Process all waiting events without blocking */ PSEvent* event = NULL; while ((event = PSEventTryAcquire()) != NULL) { ProcessEvent(event); PSEventRelease(event); } } #endif while(SDL_PollEvent(&evt)) { switch(evt.type) { case SDL_KEYDOWN: case SDL_KEYUP: { key = evt.key.keysym.sym; #ifndef __SDLSHIM__ static uint8_t shiftstates = 0; extern bool freezeframe; if (console.IsVisible() && !IsNonConsoleKey(key)) { if (key == SDLK_LSHIFT) { if (evt.type == SDL_KEYDOWN) shiftstates |= LEFTMASK; else shiftstates &= ~LEFTMASK; } else if (key == SDLK_RSHIFT) { if (evt.type == SDL_KEYDOWN) shiftstates |= RIGHTMASK; else shiftstates &= ~RIGHTMASK; } else { int ch = key; if (shiftstates != 0) { ch = toupper(ch); if (ch == '.') ch = '>'; if (ch == '-') ch = '_'; if (ch == '/') ch = '?'; if (ch == '1') ch = '!'; } if (evt.type == SDL_KEYDOWN) console.HandleKey(ch); else console.HandleKeyRelease(ch); } } else #endif // __SDLSHIM__ { ino = mappings[key]; if (ino != 0xff) inputs[ino] = (evt.type == SDL_KEYDOWN); if (evt.type == SDL_KEYDOWN) { if (Replay::IsPlaying() && ino <= LASTCONTROLKEY) { stat("user interrupt - stopping playback of replay"); Replay::end_playback(); memset(inputs, 0, sizeof(inputs)); inputs[ino] = true; } #ifndef __SDLSHIM__ if (key == '`') // bring up console { if (!freezeframe) { sound(SND_SWITCH_WEAPON); console.SetVisible(true); } } else #endif { last_sdl_key = key; } } } } break; case SDL_QUIT: { inputs[ESCKEY] = true; game.running = false; } break; } } }
PTABDEF OEMDEF::GetXdef(PGLOBAL g) { typedef PTABDEF (__stdcall *XGETDEF) (PGLOBAL, void *); char c, getname[40] = "Get"; PTABDEF xdefp; XGETDEF getdef = NULL; PCATLG cat = Cat; #if defined(WIN32) // Is the DLL already loaded? if (!Hdll && !(Hdll = GetModuleHandle(Module))) // No, load the Dll implementing the function if (!(Hdll = LoadLibrary(Module))) { char buf[256]; DWORD rc = GetLastError(); sprintf(g->Message, MSG(DLL_LOAD_ERROR), rc, Module); FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, rc, 0, (LPTSTR)buf, sizeof(buf), NULL); strcat(strcat(g->Message, ": "), buf); return NULL; } // endif hDll // The exported name is always in uppercase for (int i = 0; ; i++) { c = Subtype[i]; getname[i + 3] = toupper(c); if (!c) break; } // endfor i // Get the function returning an instance of the external DEF class if (!(getdef = (XGETDEF)GetProcAddress((HINSTANCE)Hdll, getname))) { sprintf(g->Message, MSG(PROCADD_ERROR), GetLastError(), getname); FreeLibrary((HMODULE)Hdll); return NULL; } // endif getdef #else // !WIN32 const char *error = NULL; // Is the library already loaded? // if (!Hdll && !(Hdll = ???)) // Load the desired shared library if (!(Hdll = dlopen(Module, RTLD_LAZY))) { error = dlerror(); sprintf(g->Message, MSG(SHARED_LIB_ERR), Module, SVP(error)); return NULL; } // endif Hdll // The exported name is always in uppercase for (int i = 0; ; i++) { c = Subtype[i]; getname[i + 3] = toupper(c); if (!c) break; } // endfor i // Get the function returning an instance of the external DEF class if (!(getdef = (XGETDEF)dlsym(Hdll, getname))) { error = dlerror(); sprintf(g->Message, MSG(GET_FUNC_ERR), getname, SVP(error)); dlclose(Hdll); return NULL; } // endif getdef #endif // !WIN32 // Just in case the external Get function does not set error messages sprintf(g->Message, MSG(DEF_ALLOC_ERROR), Subtype); // Get the table definition block if (!(xdefp = getdef(g, NULL))) return NULL; // Have the external class do its complete definition if (!cat->Cbuf) { // Suballocate a temporary buffer for the entire column section cat->Cblen = cat->GetSizeCatInfo("Colsize", "8K"); cat->Cbuf = (char*)PlugSubAlloc(g, NULL, cat->Cblen); } // endif Cbuf // Here "OEM" should be replace by a more useful value if (xdefp->Define(g, cat, Name, "OEM")) return NULL; // Ok, return external block return xdefp; } // end of GetXdef
/********************************************************************** * Function repeats_menu() * * Parameter: * * * This function prompts user to choose an algorithm to compute * repeats and similar things. * The utilities menu is also available from this menu. * **********************************************************************/ void repeats_menu() { static int smax_percent = 0; static int smax_minlen = 0; int status, num_lines; char ch; STRING *text; while (1) { num_lines = 20; printf("\n** Repeats Menu **\n\n"); printf("1) Find primitive tandem repeats (Crochemore's algorithm)\n"); printf("2) Find supermaximals and near supermaximals of a string\n"); printf("3) Find nonoverlapping maximals of a string" " (Crochemore variant)\n"); printf("4) Find nonoverlapping maximals of a string" " (big path algorithm)\n"); printf("5) Find tandem repeats/tandem arrays using the suffix tree\n"); printf("6) Find vocabulary of tandem repeats (and more) using\n"); printf(" a) Ziv-Lempel decomposition\n"); printf(" b) nonoverlapping blocks decomposition (as in the book)\n"); printf("7) Find occurrences in linear time (without suffix tree) using\n"); printf(" a) Ziv-Lempel decomposition\n"); printf(" b) nonoverlapping blocks decomposition (as in the book)\n"); printf("*) String Utilites\n"); printf("0) Exit\n"); printf("\nEnter Selection: "); while ((choice = my_getline(stdin, &ch_len)) == NULL) ; switch (choice[0]) { case '0': return; case '1': if (!(text = get_string("string"))) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe string:\n"); terse_print_string(text); mputc('\n'); status = map_sequences(text, NULL, NULL, 0); if (status != -1) { strmat_repeats_primitives(text, stats_flag); unmap_sequences(text, NULL, NULL, 0); } mend(num_lines); putchar('\n'); break; case '2': if (!(text = get_string("text"))) continue; smax_percent = get_bounded("Percent Supermaximal", 0, 100, smax_percent); printf("\n"); if (smax_percent == -1) continue; smax_minlen = get_bounded("Supermax. Minimum Length", 0, text->length, smax_minlen); printf("\n"); if (smax_minlen == -1) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe text:\n"); terse_print_string(text); mputc('\n'); status = map_sequences(text, NULL, NULL, 0); if (status != -1) { mprintf("Finding the supermaximals...\n\n"); strmat_repeats_supermax(text, smax_percent, smax_minlen); unmap_sequences(text, NULL, NULL, 0); } mend(num_lines); putchar('\n'); break; case '3': if (!(text = get_string("string"))) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe string:\n"); terse_print_string(text); mputc('\n'); status = map_sequences(text, NULL, NULL, 0); if (status != -1) { strmat_repeats_nonoverlapping(text, stats_flag); unmap_sequences(text, NULL, NULL, 0); } mend(num_lines); putchar('\n'); break; case '4': if (!(text = get_string("string"))) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe string:\n"); terse_print_string(text); mputc('\n'); status = map_sequences(text, NULL, NULL, 0); if (status != -1) { strmat_repeats_bigpath(text, stree_build_policy, stree_build_threshold, stats_flag); unmap_sequences(text, NULL, NULL, 0); } mend(num_lines); putchar('\n'); break; case '5': if (!(text = get_string("string"))) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe string:\n"); terse_print_string(text); mputc('\n'); status = map_sequences(text, NULL, NULL, 0); if (status != -1) { strmat_repeats_tandem(text, stree_build_policy, stree_build_threshold, stats_flag); unmap_sequences(text, NULL, NULL, 0); } mend(num_lines); putchar('\n'); break; case '6': ch = toupper(choice[1]); if (ch!='A' && ch!='B') { printf("\nYou must specify which type of decomposition to use" "(as in '6a' or '6b').\n"); continue; } if (!(text = get_string("string"))) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe string:\n"); terse_print_string(text); mputc('\n'); status = map_sequences(text, NULL, NULL, 0); if (status != -1) { strmat_repeats_vocabulary(text, stree_build_policy, stree_build_threshold, stats_flag,ch); unmap_sequences(text, NULL, NULL, 0); } mend(num_lines); putchar('\n'); break; case '7': ch = toupper(choice[1]); if (ch!='A' && ch!='B') { printf("\nYou must specify which type of decomposition to use" "(as in '7a' or '7b').\n"); continue; } if (!(text = get_string("string"))) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe string:\n"); terse_print_string(text); mputc('\n'); status = map_sequences(text, NULL, NULL, 0); if (status != -1) { strmat_repeats_linear_occs(text, stree_build_policy, stree_build_threshold, stats_flag,ch); unmap_sequences(text, NULL, NULL, 0); } mend(num_lines); putchar('\n'); break; case '*': util_menu(); break; default: printf("\nThat is not a choice.\n"); } } }
int main() { int listenSocket[2], connectSocket, status, i; unsigned short int msgLength; struct addrinfo hints, *servinfo, *p; struct sockaddr_storage clientAddress; socklen_t clientAddressLength = sizeof clientAddress; void *addr; char msg[MSG_ARRAY_SIZE], listenPort[PORT_ARRAY_SIZE], ipstr[INET6_ADDRSTRLEN]; int optval = 1; // socket double et IPV6_V6ONLY à 1 bool sockSuccess = false; struct timeval timeVal; fd_set readSet[2]; listenSocket[v4] = listenSocket[v6] = -1; memset(listenPort, 0, sizeof listenPort); // Mise à zéro du tampon puts("Entrez le numéro de port utilisé en écoute (entre 1500 et 65000) : "); scanf("%"xstr(MAX_PORT)"s", listenPort); memset(&hints, 0, sizeof hints); hints.ai_family = AF_UNSPEC; // IPv6 et IPv4 hints.ai_socktype = SOCK_STREAM; hints.ai_flags = AI_PASSIVE; // use my IP if ((status = getaddrinfo(NULL, listenPort, &hints, &servinfo)) != 0) { fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(status)); return 1; } // Scrutation des résultats et création de socket // Sortie après création d'une «prise» IPv4 et d'une «prise» IPv6 p = servinfo; while ((p != NULL) && !sockSuccess) { // Identification de l'adresse courante if (p->ai_family == AF_INET) { // IPv4 struct sockaddr_in *ipv4 = (struct sockaddr_in *)p->ai_addr; addr = &(ipv4->sin_addr); // conversion de l'adresse IP en une chaîne de caractères inet_ntop(p->ai_family, addr, ipstr, sizeof ipstr); printf(" IPv4: %s\n", ipstr); if ((listenSocket[v4] = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) { perror("socket:"); // Echec ouverture socket } else if (bind(listenSocket[v4], p->ai_addr, p->ai_addrlen) == -1) { close(listenSocket[v4]); perror("bind:"); listenSocket[v4] = -1; // Echec socket en écoute } } else { // IPv6 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)p->ai_addr; addr = &(ipv6->sin6_addr); // conversion de l'adresse IP en une chaîne de caractères inet_ntop(p->ai_family, addr, ipstr, sizeof ipstr); printf(" IPv6: %s\n", ipstr); if ((listenSocket[v6] = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) { perror("socket:"); // Echec ouverture socket } else if (setsockopt(listenSocket[v6], IPPROTO_IPV6, IPV6_V6ONLY, &optval, sizeof optval) == -1) { perror("setsockopt:"); listenSocket[v6] = -1; // Echec option bindv6only=1 } else if (bind(listenSocket[v6], p->ai_addr, p->ai_addrlen) == -1) { close(listenSocket[v6]); perror("bind:"); listenSocket[v6] = -1; // Echec socket en écoute } } if ((listenSocket[v4] != -1) && (listenSocket[v6] != -1)) // deux prises ouvertes sockSuccess = true; else p = p->ai_next; // Enregistrement d'adresse suivant } if (p == NULL) { fputs("Création de socket impossible\n", stderr); exit(EXIT_FAILURE); } // Libération de la mémoire occupée par les enregistrements freeaddrinfo(servinfo); printf("Attente de requête sur le port %s\n", listenPort); // Utilisation de select en mode scrutation timeVal.tv_sec = 0; timeVal.tv_usec = 0; // Attente des requêtes des clients. // Appel non bloquant et passage en mode passif // Demandes d'ouverture de connexion traitées par accept if (listen(listenSocket[v4], BACKLOG) == -1) { perror("listen"); exit(EXIT_FAILURE); } if (listen(listenSocket[v6], BACKLOG) == -1) { perror("listen:"); exit(EXIT_FAILURE); } while (1) { FD_ZERO(&readSet[v4]); FD_SET(listenSocket[v4], &readSet[v4]); FD_ZERO(&readSet[v6]); FD_SET(listenSocket[v6], &readSet[v6]); if (select(listenSocket[v4]+1, &readSet[v4], NULL, NULL, &timeVal) == -1) { // IPv4 perror("select:"); exit(EXIT_FAILURE); } if (select(listenSocket[v6]+1, &readSet[v6], NULL, NULL, &timeVal) == -1) { // IPv6 perror("select:"); exit(EXIT_FAILURE); } if (FD_ISSET(listenSocket[v4], &readSet[v4])) { // IPv4 // Appel bloquant en attente d'une nouvelle connexion // connectSocket est la nouvelle prise utilisée pour la connexion active if ((connectSocket = accept(listenSocket[v4], (struct sockaddr *) &clientAddress, &clientAddressLength)) == -1) { perror("accept:"); close(listenSocket[v4]); exit(EXIT_FAILURE); } // Affichage de l'adresse IP du client. inet_ntop(clientAddress.ss_family, get_in_addr((struct sockaddr *)&clientAddress), ipstr, sizeof ipstr); printf(">> connecté à [%s]:", ipstr); // Affichage du numéro de port du client. printf("%hu\n", ntohs(get_in_port((struct sockaddr *)&clientAddress))); // Mise à zéro du tampon de façon à connaître le délimiteur // de fin de chaîne. memset(msg, 0, sizeof msg); while (recv(connectSocket, msg, sizeof msg, 0) > 0) if ((msgLength = strlen(msg)) > 0) { printf(" -- %s\n", msg); // Conversion de cette ligne en majuscules. for (i = 0; i < msgLength; i++) msg[i] = toupper(msg[i]); // Renvoi de la ligne convertie au client. if (send(connectSocket, msg, msgLength, 0) == -1) { perror("send:"); close(listenSocket[v4]); exit(EXIT_FAILURE); } memset(msg, 0, sizeof msg); // Mise à zéro du tampon } } if (FD_ISSET(listenSocket[v6], &readSet[v6])) { // IPv6 // Appel bloquant en attente d'une nouvelle connexion // connectSocket est la nouvelle prise utilisée pour la connexion active if ((connectSocket = accept(listenSocket[v6], (struct sockaddr *) &clientAddress, &clientAddressLength)) == -1) { perror("accept:"); close(listenSocket[v6]); exit(EXIT_FAILURE); } // Affichage de l'adresse IP du client. inet_ntop(clientAddress.ss_family, get_in_addr((struct sockaddr *)&clientAddress), ipstr, sizeof ipstr); printf(">> connecté à [%s]:", ipstr); // Affichage du numéro de port du client. printf("%hu\n", ntohs(get_in_port((struct sockaddr *)&clientAddress))); // Mise à zéro du tampon de façon à connaître le délimiteur // de fin de chaîne. memset(msg, 0, sizeof msg); while (recv(connectSocket, msg, sizeof msg, 0) > 0) if ((msgLength = strlen(msg)) > 0) { printf(" -- %s\n", msg); // Conversion de cette ligne en majuscules. for (i = 0; i < msgLength; i++) msg[i] = toupper(msg[i]); // Renvoi de la ligne convertie au client. if (send(connectSocket, msg, msgLength, 0) == -1) { perror("send:"); close(listenSocket[v6]); exit(EXIT_FAILURE); } memset(msg, 0, sizeof msg); // Mise à zéro du tampon } } } // jamais atteint return 0; }
/********************************************************************** * Function suf_tree_menu() * * Parameter: * * * This function prompts user to choose an algorithm to create * a suffix tree and use it. * The utilities menu is also available from this menu. * **********************************************************************/ void suf_tree_menu() { int i, status, num_lines, num_strings; char ch; STRING *pattern, **strings, *text; while (1) { num_lines = 18; printf("\n** Suffix Tree Menu **\n\n"); printf("1) Build a suffix tree using Ukkonen's algorithm\n"); printf("2) Build a suffix tree using Weiner's algorithm\n"); printf("3) Exact matching using a suffix tree for the text\n"); printf("4) Walk around a suffix tree\n"); printf("5) Compute the LCA values for a suffix tree\n"); printf(" a) using the naive LCA algorithm\n"); printf(" b) using the constant time LCA algorithm\n"); printf("6) Compute Lempel-Ziv decomposition\n"); printf(" a) original version (f-factorization)\n"); printf(" b) nonoverlapping blocks (as in the book)\n"); printf("8) Set suffix tree build policy (current: "); switch(stree_build_policy) { case LINKED_LIST: printf("linked list)\n"); break; case SORTED_LIST: printf("sorted list)\n"); break; case LIST_THEN_ARRAY: printf("list then array, threshold %d)\n", stree_build_threshold); break; case COMPLETE_ARRAY: printf("complete array)\n"); break; } printf("9) Suffix tree print toggle (current: %s)\n", (stree_print_flag == ON ? "on" : "off")); printf("*) String Utilites\n"); printf("0) Exit\n"); printf("\nEnter Selection: "); while ((choice = my_getline(stdin, &ch_len)) == NULL) ; switch (choice[0]) { case '0': return; case '1': strings = get_string_ary("list of sequences", &num_strings); if (strings == NULL) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe sequences:\n"); for (i=0; i < num_strings; i++) { mprintf("%2d)", i + 1); terse_print_string(strings[i]); } mputc('\n'); status = map_sequences(NULL, NULL, strings, num_strings); if (status != -1) { mprintf("Executing Ukkonen's Algorithm...\n\n"); strmat_ukkonen_build(strings, num_strings, stree_build_policy, stree_build_threshold, stats_flag, stree_print_flag); unmap_sequences(NULL, NULL, strings, num_strings); } mend(num_lines); putchar('\n'); free(strings); break; case '2': strings = get_string_ary("list of sequences", &num_strings); if (strings == NULL) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe sequences:\n"); for (i=0; i < num_strings; i++) { mprintf("%2d)", i + 1); terse_print_string(strings[i]); } mputc('\n'); status = map_sequences(NULL, NULL, strings, num_strings); if (status != -1) { mprintf("Executing Weiner's Algorithm...\n\n"); strmat_weiner_build(strings, num_strings, stree_build_policy, stree_build_threshold, stats_flag, stree_print_flag); unmap_sequences(NULL, NULL, strings, num_strings); } mend(num_lines); putchar('\n'); free(strings); break; case '3': if (!(pattern = get_string("pattern")) || !(strings = get_string_ary("list of sequences", &num_strings))) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe pattern:\n"); terse_print_string(pattern); mprintf("\nThe texts:\n"); for (i=0; i < num_strings; i++) { mprintf("%2d)", i + 1); terse_print_string(strings[i]); } mputc('\n'); status = map_sequences(NULL, pattern, strings, num_strings); if (status != -1) { mprintf("Executing exact matching with a suffix tree...\n\n"); strmat_stree_match(pattern, strings, num_strings, stree_build_policy, stree_build_threshold, stats_flag); unmap_sequences(NULL, pattern, strings, num_strings); } mend(num_lines); putchar('\n'); free(strings); break; case '4': strings = get_string_ary("list of sequences", &num_strings); if (strings == NULL) continue; status = map_sequences(NULL, NULL, strings, num_strings); if (status != -1) { strmat_stree_walkaround(strings, num_strings, stree_build_policy, stree_build_threshold); unmap_sequences(NULL, NULL, strings, num_strings); } putchar('\n'); free(strings); break; case '5': ch = toupper(choice[1]); if (ch != 'A' && ch != 'B') { printf("\nYou must specify which type of LCA algorithm to use " "(as in '3a' or '3b').\n"); continue; } strings = get_string_ary("list of sequences", &num_strings); if (strings == NULL) continue; status = map_sequences(NULL, NULL, strings, num_strings); if (status != -1) { if (ch == 'A') strmat_stree_naive_lca(strings, num_strings, stree_build_policy, stree_build_threshold, stats_flag); else strmat_stree_lca(strings, num_strings, stree_build_policy, stree_build_threshold, stats_flag); unmap_sequences(NULL, NULL, strings, num_strings); } putchar('\n'); free(strings); break; case '6': ch = toupper(choice[1]); if (ch!='A' && ch!='B') { printf("\nYou must specify which type of decomposition to compute " "(as in '6a' or '6b').\n"); continue; } if (!(text = get_string("string"))) continue; mstart(stdin, fpout, OK, OK, 0, NULL); mprintf("\nThe string:\n"); terse_print_string(text); mputc('\n'); status = map_sequences(text, NULL, NULL, 0); if(status != -1) { strmat_stree_lempel_ziv(text, stree_build_policy, stree_build_threshold, stats_flag,ch); unmap_sequences(text, NULL, NULL, 0); } mend(num_lines); putchar('\n'); break; case '8': choice = "0"; while (choice[0] != '1' && choice[0] != '2' && choice[0] != '3' && choice[0] != '4') { printf("\n** Suffix Tree Build Policies **\n"); printf("\n(1 - linked list, 2 - sorted list, 3 - linked list/array," " 4 - complete array)\n"); printf("Enter Build Policy [%d]: ", (stree_build_policy == LINKED_LIST ? 1 : (stree_build_policy == SORTED_LIST ? 2 : (stree_build_policy == LIST_THEN_ARRAY ? 3 : 4)))); if ((choice = my_getline(stdin, &ch_len)) == NULL || choice[0] == '\0') break; switch (choice[0]) { case '1': stree_build_policy = LINKED_LIST; break; case '2': stree_build_policy = SORTED_LIST; break; case '3': stree_build_policy = LIST_THEN_ARRAY; break; case '4': stree_build_policy = COMPLETE_ARRAY; break; default: printf("\nThat is not a choice.\n"); } } if (stree_build_policy == LIST_THEN_ARRAY) { printf("\nEnter Build Threshold [%d]: ", stree_build_threshold); if ((choice = my_getline(stdin, &ch_len)) != NULL) sscanf(choice, "%d", &stree_build_threshold); } putchar('\n'); break; case '9': if (stree_print_flag == ON) stree_print_flag = OFF; else stree_print_flag = ON; break; case '*': util_menu(); break; default: printf("\nThat is not a choice.\n"); } } }
/********************************************************************** * Function z_alg_menu(); * * Parameter: * * * This function prompts user to create and utilize the Z values * for a string. The utilities menu is also available from this menu. * **********************************************************************/ void z_alg_menu() { int status, num_lines; char ch; STRING *text, *pattern; while (1) { num_lines = 12; printf("\n** Z-value Algorithm Menu **\n\n"); printf("1) Build Z values for a sequence\n"); printf("2) Exact matching using Z values\n"); printf("3) Knuth-Morris-Pratt (Z-values preprocessing)\n"); printf(" a) using sp values\n"); printf(" b) using sp' values\n"); printf("*) String Utilites\n"); printf("0) Exit\n"); printf("\nEnter Selection: "); while ((choice = my_getline(stdin, &ch_len)) == NULL) ; switch (choice[0]) { case '0': return; case '1': if (!(text = get_string("text"))) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mputs("The string:\n"); terse_print_string(text); status = map_sequences(text, NULL, NULL, 0); if (status != -1) { mputs("Building Z values...\n\n"); strmat_z_build(text, stats_flag); unmap_sequences(text, NULL, NULL, 0); } mend(num_lines); putchar('\n'); break; case '2': if (!(pattern = get_string("pattern")) || !(text = get_string("text"))) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mputs("\nThe pattern:\n"); terse_print_string(pattern); mputs("\nThe text:\n"); terse_print_string(text); mputc('\n'); status = map_sequences(text, pattern, NULL, 0); if (status != -1) { mputs("Executing exact matching with Z values algorithm...\n\n"); strmat_z_match(pattern, text, stats_flag); unmap_sequences(text, pattern, NULL, 0); } mend(num_lines); putchar('\n'); break; case '3': ch = choice[1]; if (toupper(ch) != 'A' && toupper(ch) != 'B') { printf("\nYou must specify the KMP variation (as in '3a' or '3b').\n"); continue; } if (!(pattern = get_string("pattern")) || !(text = get_string("text"))) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe pattern:\n"); terse_print_string(pattern); mprintf("\nThe text:\n"); terse_print_string(text); mputc('\n'); status = map_sequences(text, pattern, NULL, 0); if (status != -1) { if (toupper(ch) == 'A') { mprintf ("Executing KMP with sp values...\n\n"); strmat_kmp_sp_z_match(pattern, text, stats_flag); } else { mprintf ("Executing KMP with sp' values...\n\n"); strmat_kmp_spprime_z_match(pattern, text, stats_flag); } unmap_sequences(text, pattern, NULL, 0); } mend(num_lines); putchar('\n'); break; case '*': util_menu(); break; default: printf("\nThat is not a choice.\n"); } } }
/********************************************************************** * Function basic_alg_menu(); * * Parameter: * * * This function prompts user to choose a basic algorithm to execute * such as Boyer-Moore. The utilities menu is also available from * this menu. * **********************************************************************/ void basic_alg_menu() { int i, status, num_lines, alpha_size, num_patterns; char ch; STRING *text, *pattern, **patterns; alpha_size = 0; while (1) { num_lines = 22; printf("\n** Basic Search Algorithm Menu **\n\n"); printf("1) Naive Algorithm\n"); printf("2) Boyer-Moore Variations\n"); printf(" a) Bad character rule\n"); printf(" b) Extended bad character rule\n"); printf(" c) Good suffix & bad character rules\n"); printf(" d) Good suffix & extended bad character rules\n"); printf("3) Knuth-Morris-Pratt (original preprocessing)\n"); printf(" a) using sp values\n"); printf(" b) using sp' values\n"); printf("4) Aho-Corasick Set Matching\n"); printf("5) Boyer-Moore Set Matching\n"); printf(" a) Bad character rule only\n"); printf(" b) Good suffix rule using keyword and suffix trees\n"); printf(" c) Good suffix rule using suffix tree only\n"); printf(" d) using original Boyer-Moore (1c) on each pattern\n"); printf("*) String Utilites\n"); printf("0) Exit\n"); printf("\nEnter Selection: "); while ((choice = my_getline(stdin, &ch_len)) == NULL) ; switch (choice[0]) { case '0': return; case '1': if (!(pattern = get_string("pattern")) || !(text = get_string("text"))) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe pattern:\n"); terse_print_string(pattern); mprintf("\nThe text:\n"); terse_print_string(text); mputc('\n'); status = map_sequences(text, pattern, NULL, 0); if (status != -1) { mprintf ("Executing naive search algorithm...\n\n"); strmat_naive_match(pattern, text, stats_flag); unmap_sequences(text, pattern, NULL, 0); } mend(num_lines); putchar('\n'); break; case '2': ch = choice[1]; if (toupper(ch) != 'A' && toupper(ch) != 'B' && toupper(ch) != 'C' && toupper(ch) != 'D') { printf("\nYou must specify the Boyer-Moore variation" " (as in '2a' or '2c').\n"); continue; } if (!(pattern = get_string("pattern")) || !(text = get_string("text"))) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe pattern:\n"); terse_print_string(pattern); mprintf("\nThe text:\n"); terse_print_string(text); mputc('\n'); status = map_sequences(text, pattern, NULL, 0); if (status != -1) { mprintf("Executing Boyer-Moore algorithm...\n\n"); switch (toupper(ch)) { case 'A': strmat_bmbad_match(pattern, text, stats_flag); break; case 'B': strmat_bmext_match(pattern, text, stats_flag); break; case 'C': strmat_bmgood_match(pattern, text, stats_flag); break; case 'D': strmat_bmextgood_match(pattern, text, stats_flag); break; } unmap_sequences(text, pattern, NULL, 0); } mend(num_lines); putchar('\n'); break; case '3': ch = choice[1]; if (toupper(ch) != 'A' && toupper(ch) != 'B') { printf("\nYou must specify the KMP variation (as in '3a' or '3b').\n"); continue; } if (!(pattern = get_string("pattern")) || !(text = get_string("text"))) continue; mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe pattern:\n"); terse_print_string(pattern); mprintf("\nThe text:\n"); terse_print_string(text); mputc('\n'); status = map_sequences(text, pattern, NULL, 0); if (status != -1) { if (toupper(ch) == 'A') { mprintf ("Executing KMP with sp values...\n\n"); strmat_kmp_sp_orig_match(pattern, text, stats_flag); } else { mprintf ("Executing KMP with sp' values...\n\n"); strmat_kmp_spprime_orig_match(pattern, text, stats_flag); } unmap_sequences(text, pattern, NULL, 0); } mend(num_lines); putchar('\n'); break; case '4': if (!(patterns = get_string_ary("list of patterns", &num_patterns))) continue; if (!(text = get_string("text"))) { free(patterns); continue; } mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe patterns:\n"); for (i=0; i < num_patterns; i++) { mprintf("%2d)", i + 1); terse_print_string(patterns[i]); } mprintf("\nThe text:\n"); terse_print_string(text); mputc('\n'); status = map_sequences(text, NULL, patterns, num_patterns); if (status != -1) { mprintf("Executing Aho-Corasick algorithm...\n\n"); strmat_ac_match(patterns, num_patterns, text, stats_flag); unmap_sequences(text, NULL, patterns, num_patterns); } mend(num_lines); putchar('\n'); free(patterns); break; case '5': ch = toupper(choice[1]); if (ch != 'A' && ch != 'B' && ch != 'C' && ch != 'D') { printf("\nYou must specify the set Boyer-Moore variation" " (as in '5a' or '5c').\n"); continue; } if (!(patterns = get_string_ary("list of patterns", &num_patterns))) continue; if (!(text = get_string("text"))) { free(patterns); continue; } mstart(stdin, fpout, OK, OK, 5, NULL); mprintf("\nThe patterns:\n"); for (i=0; i < num_patterns; i++) { mprintf("%2d)", i + 1); terse_print_string(patterns[i]); } mprintf("\nThe text:\n"); terse_print_string(text); mputc('\n'); status = map_sequences(text, NULL, patterns, num_patterns); if (status != -1) { mprintf("Executing Boyer-Moore set matching algorithm...\n\n"); switch (toupper(ch)) { case 'A': strmat_bmset_badonly_match(patterns, num_patterns, text, stats_flag); break; case 'B': strmat_bmset_2trees_match(patterns, num_patterns, text, stats_flag); break; case 'C': strmat_bmset_1tree_match(patterns, num_patterns, text, stats_flag); break; case 'D': strmat_bmset_naive_match(patterns, num_patterns, text, stats_flag); break; } unmap_sequences(text, NULL, patterns, num_patterns); } mend(num_lines); putchar('\n'); free(patterns); break; case '*': util_menu(); break; default: printf("\nThat is not a choice.\n"); } } }
std::string julian_short_month_name(unsigned month) { auto s = julian_month_name(month).substr(0, 3); s[1] = (char)toupper(s[1]); s[2] = (char)toupper(s[2]); return s; }
void R_InitSkins (void) { char sndname[128]; int sndlumps[8]; char key[10]; int intname; size_t i; int j, k, base; int stop; char *def; key[9] = 0; for (i = 1; i < numskins; i++) { for (j = 0; j < 8; j++) sndlumps[j] = -1; base = W_CheckNumForName ("S_SKIN", skins[i].namespc); // The player sprite has 23 frames. This means that the S_SKIN // marker needs a minimum of 23 lumps after it (probably more). if (base + 23 >= (int)numlumps || base == -1) continue; def = (char *)W_CacheLumpNum (base, PU_CACHE); intname = 0; // Data is stored as "key = data". while ( (def = COM_Parse (def)) ) { strncpy (key, com_token, 9); def = COM_Parse (def); if (com_token[0] != '=') { Printf (PRINT_HIGH, "Bad format for skin %d: %s %s", i, key, com_token); break; } def = COM_Parse (def); if (!stricmp (key, "name")) { strncpy (skins[i].name, com_token, 16); } else if (!stricmp (key, "sprite")) { for (j = 3; j >= 0; j--) com_token[j] = toupper (com_token[j]); intname = *((int *)com_token); } else if (!stricmp (key, "face")) { for (j = 2; j >= 0; j--) skins[i].face[j] = toupper (com_token[j]); } else { for (j = 0; j < 8; j++) { if (!stricmp (key, skinsoundnames[j][0])) { // Can't use W_CheckNumForName because skin sounds // haven't been assigned a namespace yet. for (k = base + 1; k < (int)numlumps && lumpinfo[k].handle == lumpinfo[base].handle; k++) { if (!strnicmp (com_token, lumpinfo[k].name, 8)) { //W_SetLumpNamespace (k, skins[i].namespc); sndlumps[j] = k; break; } } if (sndlumps[j] == -1) { // Replacement not found, try finding it in the global namespace sndlumps[j] = W_CheckNumForName (com_token); } break; } } //if (j == 8) // Printf (PRINT_HIGH, "Funny info for skin %i: %s = %s\n", i, key, com_token); } } if (skins[i].name[0] == 0) sprintf (skins[i].name, "skin%d", (unsigned)i); // Register any sounds this skin provides for (j = 0; j < 8; j++) { if (sndlumps[j] != -1) { if (j > 1) { sprintf (sndname, "player/%s/%s", skins[i].name, skinsoundnames[j][1]); S_AddSoundLump (sndname, sndlumps[j]); } else if (j == 1) { int r; for (r = 1; r <= 4; r++) { sprintf (sndname, "player/%s/death%d", skins[i].name, r); S_AddSoundLump (sndname, sndlumps[j]); } } else { // j == 0 int l, r; for (l = 1; l <= 4; l++) for (r = 1; r <= 2; r++) { sprintf (sndname, "player/%s/pain%d_%d", skins[i].name, l*25, r); S_AddSoundLump (sndname, sndlumps[j]); } } } } // Now collect the sprite frames for this skin. If the sprite name was not // specified, use whatever immediately follows the specifier lump. if (intname == 0) { intname = *(int *)(lumpinfo[base+1].name); for (stop = base + 2; stop < (int)numlumps && lumpinfo[stop].handle == lumpinfo[base].handle && *(int *)lumpinfo[stop].name == intname; stop++) ; } else { stop = numlumps; } memset (sprtemp, -1, sizeof(sprtemp)); maxframe = -1; for (k = base + 1; k < stop && lumpinfo[k].handle == lumpinfo[base].handle; k++) { if (*(int *)lumpinfo[k].name == intname) { R_InstallSpriteLump (k, lumpinfo[k].name[4] - 'A', // denis - fixme - security lumpinfo[k].name[5] - '0', false); if (lumpinfo[k].name[6]) R_InstallSpriteLump (k, lumpinfo[k].name[6] - 'A', lumpinfo[k].name[7] - '0', true); //W_SetLumpNamespace (k, skins[i].namespc); } } R_InstallSprite ((char *)&intname, (skins[i].sprite = (spritenum_t)(numsprites - numskins + i))); // Now go back and check for face graphics (if necessary) if (skins[i].face[0] == 0 || skins[i].face[1] == 0 || skins[i].face[2] == 0) { // No face name specified, so this skin doesn't replace it skins[i].face[0] = 0; } else { // Need to go through and find all face graphics for the skin // and assign them to the skin's namespace. for (j = 0; j < 8; j++) strncpy (facenames[j], skins[i].face, 3); for (k = base + 1; k < (int)numlumps && lumpinfo[k].handle == lumpinfo[base].handle; k++) { for (j = 0; j < 8; j++) if (!strncmp (facenames[j], lumpinfo[k].name, facelens[j])) { //W_SetLumpNamespace (k, skins[i].namespc); break; } } } } // Grrk. May have changed sound table. Fix it. if (numskins > 1) S_HashSounds (); }
//***************************************************************************** // unescape( orig) - Return a string with escaped character sequences replaced // by the actual characters that the escape codes refer to. char* unescape( char *orig) { // Loop: Examine pointers to successive words of the string char c, *cp, *result = orig; int i; for( cp = orig; (*orig = *cp); cp++, orig++) { // If this is not an escape sequence, keep going if (*cp != '\\') continue; // Check for different escape sequences switch (*++cp) { case 'a': /* alert (bell) */ *orig = '\a'; continue; case 'b': /* backspace */ *orig = '\b'; continue; case 'e': /* escape */ *orig = '\e'; continue; case 'f': /* formfeed */ *orig = '\f'; continue; case 'n': /* newline */ *orig = '\n'; continue; case 'r': /* carriage return */ *orig = '\r'; continue; case 't': /* horizontal tab */ *orig = '\t'; continue; case 'v': /* vertical tab */ *orig = '\v'; continue; case '\\': /* backslash */ *orig = '\\'; continue; case '\'': /* single quote */ *orig = '\''; continue; case '\"': /* double quote */ *orig = '"'; continue; case '0': case '1': case '2': case '3': /* octal */ case '4': case '5': case '6': case '7': /* number */ for( i = 0, c = 0; ISODIGIT((unsigned char)*cp) && i < 3; i++, cp++) { c <<= 3; c |= (*cp - '0'); } *orig = c; continue; case 'x': /* hexidecimal number */ cp++; /* skip 'x' */ for (i = 0, c = 0; isxdigit((unsigned char)*cp) && i < 2; i++, cp++) { c <<= 4; if (isdigit((unsigned char)*cp)) c |= (*cp - '0'); else c |= ((toupper((unsigned char)*cp) - 'A') + 10); } *orig = c; continue; default: --cp; break; } } // Return result and quit return (result); }
int main() { OUTPUT *final_w=NULL, *current_pointer=NULL, *last_pointer = NULL, *control=NULL; FILE *fboard=NULL, *fdict=NULL, *output=NULL; int *array_x=NULL, *array_y=NULL; int nwords=0, len=0, find_word=0, inserted=0, limit_words=0, name_len=0, len_board=0, found=0, final_score=0; int v=0, i=0, j=0, x=0, y=0; int matrixPnt[4][4]; int matrixBns[4][4]; char pntboard[4][4]; char bonusboard[4][4]; char word[MAX_LNGTH+1]; char cboard[4][4]; char *name_board=NULL, *name_dict=NULL; printf("Input board file name: "); name_board = (char*)malloc(20*sizeof(char)); if(name_board == NULL) { printf("\nMemory allocation error\n"); system("pause"); exit(EXIT_FAILURE); } scanf("%s", name_board); len_board = strlen(name_board); name_board = (char*) realloc(name_board, len_board + 1); if(name_board == NULL) { printf("\nMemory allocation error\n"); system("pause"); exit(EXIT_FAILURE); } fboard=fopen(name_board,"r"); if(fboard==NULL) { printf("\nError opening file %s\n","board.txt"); system("pause"); exit(EXIT_FAILURE); } printf("Input dictionary file name: "); name_dict = (char*)malloc(20*sizeof(char)); if(name_dict == NULL) { printf("\nMemory allocation error\n"); system("pause"); exit(EXIT_FAILURE); } scanf("%s", name_dict); len_board = strlen(name_dict); name_dict = (char*) realloc(name_dict, len_board + 1); if(name_dict == NULL) { printf("\nMemory allocation error\n"); system("pause"); exit(EXIT_FAILURE); } fdict = fopen(name_dict,"r"); if(fdict == NULL) { printf("Uploaded file was not found. It uses the default file.\n"); system("pause"); fdict = fopen("dict.txt","r"); } else { for(i=0; i<4; i++) fscanf(fboard, "%c%c%c%c\n", &cboard[i][0], &cboard[i][1], &cboard[i][2], &cboard[i][3]); for(i=0; i<4; i++) fscanf(fboard, "%c%c%c%c\n", &pntboard[i][0], &pntboard[i][1], &pntboard[i][2], &pntboard[i][3]); for(i = 0; i < 4; i++) { for(j = 0; j<4 ; j++) { matrixPnt[i][j] = ((int)pntboard[i][j])-((int)('0')); } } for(i=0; i<4; i++) fscanf(fboard, "%c%c%c%c\n", &bonusboard[i][0], &bonusboard[i][1], &bonusboard[i][2], &bonusboard[i][3]); for(i = 0; i < 4; i++) { for(j = 0; j<4 ; j++) { matrixBns[i][j] = ((int)bonusboard[i][j])-((int)('0')); } } } printf("Input words to be found (default type 0): "); scanf("%d", &nwords); if(nwords == 0) nwords = default_nwords; if(fdict==NULL) { printf("\nError opening file: %s\n","dict.txt"); system("pause"); exit(EXIT_FAILURE); } else { while( fgets(word, 1024, fdict)!= NULL ) { v = isalpha(word[0]); /*commento dict*/ if(v > 0) { len=0; while((word[len] != '/') && (word[len] != '\n')) { if(word[len] == '\'') /*apostrofo*/ { len=TRUE; word[len] = '\n'; } else len++; } word[len] = '\0'; len = strlen(word); if( (len <= 16) && (len > 1) ) { accent_c(word); array_x = (int*) malloc(len*sizeof(int)); if(array_x == NULL) { printf("\nMemory allocation error\n"); system("pause"); exit(EXIT_FAILURE); } array_y = (int*) malloc(len*sizeof(int)); if(array_y == NULL) { printf("\nMemory allocation error\n"); system("pause"); exit(EXIT_FAILURE); } for(i=0; i<len; i++) { array_x[i] = 0; array_y[i] = 0; word[i] = toupper(word[i]); } control = controller(word, cboard, array_x, array_y, matrixPnt, matrixBns, len); if(control != NULL) { find_word++; control->array_x = (int*) malloc(len*sizeof(int)); if( (control->array_x) == NULL) { printf("\nMemory allocation error\n"); system("pause"); exit(EXIT_FAILURE); } control->array_y = (int*) malloc(len*sizeof(int)); if( (control->array_y) == NULL) { printf("\nMemory allocation error\n"); system("pause"); exit(EXIT_FAILURE); } for(i=0;i<len;i++) { control->array_x[i] = array_x[i]; control->array_y[i] = array_y[i]; } if(final_w == NULL) { control->next = NULL; final_w = control; } else { control->next = NULL; current_pointer = final_w; last_pointer = final_w; inserted = FALSE; while(current_pointer != NULL && inserted == FALSE) { if(current_pointer->pnt < control->pnt) { if(current_pointer == last_pointer) { control->next = final_w; final_w = control; inserted = TRUE; } else { control->next = current_pointer; last_pointer->next = control; inserted = TRUE; } } last_pointer = current_pointer; current_pointer = current_pointer->next; } if(inserted == FALSE) { last_pointer->next = control; } } } } } } } current_pointer = final_w; name_len = (strlen(name_board)) - exe; name_board[name_len] = '\0'; output = fopen(strcat(name_board, "_results.txt"), "w"); final_score = 0; while( (current_pointer != NULL) && (limit_words < nwords) ) { fprintf(output, "%s %d \n", current_pointer->word, current_pointer->pnt); final_score = final_score + current_pointer->pnt; for(i=0; i<4; i++) { for(j=0; j<4; j++) { found = FALSE; len = strlen(current_pointer->word); for(v=0;v<len;v++) { x = current_pointer->array_x[v]; y = current_pointer->array_y[v]; if((y == i) && (x == j)) { found = TRUE; } } if(found == FALSE) { fprintf(output, "%c", tolower(cboard[i][j])); } else { fprintf(output, "%c", cboard[i][j]); } } fprintf(output, "\n"); } fprintf(output, "\n"); current_pointer = current_pointer->next; limit_words++; } fprintf(output, "\n"); fprintf(output, "Final Score: %d\n", final_score); fprintf(output, "Total words: %d", find_word); if(limit_words == nwords) { free(name_dict); free(array_x); free(array_y); free(control); while(current_pointer != NULL) { last_pointer =current_pointer; current_pointer =current_pointer->next; free(last_pointer); } } fclose(fboard); fclose(fdict); system("pause"); return 0; }
int main(int argc, char **argv) { if (argc != 3) { fprintf(stderr, "give 2 args\n"); exit(-1); } pid2_t = mmap(NULL, sizeof(*pid2_t), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0); pid_t lpid1, lpid2; char file2[FILE_NAME_SIZE]; strncpy(file2, argv[2], FILE_NAME_SIZE); char input[256]; strncpy(file1, argv[1], FILE_NAME_SIZE); pipe(pipe1); pipe(pipe2); signal(SIGINT, terminate); if ((lpid1 = fork()) == 0) { int read_bytes = 0; char c; printf("1 process pid is %d\n", getpid()); signal(SIGUSR1, switch_files); fd1 = open(file1, O_RDONLY); if (fd1 < 0) { fprintf(stderr, "error opening file %s\n", file1); return -1; } while(1) { read_bytes = read(fd1, &c, 1); if (read_bytes > 0) { fprintf(stdout, "%c\n", toupper(c)); } usleep(500000); } close(fd1); printf("fd1 closed\n"); return 0; } else { pid1 = lpid1; } if ((lpid2 = fork()) == 0) { int read_bytes = 0; char c; printf("2 process pid is %d\n", getpid()); signal(SIGUSR2, switch_files); fd2 = open(file2, O_RDONLY); if (fd2 < 0) { fprintf(stderr, "error opening file %s\n", file2); return -1; } while(1) { read_bytes = read(fd2, &c, 1); if (read_bytes > 0) { fprintf(stdout, "\t%c\n", tolower(c)); } usleep(500000); } close(fd2); printf("fd2 closed\n"); return 0; } else { *pid2_t = lpid2; pid2 = lpid2; } printf("%d %d\n", pid1, pid2); while(scanf("%s", input) > 0) { write(pipe1[1], input, strlen(input) + 1); kill(pid1, SIGUSR1); } waitpid(pid1, 0, 0); waitpid(pid2, 0, 0); printf("exit\n"); }
/* Parse the key and value from a memory buffer. */ char *hcfg_parse(char *buf, char **key, char **val) { char *ptr = NULL; *key = NULL; *val = NULL; /* Skip leading key whitespace. */ while (isspace(*buf) && *buf != '\n') ++buf; /* Skip empty lines and comments. */ if (*buf == '\n' || *buf == '#') goto endline; if (!isalnum(*buf) && *buf != '_') return NULL; /* Force key strings to be uppercase. */ *key = buf; while (isalnum(*buf) || *buf == '_') { *buf = toupper(*buf); ++buf; } /* Check that key string was valid. */ ptr = buf; while (isspace(*buf) && *buf != '\n') ++buf; if (*(buf++) != '=') return NULL; while (isspace(*buf) && *buf != '\n') ++buf; /* Kill whitespace and separator between key and value. */ while (ptr < buf) *(ptr++) = '\0'; /* Unquote the value string. */ *val = buf; ptr = buf; while (*buf && *buf != '\n') { if (*buf == '#') goto endline; if (*buf == '\\') ++buf; *(ptr++) = *(buf++); } endline: buf += strcspn(buf, "\n"); if (*buf == '\n') ++buf; /* Kill trailing value whitespace. */ if (ptr) { do *(ptr--) = '\0'; while (isspace(*ptr)); } return buf; }
int CompleteSF_Info(T_SF_Info *SFI, int LblExact, int Set_f_stol_0) { int m; const char *lt, *li; int iSFT; T_SF_Tables *SFT; if (SFI->SFT || SFI->CAA || SFI->f_stol_0 != -1.) InternalError("CompleteSF_Info(): SFI already set"); SFT = SF_Tables; for (iSFT = 0; iSFT < nSF_Tables; iSFT++, SFT++) { if (str_icmp(SFT->Label, SFI->Lbl) == 0) { SFI->SFT = SFT; break; } } if (SFI->SFT == NULL && LblExact == 0) { SFT = SF_Tables; for (iSFT = 0; iSFT < nSF_Tables; iSFT++, SFT++) { m = 0; for (lt = SFT->Label, li = SFI->Lbl; isalpha(*lt); lt++, li++) { if (toupper(*lt) != toupper(*li)) { m = 0; break; } m++; } if (m) { SFI->SFT = SFT; break; } } } if (SFI->SFT) { if (Set_f_stol_0) { if (SFI->SFT->Tab[0].stol != 0.) { char buf[128]; Sprintf(buf, "ScatteringFactor %.60s: missing entry for sinTovL = 0", SFI->SFT->Label); progerror(buf); } SFI->f_stol_0 = SFI->SFT->Tab[0].f; } } else { if (ModeScatteringFactorTable == 0) { SFI->CAA = FindSF_WK95_CAA(SFI->Lbl, LblExact); // printf("atom: %s -> using xray scattering factors from WK95\n", SFI->Lbl); if (NULL == SFI->CAA) return -1; if (Set_f_stol_0) SFI->f_stol_0 = CalcSF_WK95_CAA(SFI->CAA, 0.); } // else if (ModeScatteringFactorTable == 1) // { // SFI->CAA = FindSF_IT92_CAA(SFI->Lbl, LblExact); // printf("%s -> using scattering factors from IT92\n", SFI->Lbl); // if (NULL == SFI->CAA) // return -1; // // if (Set_f_stol_0) // SFI->f_stol_0 = CalcSF_IT92_CAA(SFI->CAA, 0.); // } else if (ModeScatteringFactorTable == 2) { SFI->CAA = FindSF_IT4322(SFI->Lbl, LblExact); // StefS // printf("atom: %s -> using electron scattering factors from IT 4.3.2.2\n", SFI->Lbl); if (NULL == SFI->CAA) return -1; if (Set_f_stol_0) SFI->f_stol_0 = CalcSF_IT4322(SFI->CAA, 0.); } else if (ModeScatteringFactorTable == 3) { SFI->CAA = FindSF_IT4323(SFI->Lbl, LblExact); // StefS // printf("atom: %s -> using electron scattering factors from IT 4.3.2.3\n", SFI->Lbl); if (NULL == SFI->CAA) return -1; if (Set_f_stol_0) SFI->f_stol_0 = CalcSF_IT4323(SFI->CAA, 0.); } } return 0; }
// ************************************************************* // Configuration helpers // ************************************************************* int run (int argc, ACE_TCHAR *argv[]) { int rc = 0; ProactorTask task1(cfg); RecvFactory r_factory; SendFactory s_factory; PSessionManager r_manager (task1, r_factory,"R_Manager"); PSessionManager s_manager (task1, s_factory,"S_Manager"); Acceptor acceptor (r_manager); Connector connector (s_manager); ACE_Time_Value time_begin = ACE_OS::gettimeofday (); ACE_Time_Value time_end = ACE_OS::gettimeofday (); ACE_Time_Value time_run; if (task1.start () == 0) { task1.enable_event_loop(); ACE_Time_Value timeout (cfg.timeout(), 0); r_manager.set_timeout (timeout); s_manager.set_timeout (timeout); if (cfg.both() != 0 || cfg.connections () == 0) // Acceptor { if (acceptor.start (ACE_INET_Addr (cfg.listen_port())) == 0) rc = 1; } if (cfg.both() != 0 || cfg.connections () > 0) // Connector { ACE_INET_Addr addr; addr.set (cfg.connect_port(), cfg.connect_host()); rc += connector.start (addr, cfg.connections ()); } } time_begin = ACE_OS::gettimeofday (); if (rc > 0) { //task1.enable_event_loop(); ACE_Time_Value sleep_time (cfg.seconds()); while ( sleep_time != ACE_Time_Value::zero) { ACE_Countdown_Time countdown ( & sleep_time ); ACE_OS::sleep (sleep_time ); } if (cfg.seconds () == 0) { bool flgExit = false; for (;!flgExit;) { char c; cout << "\nPress Q to stop=>" << flush; cin.clear (); cin >> c; switch (toupper (c)) { case 'Q': flgExit = true; break; case 'P': cout << "\n*** Connector: PendingConnects=" << connector.get_ref_cnt() << " Senders=" << s_manager.get_number_connections () << "\n*** Acceptor: PendingAccepts=" << acceptor.get_ref_cnt() << " Receivers=" << r_manager.get_number_connections (); break; }//switch }//for }//if cfg.seconds
void countCharWordsSentCase(char fileName[], char fileName2[], int* charCount, int* wordCount, int* sentenceCount) { //char c; char ch; FILE *fp1, *fp2; int no_of_char = 0, no_of_words = 1, no_of_sent = 0; fp1= fopen(fileName,"r"); if( fp1 == NULL ) { perror("Error while opening the file.\n"); exit(EXIT_FAILURE); } fp2 = fopen(fileName2,"w"); if( fp2 == NULL ) { perror("Error while opening the file.\n"); exit(EXIT_FAILURE); } //upper to lower and viceversa while (!feof(fp1)) { no_of_char++; ch = fgetc(fp1); if (ch == ' ' || ch == '.' || ch == '\n' || ch == '\t') { if(ch == ' ' || ch == '\n' || ch == '\t') { fputc(ch,fp2); no_of_words++; } else if(ch == '.') { fputc(ch,fp2); no_of_sent++; } } else if (isalpha(ch)) { if (isupper(ch)) { fputc(tolower(ch),fp2); } else { fputc(toupper(ch),fp2); } } else { //fputc(' ',fp2); } } fclose(fp1); fclose(fp2); no_of_char--; *charCount = no_of_char; *wordCount = no_of_words; *sentenceCount = no_of_sent; return; }
static int load_dll(ClipMachine * ClipMachineMemory, const char *name, struct Coll *names, ClipVar * resp) { void *hp; char buf[256], *s, *e; char uname[128]; const char **spp; ClipModule *entry; ClipFunction **fpp; ClipNameEntry *np; ClipFile **cpp; struct DBFuncTable **dpp; int l, ret = 0, i; s = strrchr(name, '/'); if (s) snprintf(buf, sizeof(buf), "%s", name); else snprintf(buf, sizeof(buf), "%s/lib/%s ", CLIPROOT, name); if (!loaded_dlls) { loaded_dlls = new_Coll(free, strcmp); } else { if (search_Coll(loaded_dlls, buf, 0)) return 0; } #ifdef OS_MINGW hp = lt_dlopen(buf); #else hp = dlopen(buf, RTLD_NOW); #endif if (!hp) { _clip_trap_printf(ClipMachineMemory, __FILE__, __LINE__, "shared loading problem: %s: file %s", dlerror(), buf); return _clip_call_errblock(ClipMachineMemory, 1); } insert_Coll(loaded_dlls, strdup(buf)); /* path/name.ext -> name_module entry symbol */ s = strrchr(name, '/'); if (!s) s = (char *) name; else s = s + 1; e = strchr(s, '.'); if (e) l = e - s; else l = strlen(s); if (l > sizeof(uname)) l = sizeof(uname); for (i = 0; i < l; i++, s++) { if (*s == '-') uname[i] = '_'; else uname[i] = toupper(*s); } uname[l] = 0; snprintf(buf, sizeof(buf), "clip__MODULE_%s", uname); #ifdef OS_MINGW entry = (ClipModule *) lt_dlsym(hp, buf); #else entry = (ClipModule *) dlsym(hp, buf); #endif if (!entry) { _clip_trap_printf(ClipMachineMemory, __FILE__, __LINE__, "shared '%s' fetch name '%s' problem: %s", name, buf, dlerror()); return _clip_call_errblock(ClipMachineMemory, 1); } for (np = entry->ClipNameEntry_cfunctions_of_ClipModule; np && np->ClipFunction_function_of_ClipNameEntry; ++np) _clip_register_hash(ClipMachineMemory, np->ClipFunction_function_of_ClipNameEntry, np->hash_of_ClipNameEntry); for (fpp = entry->ClipFunction_inits_of_ClipModule; fpp && *fpp; ++fpp) _clip_main_func(ClipMachineMemory, *fpp, _clip_argc, _clip_argv, _clip_envp); for (fpp = entry->ClipFunction_exits_of_ClipModule; fpp && *fpp; ++fpp) { ClipMachineMemory->cexits = (ClipFunction **) realloc(ClipMachineMemory->cexits, (ClipMachineMemory->ncexits + 1) * sizeof(ClipFunction *)); ClipMachineMemory->cexits[ClipMachineMemory->ncexits] = *fpp; ++ClipMachineMemory->ncexits; } for (spp = entry->pfunctions_of_ClipModule; spp && *spp; ++spp) if (_clip_load(ClipMachineMemory, *spp, 0, 0)) ++ret; /* if (entry->cpfile && _clip_register_file(ClipMachineMemory, entry->cpfile)) ++ret; */ for (cpp = entry->cpfiles_of_ClipModule; cpp && *cpp; ++cpp) if (_clip_register_file(ClipMachineMemory, *cpp)) ++ret; for (dpp = entry->dbdrivers_of_ClipModule; dpp && *dpp; ++dpp) if (_clip_register_driver(ClipMachineMemory, *dpp)) ++ret; add_ClipVect(&ClipMachineMemory->dlls, hp); return ret; }
static Variant HHVM_FUNCTION(dbase_create, const String& filename, const Variant& fields) { if (!fields.isArray()) { raise_warning("Expected array as second parameter"); return false; } //if (php_check_open_basedir(Z_STRVAL_PP(filename) TSRMLS_CC)) { // RETURN_FALSE; //} int fd; if ((fd = open(filename.c_str(), O_BINARY|O_RDWR|O_CREAT, 0644)) < 0) { raise_warning("Unable to create database (%d): %s", errno, strerror(errno)); return false; } Array arr_fields = fields.toArray(); ssize_t num_fields = arr_fields.size(); if (num_fields <= 0) { raise_warning("Unable to create database without fields"); close(fd); return false; } // have to use regular malloc() because this gets free()'d by // code in the dbase library. dbhead_t* dbh = (dbhead_t*)malloc(sizeof(dbhead_t)); dbfield_t* dbf = (dbfield_t*)malloc(sizeof(dbfield_t) * num_fields); if ((dbh == nullptr) || (dbf == nullptr)) { raise_warning("Unable to allocate memory for header info"); if (dbh != nullptr) { free(dbh); } if (dbf != nullptr) { free(dbf); } close(fd); return false; } // This will ensure close(fd) and free_dbf_head(dbh) on "return false". DBaseConnection dbc(dbh); // initialize the header structure dbh->db_fields = dbf; dbh->db_fd = fd; dbh->db_dbt = DBH_TYPE_NORMAL; strcpy(dbh->db_date, "19930818"); dbh->db_records = 0; dbh->db_nfields = num_fields; dbh->db_hlen = sizeof(struct dbf_dhead) + 1 + num_fields * sizeof(struct dbf_dfield); int rlen = 1; // make sure that the db_format entries for all fields are set to NULL to ensure we // don't seg fault if there's and error and we need to call free_dbf_head() before all // fields have been defined. dbfield_t* cur_f = dbf; for (size_t i = 0; i < num_fields; i++, cur_f++) { cur_f->db_format = nullptr; } cur_f = dbf; int i = 0; for (ArrayIter arr_it(arr_fields); arr_it; ++arr_it, cur_f++, i++) { Array& field = arr_it.second().toArrRef(); ArrayIter field_it(field); // field name if (!field_it) { raise_warning("expected field name as first element of list in field %d", i); return false; } const String& field_name = field_it.second().toCStrRef(); if ((field_name.size() > 10) || (field_name.size() == 0)) { raise_warning("invalid field name '%s' (must be non-empty and less than or equal to 10 characters)", field_name.c_str()); return false; } strncpy(cur_f->db_fname, field_name.c_str(), field_name.size()+1); // field type ++field_it; if (!field_it) { raise_warning("expected field type as second element of list in field %d", i); return false; } cur_f->db_type = toupper(field_it.second().toCStrRef().c_str()[0]); cur_f->db_fdc = 0; // verify the field length switch (cur_f->db_type) { case 'L': cur_f->db_flen = 1; break; case 'M': cur_f->db_flen = 10; dbh->db_dbt = DBH_TYPE_MEMO; // should create the memo file here, probably break; case 'D': cur_f->db_flen = 8; break; case 'F': cur_f->db_flen = 20; break; case 'N': case 'C': // field length ++field_it; if (!field_it) { raise_warning("expected field length as third element of list in field %d", i); return false; } cur_f->db_flen = field_it.second().toInt32(); if (cur_f->db_type == 'N') { ++field_it; if (!field_it) { raise_warning("expected field precision as fourth element of list in field %d", i); return false; } } break; default: raise_warning("unknown field type '%c'", cur_f->db_type); return false; } cur_f->db_foffset = rlen; rlen += cur_f->db_flen; cur_f->db_format = get_dbf_f_fmt(cur_f); } dbh->db_rlen = rlen; put_dbf_info(dbh); // We need a copy of dbc here, because return will destroy original. open_dbases->insert(std::make_pair(dbh->db_fd, std::shared_ptr<DBaseConnection>(new DBaseConnection(dbc)))); return Variant(dbh->db_fd); }
Language *ReadLangModel(Vocab *vocab,char *filename, float scale,float pen,float ngram) { Language *lang; FILE *file; char buf[256],*ptr; int i,flags; lang=qalloc(sizeof(Language),1,"Language:ReadLanguage:lang"); lang->type = l_invalid; lang->vocab = vocab; lang->scale = scale; lang->pen = pen; lang->name = qalloc(1,strlen(filename)+1,"Language:ReadLanguage:lang->name"); strcpy(lang->name,filename); LockSymTable(vocab->wdst); if ((file=fopen(filename,"r"))==NULL) HError(LANG_ERR+1,"Cannot open file %s to read language",filename); fgets(buf,256,file); /* Get string (max 256 chars) from file */ for (ptr=buf;*ptr;*ptr++=toupper(*ptr)); /* Get LM identifier */ while(isspace(*(--ptr))) *ptr=0; /* Remove whitespaces */ for (ptr=buf;isspace(*ptr);*ptr++=0); for (i=1;i<l_invalid;i++) { /* Check to see which lm key the */ if (!strcmp(ptr,lmIdentifier[i])) /* string <ptr> corresponds to */ lang->type=i; } if (lang->type==l_invalid) HError(LANG_ERR+1,"Do not recognise LM type %s",ptr); switch(lang->type) /* Now call corresponding <Read> function */ { case l_ngram: flags=ReadNGram(lang,file); break; case l_interpolate: flags=ReadInterpolate(lang,file); break; case l_mylm: flags=ReadMyLangModel(lang,file); break; /* Add new LM types here */ /* flags=Read????(lang,file); */ case l_srilm: flags=ReadSriLM(lang,file); break; default: HError(LANG_ERR+2,"No read function for LM type %d",lang->type); break; } fclose(file); lang->flags=flags; return(lang); }
void capitalize(char *str, int len) { int i; for (i = 0; i < len; i++) { str[i] = (char)toupper(str[i]); } }
void sdstoupper(sds s) { int len = sdslen(s), j; for (j = 0; j < len; j++) s[j] = toupper(s[j]); }
int wcshdo(int relax, struct wcsprm *wcs, int *nkeyrec, char **header) /* ::: CUBEFACE and STOKES handling? */ { static const char *function = "wcshdo"; char alt, comment[72], keyvalue[72], keyword[16], obsg[8] = "OBSG?", obsgeo[8] = "OBSGEO-?", ptype, xtype, xyz[] = "XYZ"; int bintab, col0, *colax, colnum, i, j, k, naxis, pixlist, primage, status = 0; struct wcserr **err; *nkeyrec = 0; *header = 0x0; if (wcs == 0x0) return WCSHDRERR_NULL_POINTER; err = &(wcs->err); if (wcs->flag != WCSSET) { if ((status = wcsset(wcs))) return status; } if ((naxis = wcs->naxis) == 0) { return 0; } /* These are mainly for convenience. */ alt = wcs->alt[0]; if (alt == ' ') alt = '\0'; colnum = wcs->colnum; colax = wcs->colax; primage = 0; bintab = 0; pixlist = 0; if (colnum) { bintab = 1; col0 = colnum; } else if (colax[0]) { pixlist = 1; col0 = colax[0]; } else { primage = 1; } /* WCS dimension. */ if (!pixlist) { sprintf(keyvalue, "%20d", naxis); wcshdo_util(relax, "WCSAXES", "WCAX", 0, 0x0, 0, 0, 0, alt, colnum, colax, keyvalue, "Number of coordinate axes", nkeyrec, header, &status); } /* Reference pixel coordinates. */ for (j = 0; j < naxis; j++) { sprintf(keyvalue, "%20.12G", wcs->crpix[j]); wcshdo_util(relax, "CRPIX", "CRP", WCSHDO_CRPXna, "CRPX", 0, j+1, 0, alt, colnum, colax, keyvalue, "Pixel coordinate of reference point", nkeyrec, header, &status); } /* Linear transformation matrix. */ k = 0; for (i = 0; i < naxis; i++) { for (j = 0; j < naxis; j++, k++) { if (i == j) { if (wcs->pc[k] == 1.0) continue; } else { if (wcs->pc[k] == 0.0) continue; } sprintf(keyvalue, "%20.12G", wcs->pc[k]); wcshdo_util(relax, "PC", bintab ? "PC" : "P", WCSHDO_TPCn_ka, bintab ? 0x0 : "PC", i+1, j+1, 0, alt, colnum, colax, keyvalue, "Coordinate transformation matrix element", nkeyrec, header, &status); } } /* Coordinate increment at reference point. */ for (i = 0; i < naxis; i++) { sprintf(keyvalue, "%20.12G", wcs->cdelt[i]); comment[0] = '\0'; if (wcs->cunit[i][0]) sprintf(comment, "[%s] ", wcs->cunit[i]); strcat(comment, "Coordinate increment at reference point"); wcshdo_util(relax, "CDELT", "CDE", WCSHDO_CRPXna, "CDLT", i+1, 0, 0, alt, colnum, colax, keyvalue, comment, nkeyrec, header, &status); } /* Units of coordinate increment and reference value. */ for (i = 0; i < naxis; i++) { if (wcs->cunit[i][0] == '\0') continue; sprintf(keyvalue, "'%s'", wcs->cunit[i]); wcshdo_util(relax, "CUNIT", "CUN", WCSHDO_CRPXna, "CUNI", i+1, 0, 0, alt, colnum, colax, keyvalue, "Units of coordinate increment and value", nkeyrec, header, &status); } /* Coordinate type. */ for (i = 0; i < naxis; i++) { if (wcs->ctype[i][0] == '\0') continue; sprintf(keyvalue, "'%s'", wcs->ctype[i]); strcpy(comment, "Coordinate type code"); if (i == wcs->lng || i == wcs->lat) { if (strncmp(wcs->ctype[i], "RA--", 4) == 0) { strcpy(comment, "Right ascension, "); } else if (strncmp(wcs->ctype[i], "DEC-", 4) == 0) { strcpy(comment, "Declination, "); } else if (strncmp(wcs->ctype[i]+1, "LON", 3) == 0 || strncmp(wcs->ctype[i]+1, "LAT", 3) == 0) { switch (wcs->ctype[i][0]) { case 'G': strcpy(comment, "galactic "); break; case 'E': strcpy(comment, "ecliptic "); case 'H': strcpy(comment, "helioecliptic "); case 'S': strcpy(comment, "supergalactic "); } if (i == wcs->lng) { strcat(comment, "longitude, "); } else { strcat(comment, "latitude, "); } wcs->ctype[i][0] = toupper(wcs->ctype[i][0]); } strcat(comment, wcs->cel.prj.name); strcat(comment, " projection"); } else if (i == wcs->spec) { spctyp(wcs->ctype[i], 0x0, 0x0, comment, 0x0, &ptype, &xtype, 0x0); if (ptype == xtype) { strcat(comment, " (linear)"); } else { switch (xtype) { case 'F': strcat(comment, " (linear in frequency)"); break; case 'V': strcat(comment, " (linear in velocity)"); break; case 'W': strcat(comment, " (linear in wavelength)"); break; } } } wcshdo_util(relax, "CTYPE", "CTY", WCSHDO_CRPXna, "CTYP", i+1, 0, 0, alt, colnum, colax, keyvalue, comment, nkeyrec, header, &status); } /* Coordinate value at reference point. */ for (i = 0; i < naxis; i++) { sprintf(keyvalue, "%20.12G", wcs->crval[i]); comment[0] = '\0'; if (wcs->cunit[i][0]) sprintf(comment, "[%s] ", wcs->cunit[i]); strcat(comment, "Coordinate value at reference point"); wcshdo_util(relax, "CRVAL", "CRV", WCSHDO_CRPXna, "CRVL", i+1, 0, 0, alt, colnum, colax, keyvalue, comment, nkeyrec, header, &status); } /* Parameter values. */ for (k = 0; k < wcs->npv; k++) { sprintf(keyvalue, "%20.12G", (wcs->pv[k]).value); if ((wcs->pv[k]).i == (wcs->lng + 1)) { switch ((wcs->pv[k]).m) { case 1: strcpy(comment, "[deg] Native longitude of the reference point"); break; case 2: strcpy(comment, "[deg] Native latitude of the reference point"); break; case 3: if (primage) { sprintf(keyword, "LONPOLE%c", alt); } else if (bintab) { sprintf(keyword, "LONP%d%c", colnum, alt); } else { sprintf(keyword, "LONP%d%c", colax[(wcs->pv[k]).i - 1], alt); } sprintf(comment, "[deg] alias for %s (has precedence)", keyword); break; case 4: if (primage) { sprintf(keyword, "LATPOLE%c", alt); } else if (bintab) { sprintf(keyword, "LATP%d%c", colnum, alt); } else { sprintf(keyword, "LATP%d%c", colax[(wcs->pv[k]).i - 1], alt); } sprintf(comment, "[deg] alias for %s (has precedence)", keyword); break; } } else if ((wcs->pv[k]).i == (wcs->lat + 1)) { sprintf(comment, "%s projection parameter", wcs->cel.prj.code); } else { strcpy(comment, "Coordinate transformation parameter"); } wcshdo_util(relax, "PV", "V", WCSHDO_PVn_ma, "PV", wcs->pv[k].i, -1, wcs->pv[k].m, alt, colnum, colax, keyvalue, comment, nkeyrec, header, &status); } for (k = 0; k < wcs->nps; k++) { sprintf(keyvalue, "'%s'", (wcs->ps[k]).value); wcshdo_util(relax, "PS", "S", WCSHDO_PVn_ma, "PS", wcs->ps[k].i, -1, wcs->ps[k].m, alt, colnum, colax, keyvalue, "Coordinate transformation parameter", nkeyrec, header, &status); } /* Celestial and spectral transformation parameters. */ if (!undefined(wcs->lonpole)) { sprintf(keyvalue, "%20.12G", wcs->lonpole); wcshdo_util(relax, "LONPOLE", "LONP", 0, 0x0, 0, 0, 0, alt, colnum, colax, keyvalue, "[deg] Native longitude of celestial pole", nkeyrec, header, &status); } if (!undefined(wcs->latpole)) { sprintf(keyvalue, "%20.12G", wcs->latpole); wcshdo_util(relax, "LATPOLE", "LATP", 0, 0x0, 0, 0, 0, alt, colnum, colax, keyvalue, "[deg] Native latitude of celestial pole", nkeyrec, header, &status); } if (!undefined(wcs->restfrq)) { sprintf(keyvalue, "%20.12G", wcs->restfrq); wcshdo_util(relax, "RESTFRQ", "RFRQ", 0, 0x0, 0, 0, 0, alt, colnum, colax, keyvalue, "[Hz] Line rest frequency", nkeyrec, header, &status); } if (!undefined(wcs->restwav)) { sprintf(keyvalue, "%20.12G", wcs->restwav); wcshdo_util(relax, "RESTWAV", "RWAV", 0, 0x0, 0, 0, 0, alt, colnum, colax, keyvalue, "[Hz] Line rest wavelength", nkeyrec, header, &status); } /* Coordinate system title. */ if (wcs->wcsname[0]) { sprintf(keyvalue, "'%s'", wcs->wcsname); if (bintab) { wcshdo_util(relax, "WCSNAME", "WCSN", 0, 0x0, 0, 0, 0, alt, colnum, colax, keyvalue, "Coordinate system title", nkeyrec, header, &status); } else { /* TWCS was a mistake. */ wcshdo_util(relax, "WCSNAME", "TWCS", WCSHDO_WCSNna, "WCSN", 0, 0, 0, alt, colnum, colax, keyvalue, "Coordinate system title", nkeyrec, header, &status); } } /* Coordinate axis title. */ if (wcs->cname) { for (i = 0; i < naxis; i++) { if (wcs->cname[i][0] == '\0') continue; sprintf(keyvalue, "'%s'", wcs->cname[i]); wcshdo_util(relax, "CNAME", "CNA", WCSHDO_CNAMna, "CNAM", i+1, 0, 0, alt, colnum, colax, keyvalue, "Axis name for labelling purposes", nkeyrec, header, &status); } } /* Random error in coordinate. */ if (wcs->crder) { for (i = 0; i < naxis; i++) { if (undefined(wcs->crder[i])) continue; sprintf(keyvalue, "%20.12G", wcs->crder[i]); comment[0] = '\0'; if (wcs->cunit[i][0]) sprintf(comment, "[%s] ", wcs->cunit[i]); strcat(comment, "Random error in coordinate"); wcshdo_util(relax, "CRDER", "CRD", WCSHDO_CNAMna, "CRDE", i+1, 0, 0, alt, colnum, colax, keyvalue, comment, nkeyrec, header, &status); } } /* Systematic error in coordinate. */ if (wcs->csyer) { for (i = 0; i < naxis; i++) { if (undefined(wcs->csyer[i])) continue; sprintf(keyvalue, "%20.12G", wcs->csyer[i]); comment[0] = '\0'; if (wcs->cunit[i][0]) sprintf(comment, "[%s] ", wcs->cunit[i]); strcat(comment, "Systematic error in coordinate"); wcshdo_util(relax, "CSYER", "CSY", WCSHDO_CNAMna, "CSYE", i+1, 0, 0, alt, colnum, colax, keyvalue, comment, nkeyrec, header, &status); } } /* Equatorial coordinate system type. */ if (wcs->radesys[0]) { sprintf(keyvalue, "'%s'", wcs->radesys); wcshdo_util(relax, "RADESYS", "RADE", 0, 0x0, 0, 0, 0, alt, colnum, colax, keyvalue, "Equatorial coordinate system", nkeyrec, header, &status); } /* Equinox of equatorial coordinate system. */ if (!undefined(wcs->equinox)) { sprintf(keyvalue, "%20.12G", wcs->equinox); wcshdo_util(relax, "EQUINOX", "EQUI", 0, 0x0, 0, 0, 0, alt, colnum, colax, keyvalue, "[yr] Equinox of equatorial coordinates", nkeyrec, header, &status); } /* Reference frame of spectral coordinates. */ if (wcs->specsys[0]) { sprintf(keyvalue, "'%s'", wcs->specsys); wcshdo_util(relax, "SPECSYS", "SPEC", 0, 0x0, 0, 0, 0, alt, colnum, colax, keyvalue, "Reference frame of spectral coordinates", nkeyrec, header, &status); } /* Reference frame of spectral observation. */ if (wcs->ssysobs[0]) { sprintf(keyvalue, "'%s'", wcs->ssysobs); wcshdo_util(relax, "SSYSOBS", "SOBS", 0, 0x0, 0, 0, 0, alt, colnum, colax, keyvalue, "Reference frame of spectral observation", nkeyrec, header, &status); } /* Observer's velocity towards source. */ if (!undefined(wcs->velosys)) { sprintf(keyvalue, "%20.12G", wcs->velosys); wcshdo_util(relax, "VELOSYS", "VSYS", 0, 0x0, 0, 0, 0, alt, colnum, colax, keyvalue, "[m/s] Velocity towards source", nkeyrec, header, &status); } /* Reference frame of source redshift. */ if (wcs->ssyssrc[0]) { sprintf(keyvalue, "'%s'", wcs->ssyssrc); wcshdo_util(relax, "SSYSSRC", "SSRC", 0, 0x0, 0, 0, 0, alt, colnum, colax, keyvalue, "Reference frame of source redshift", nkeyrec, header, &status); } /* Redshift of the source. */ if (!undefined(wcs->zsource)) { sprintf(keyvalue, "%20.12G", wcs->zsource); wcshdo_util(relax, "ZSOURCE", "ZSOU", 0, 0x0, 0, 0, 0, alt, colnum, colax, keyvalue, "Redshift of the source", nkeyrec, header, &status); } /* Observatory coordinates. */ for (k = 0; k < 3; k++) { if (undefined(wcs->obsgeo[k])) continue; sprintf(keyvalue, "%20.12G", wcs->obsgeo[k]); sprintf(comment, "[m] ITRF observatory %c-coordinate", xyz[k]); obsgeo[7] = xyz[k]; obsg[4] = xyz[k]; wcshdo_util(relax, obsgeo, obsg, 0, 0x0, 0, 0, 0, ' ', colnum, colax, keyvalue, comment, nkeyrec, header, &status); } /* MJD of observation. */ if (!undefined(wcs->mjdobs)) { sprintf(keyvalue, "%20.12G", wcs->mjdobs); strcpy(comment, "[d] MJD of observation"); if (wcs->dateobs[0]) { if (primage || (relax & 1) == 0) { sprintf(comment+22, " matching DATE-OBS"); } else { sprintf(comment+22, " matching DOBS%d", col0); } } wcshdo_util(relax, "MJD-OBS", "MJDOB", 0, 0x0, 0, 0, 0, ' ', colnum, colax, keyvalue, comment, nkeyrec, header, &status); } /* MJD mid-observation time. */ if (!undefined(wcs->mjdavg)) { sprintf(keyvalue, "%20.12G", wcs->mjdavg); strcpy(comment, "[d] MJD mid-observation"); if (wcs->dateavg[0]) { if (primage) { sprintf(comment+23, " matching DATE-AVG"); } else { sprintf(comment+23, " matching DAVG%d", col0); } } wcshdo_util(relax, "MJD-AVG", "MJDA", 0, 0x0, 0, 0, 0, ' ', colnum, colax, keyvalue, comment, nkeyrec, header, &status); } /* ISO-8601 date corresponding to MJD-OBS. */ if (wcs->dateobs[0]) { sprintf(keyvalue, "'%s'", wcs->dateobs); strcpy(comment, "ISO-8601 observation date"); if (!undefined(wcs->mjdobs)) { if (primage) { sprintf(comment+25, " matching MJD-OBS"); } else { sprintf(comment+25, " matching MJDOB%d", col0); } } if (relax & 1) { /* Allow DOBSn. */ wcshdo_util(relax, "DATE-OBS", "DOBS", WCSHDO_DOBSn, 0x0, 0, 0, 0, ' ', colnum, colax, keyvalue, comment, nkeyrec, header, &status); } else { /* Force DATE-OBS. */ wcshdo_util(relax, "DATE-OBS", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue, comment, nkeyrec, header, &status); } } /* ISO-8601 date corresponding to MJD-OBS. */ if (wcs->dateavg[0]) { sprintf(keyvalue, "'%s'", wcs->dateavg); strcpy(comment, "ISO-8601 mid-observation date"); if (!undefined(wcs->mjdavg)) { if (primage) { sprintf(comment+29, " matching MJD-AVG"); } else { sprintf(comment+29, " matching MJDA%d", col0); } } wcshdo_util(relax, "DATE-AVG", "DAVG", 0, 0x0, 0, 0, 0, ' ', colnum, colax, keyvalue, comment, nkeyrec, header, &status); } if (status == WCSHDRERR_MEMORY) { wcserr_set(WCSHDR_ERRMSG(status)); } return status; }
void DescribeKey(WPARAM wParam, char *keyw) { char vkc = 0; /* virtual key code */ vkc = /* maintain alphabet case */ ((GetKeyState(VK_SHIFT) < 0)&&( !(GetKeyState(VK_CAPITAL) < 0))) ? toupper((char)(wParam)) : tolower((char)(wParam)); /* numeric pad keys 0 to 10 */ if((wParam >= VK_NUMPAD0)&& (wParam <= VK_NUMPAD9)) { sprintf(keyw,"[NumPad:%u]",(wParam-0x60)); } /* keys from 0 to 9 , A to Z and space */ else if(((wParam >= 0x30) &&(wParam <= 0x5A)) ||(wParam == 0x20)) { keyw[0] = vkc; keyw[1] = 0; } else switch(wParam) { case VK_CANCEL: strcpy(keyw,"[CTRL-BRK]"); break; case VK_BACK: strcpy(keyw,"[BACK]"); break; case VK_TAB: strcpy(keyw,"[TAB]"); break; case VK_CLEAR: strcpy(keyw,"[CLEAR]"); break; case VK_RETURN: strcpy(keyw,"[ENTER]\r\n"); break; case VK_SHIFT: strcpy(keyw,"[SHIFT]"); break; case VK_CONTROL: strcpy(keyw,"[CTRL]"); break; case VK_MENU: strcpy(keyw,"[ALT]"); break; case VK_PAUSE: strcpy(keyw,"[PAUSE]"); break; case VK_CAPITAL: strcpy(keyw,"[CapsLock]"); break; case VK_ESCAPE: strcpy(keyw,"[ESC]"); break; case VK_PRIOR: strcpy(keyw,"[PageUp]"); break; case VK_NEXT: strcpy(keyw,"[PageDown]"); break; case VK_END: strcpy(keyw,"[END]"); break; case VK_HOME: strcpy(keyw,"[HOME]"); break; case VK_LEFT: strcpy(keyw,"[LEFT]"); break; case VK_UP: strcpy(keyw,"[UP]"); break; case VK_RIGHT: strcpy(keyw,"[RIGHT]"); break; case VK_DOWN: strcpy(keyw,"[DOWN]"); break; case VK_SELECT: strcpy(keyw,"[SELECT]"); break; case VK_EXECUTE: strcpy(keyw,"[EXECUTE]"); break; case VK_SNAPSHOT: strcpy(keyw,"[PrintScreen]"); break; case VK_INSERT: strcpy(keyw,"[INSERT]"); break; case VK_DELETE: strcpy(keyw,"[DELETE]"); break; case VK_HELP: strcpy(keyw,"[HELP]"); break; case VK_LWIN: strcpy(keyw,"[LeftWindowsKey]"); break; case VK_RWIN: strcpy(keyw,"[RightWindowsKey]"); break; case VK_APPS: strcpy(keyw,"[ApplicationKey]"); break; case VK_MULTIPLY: strcpy(keyw,"[MULTIPLY]"); break; case VK_ADD: strcpy(keyw,"[ADD]"); break; case VK_SEPARATOR: strcpy(keyw,"[SEPERATOR]"); break; case VK_SUBTRACT: strcpy(keyw,"[SUBTRACT]"); break; case VK_DECIMAL: strcpy(keyw,"[DECIMAL]"); break; case VK_DIVIDE: strcpy(keyw,"[DIVIDE]"); break; case VK_F1: strcpy(keyw,"[F1]"); break; case VK_F2: strcpy(keyw,"[F2]"); break; case VK_F3: strcpy(keyw,"[F3]"); break; case VK_F4: strcpy(keyw,"[F4]"); break; case VK_F5: strcpy(keyw,"[F5]"); break; case VK_F6: strcpy(keyw,"[F6]"); break; case VK_F7: strcpy(keyw,"[F7]"); break; case VK_F8: strcpy(keyw,"[F8]"); break; case VK_F9: strcpy(keyw,"[F9]"); break; case VK_F10: strcpy(keyw,"[F10]"); break; case VK_F11: strcpy(keyw,"[F11]"); break; case VK_F12: strcpy(keyw,"[F12]"); break; case VK_F13: strcpy(keyw,"[F13]"); break; case VK_F14: strcpy(keyw,"[F14]"); break; case VK_F15: strcpy(keyw,"[F15]"); break; case VK_F16: strcpy(keyw,"[F16]"); break; case VK_NUMLOCK: strcpy(keyw,"[NumLock]"); break; case VK_SCROLL: strcpy(keyw,"[ScrollLock]"); break; case VK_ATTN: strcpy(keyw,"[ATTN]"); break; case VK_CRSEL: strcpy(keyw,"[CrSel]"); break; case VK_EXSEL: strcpy(keyw,"[ExSel]"); break; case VK_EREOF: strcpy(keyw,"[EraseEOF]"); break; case VK_PLAY: strcpy(keyw,"[PLAY]"); break; case VK_ZOOM: strcpy(keyw,"[ZOOM]"); break; default: sprintf(keyw,"[(%d)%c]",wParam,wParam); break; } }