void InputControlListener::refreshSIP()
{
pp_int32 i;
PPContainer* container = tracker.inputContainerExtended;
for (i = 0; i < (signed)sizeof(keyLine_0_lowerCase); i++)
{
PPButton* button = static_cast<PPButton*>(container->getControlByID(keyLineIDs_0[i]));
button->setText(uppercase() ? keyLine_0_lowerCase[i] : keyLine_0_upperCase[i]);
}
for (i = 0; i < (signed)sizeof(keyLine_1_lowerCase); i++)
{
PPButton* button = static_cast<PPButton*>(container->getControlByID(keyLineIDs_1[i]));
button->setText(uppercase() ? keyLine_1_lowerCase[i] : keyLine_1_upperCase[i]);
}
for (i = 0; i < (signed)sizeof(keyLine_2_lowerCase); i++)
{
PPButton* button = static_cast<PPButton*>(container->getControlByID(keyLineIDs_2[i]));
button->setText(uppercase() ? keyLine_2_lowerCase[i] : keyLine_2_upperCase[i]);
}
for (i = 0; i < (signed)sizeof(keyLine_3_lowerCase); i++)
{
PPButton* button = static_cast<PPButton*>(container->getControlByID(keyLineIDs_3[i]));
button->setText(uppercase() ? keyLine_3_lowerCase[i] : keyLine_3_upperCase[i]);
}
tracker.screen->paintControl(container);
}
Haplotype* generate_haplotype(int32_t pos, Region& str_region, int32_t max_ref_flank_len, std::string& chrom_seq,
std::vector<std::string>& vcf_alleles, StutterModel* stutter_model,
std::vector<HapBlock*>& blocks, std::ostream& logger){
assert(blocks.size() == 0);
assert(vcf_alleles.size() >= 1);
int32_t rep_region_start = pos;
int32_t rep_region_end = rep_region_start + vcf_alleles[0].size();
int32_t min_start = (rep_region_start < max_ref_flank_len ? 1 : rep_region_start-max_ref_flank_len);
int32_t max_stop = rep_region_end + max_ref_flank_len;
assert(uppercase(vcf_alleles[0]).compare(uppercase(chrom_seq.substr(rep_region_start, rep_region_end-rep_region_start))) == 0);
// Create a set of haplotype regions, consisting of STR sequence block flanked by two reference sequence stretches
blocks.push_back(new HapBlock(min_start, rep_region_start, uppercase(chrom_seq.substr(min_start, rep_region_start-min_start)))); // Ref sequence preceding STRS
blocks.push_back(new RepeatBlock(rep_region_start, rep_region_end,
uppercase(chrom_seq.substr(rep_region_start, rep_region_end-rep_region_start)), str_region.period(), stutter_model));
blocks.push_back(new HapBlock(rep_region_end, max_stop, uppercase(chrom_seq.substr(rep_region_end, max_stop-rep_region_end)))); // Ref sequence following STRs
for (unsigned int j = 1; j < vcf_alleles.size(); j++)
blocks[1]->add_alternate(vcf_alleles[j]);
// Initialize each block's data structures, namely the homopolymer length information
for (unsigned int i = 0; i < blocks.size(); i++)
blocks[i]->initialize();
logger << "Constructing haplotype" << std::endl;
Haplotype* haplotype = new Haplotype(blocks);
haplotype->print_block_structure(30, 100, logger);
return haplotype;
}
static int process_hostility(char *line)
{
int n;
char a[255], b[255];
int hostility;
int f1, f2;
n = sscanf(line, "hostility %[A-Za-z] %[A-Za-z] %d", a, b, &hostility);
if (n != 3)
return -1;
uppercase(a);
uppercase(b);
f1 = lookup_faction(a);
if (f1 < 0) {
fprintf(stderr, "Bad faction '%s'\n", a);
return -1;
}
f2 = lookup_faction(b);
if (f2 < 0) {
fprintf(stderr, "Bad faction '%s'\n", b);
return -1;
}
fact[f1].hostility[f2] = (float) hostility / 100.0f;
fact[f2].hostility[f1] = (float) hostility / 100.0f;
return 0;
}
void NEXUS::initialize()
{
// Check #NEXUS
getline(*file,line);
if (line != "#NEXUS")
throw myexception()<<"NEXUS trees reader: File does not begin with '#NEXUS' and may not be a NEXUS file.";
// [ and ] do not break words
string word;
bool in_trees_block=false;
while(get_NEXUS_command(*file,line))
{
// cerr<<"line: "<<line<<endl;
int pos=0;
if (not get_word_NEXUS(word,pos,line)) continue;
// cerr<<"NEXUS: command = :"<<word<<":"<<" in_trees_block = "<<in_trees_block<<endl;
// Parse BEGIN TREES
if (uppercase(word) == "BEGIN") {
if (not get_word_NEXUS(word,pos,line)) continue;
if (uppercase(word) == "TREES")
in_trees_block = true;
}
if (not in_trees_block) continue;
// Parse TRANSLATE ...
if (uppercase(word) == "TRANSLATE") {
parse_translate_command(line.substr(pos,line.size()-pos));
// cerr<<"leaf names = "<<join(leaf_names,',')<<endl;
line.clear();
return;
}
else if (uppercase(word) == "TREE") {
try {
get_word_NEXUS(word,pos,line);
if (not (word == "="))
get_word_NEXUS(word,pos,line);
NEXUS_skip_ws(pos,line);
SequenceTree T;
string t = strip_NEXUS_comments(line.substr(pos,line.size()-pos));
T.parse(t);
leaf_names = T.get_sequences();
std::sort(leaf_names.begin(),leaf_names.end());
return;
}
catch (std::exception& e) {
cerr<<" Error! "<<e.what()<<endl;
cerr<<" Quitting read of tree file."<<endl;
file->setstate(std::ios::badbit);
}
}
}
}
void CheckTimidityConfig(void)
{
if (*s_timiditycfgpath)
if (M_FileExists(s_timiditycfgpath))
C_Output("Using TiMidity configuration file %s.", uppercase(s_timiditycfgpath));
else
C_Warning("Can't find TiMidity configuration file %s.", uppercase(s_timiditycfgpath));
}
int main (void)
{
char uppercase (char string[]);
char string[] = { "Test" };
char string2[] = { "THIS is THE second" };
char string3[] = { "abcdefghijklmnopqrstuvxyz" };
uppercase (string);
printf("\nTEST 1 i Test, o s/b TEST = %s\n", string);
uppercase (string2);
printf("\nTEST 2 i Test, o s/b THIS IS THE SECOND= %s\n", string2);
uppercase (string3);
printf("\nTEST 3 i Test, o s/b ABCDEFGHIJKLMNOPQRSTUVWXYZ = %s\n", string3);
}
int main(void)
{
char c;
c = uppercase('a');
printf("%c\n", c);
c = uppercase('h');
printf("%c\n", c);
c = uppercase('A');
printf("%c\n", c);
c = uppercase('}');
printf("%c\n", c);
return (0);
}
/**
* version_string is defined in version.c adding it to a
* separate file allows us to parse it in configure.
*/
void
display_version(BOOLEAN b) {
char name[128];
memset(name, 0, sizeof name);
strncpy(name, program_name, strlen(program_name));
if(b == TRUE){
printf("%s %s\n\n%s\n", uppercase(name, strlen(name)), version_string, copyright);
exit(EXIT_SUCCESS);
} else {
printf("%s %s\n", uppercase(name, strlen(name)), version_string);
}
}
void addpet(Tree *pt){
Item temp;
if(TreeIsFull(pt)){
puts("No room in the club!");
}else{
puts("Please enter name of pet: ");
fgets(temp.petname,MAXN,stdin);
puts("Please enter kind of pet: ");
fgets(temp.petkind,MAXN,stdin);
uppercase(temp.petname);
uppercase(temp.petkind);
AddItem(&temp,pt);
}
}
static void codegen_ebml_union_content_from_type(struct_data *def,
char *name, int type, FILE *out) {
int i;
for (i = 0; i < def->info.member_count; i++) {
if (memb_struct_check(&def->info.members[i])) {
char uppercased[strlen(def->info.members[i].type_info.substruct_info.type_name)+1];
uppercase(def->info.members[i].type_info.substruct_info.type_name,uppercased);
fprintf(out," case %d: {\n",i);
fprintf(out," uber.actual = &(actual->%s);\n ",
def->info.members[i].name);
if (type) {
fprintf(out,"uber.type = EBML_%s;\n",uppercased);
fprintf(out," res += info_pack_to_ebml(&ebml[res],&uber);\n");
} else {
fprintf(out,"uber.type = DEBML_%s;\n",uppercased);
fprintf(out," res += info_unpack_fr_ebml(&ebml[res],&uber);\n");
}
fprintf(out," break;\n }\n");
}
/* TODO: handle unions of primitives (ints,floats,strings...) */
}
return;
}
LCUI_API int LCUI_strcasecmpW( const wchar_t *str1, const wchar_t *str2 )
{
const wchar_t *p1, *p2;
for(p1=str1, p2=str2; *p1!=0 || *p2!=0; ++p1, ++p2) {
if(uppercase(*p1) == uppercase(*p2)) {
continue;
}
return *p1-*p2;
}
if( *p1 != 0 ) {
return 1;
} else if( *p2 != 0 ) {
return -1;
}
return 0;
}
void main()
{
clrscr();
int choice;
char ch;
do{clrscr();
cout<<"\n MENU ";
cout<<"\n 1.CREATE";
cout<<"\n 2.DISPLAY";
cout<<"\n 3.NO OF UPPER CASE CHARACTERS ";
cout<<"\n 4.NO OF VOWELS";
cout<<"\n 5.NO OF DIGITS";
cout<<"\n 6.NO OF WORDS";
cout<<"\n 7.NUMBER OF LINES";
cout<<"\n enter ur choice";
cin>>choice;
switch(choice)
{
case 1:create();break;
case 2:display();break;
case 3:uppercase();break;
case 4:vowels();break;
case 5:digits();break;
case 6:words();break;
case 7:lines();break;
default: cout<<"\n wrong choice entered..!!";
}
cout<<"\n do you want to continue...??";
cin>>ch;
}
while(ch=='y'||ch=='Y');
}
void addpet(Tree * pt){
Item temp;
if(TreeIsFull(pt)){
puts("No room in the club");
}
else{
puts("Please enter name of pet");
gets(temp.petname);
puts("please enter pet kind");
gets(temp.petkind);
uppercase(temp.petname);
uppercase(temp.petkind);
AddItem(&temp,pt);
}
}
/* ----------------------------------------------------------------------------*/
char* programaDisciplina(char* disc){
FILE *fd;
char texto[10];
string str;
/* Normaliza e obtem o nome do arquivo correspondente
* a disciplina passada como parametro*/
uppercase(disc);
strcpy(texto, disc);
strcat(texto, ".txt");
fd = fopen(texto, "r");
/* Verifica se a abertura do arquivo foi bem sucedida */
if(fd == NULL){
printf("Erro ao abrir o arquivo da disciplina %s.\n", disc);
exit(-1);
}
else{
char tmp[200];
char *pch;
/* Inicializa um vetor contendo a resposta */
str = str_initialize(((size_t)NUM_MAX_DISCIPLINAS * TAM_MAX_NOME_DISCIPLINA));
/* Le o titulo da disciplina */
fgets(tmp, sizeof(tmp), fd);
str_concat_chararr(str, tmp, sizeof(tmp) -1);
/* Le o resto do arquivo */
while(fgets(tmp, sizeof(tmp), fd)!=NULL){
/* Separa a linha lida */
pch = strtok(tmp, " ");
/* Imprime a linha lida */
while(pch !=NULL){
/* Para a impressao caso se depare com a palavra "Horário:" */
if(strcmp(pch, "Horário:\n") ==0){
str_concat_chararr(str, "\n", sizeof(char));
fclose(fd);
return str->s;
}
else{
str_concat_chararr(str, pch, strlen(pch));
str_concat_chararr(str, " ", sizeof(char));
}
pch = strtok(NULL, " ");
}
}
str_concat_chararr(str, "\n", sizeof(char));
fclose(fd);
return str->s;
}
}
bool NEXUS::next_tree_(Tree& T,int& r)
{
if (not line.size())
get_NEXUS_command(*file,line);
if (not line.size()) return false;
try {
string word;
int pos=0;
get_word_NEXUS(word,pos,line);
if (uppercase(word) == "END") {
file->setstate(std::ios::badbit);
return false;
}
get_word_NEXUS(word,pos,line);
if (not (word == "=")) {
get_word_NEXUS(word,pos,line);
assert(word == "=");
}
NEXUS_skip_ws(pos,line);
string t = strip_NEXUS_comments(line.substr(pos,line.size()-pos));
if (leaf_names.size())
r = T.parse_with_names(t, leaf_names);
else
r = T.parse_no_names(t);
}
catch (std::exception& e) {
cerr<<" Error! "<<e.what()<<endl;
cerr<<" Quitting read of tree file."<<endl;
file->setstate(std::ios::badbit);
return false;
}
line.clear();
return not done();
}
int main (void) {
int caractere,
ultimaFoiMaiuscula = 0;
while (caractere = getc(stdin), caractere != EOF) {
if (ehLetra(caractere)) {
if (ultimaFoiMaiuscula) {
putc(lowercase(caractere), stdout);
}
else {
putc(uppercase(caractere), stdout);
}
ultimaFoiMaiuscula = !ultimaFoiMaiuscula;
}
else {
putc(caractere, stdout);
}
if (caractere == '\n') {
ultimaFoiMaiuscula = 0;
}
}
return 0;
}
// MS SQL 2000
char *msql2k (char *pwd, char *salt) {
static char sql2k[128];
SHA_CTX ctx;
char uc[128];
wchar_t wcs[128];
uint8_t sbin[32], out[32];
size_t plen, slen;
int i, idx=0;
idx=init_entry (sql2k, salt, sbin, 1);
// convert to uppercase
uppercase (uc, pwd);
// convert password to Unicode
plen=mbstowcs (wcs, uc, sizeof wcs);
// hash with salt
SHA1_Init (&ctx);
SHA1_Update (&ctx, wcs, plen*2);
SHA1_Update (&ctx, sbin, idx - VERSION_LEN);
SHA1_Final (out, &ctx);
// format to hex
for (i=0; i<SHA_DIGEST_LENGTH; i++) {
_snprintf (&sql2k[(idx+i)*2], 2, "%02X", out[i]);
}
return sql2k;
}
void displaymap(unsigned char c, char *buf)
{
buf[0] = '^';
if (IS_CTRL(c))
buf[1] = c + 64;
else
buf[1] = uppercase(c);
}
/* ------------------------------------------------------------------------*//**
* @FUNCTION main44xx_write
* @BRIEF write selected item provided in string argv.
* @RETURNS 0 in case of success
* OMAPCONF_ERR_ARG
* OMAPCONF_ERR_CPU
* OMAPCONF_ERR_REG_ACCESS
* OMAPCONF_ERR_INTERNAL
* @param[in] argc: shell input argument number
* @param[in] argv: shell input argument(s)
* @DESCRIPTION write selected item provided in string argv.
*//*------------------------------------------------------------------------ */
static int main44xx_write(int argc, char *argv[])
{
CHECK_CPU(44xx, OMAPCONF_ERR_CPU);
if (strcmp(argv[0], "audioic") == 0) {
if (argc < 3) {
return err_arg_missing_msg_show(HELP_CATEGORY_MAX);
} else if (argc == 3) {
return twl6040_writereg(
uppercase(argv[1]), uppercase(argv[2]));
} else {
return err_arg_too_many_msg_show(HELP_CATEGORY_MAX);
}
} else {
return err_unknown_argument_msg_show(argv[0]);
}
}
/* convert a letter to upper case */
char *uppercase_string(char * s){
int i = 0;
while ( *(s+i) != '\0' ){
*(s+i) = uppercase ( *(s+i) );
i +=1;
}
return s;
}
void R_InitColormaps(void)
{
dboolean COLORMAP = (W_CheckMultipleLumps("COLORMAP") > 1);
int i;
byte *palsrc, *palette;
wad_file_t *colormapwad;
if (W_CheckNumForName("C_START") >= 0 && W_CheckNumForName("C_END") >= 0)
{
firstcolormaplump = W_GetNumForName("C_START");
lastcolormaplump = W_GetNumForName("C_END");
numcolormaps = lastcolormaplump - firstcolormaplump;
colormaps = Z_Malloc(sizeof(*colormaps) * numcolormaps, PU_STATIC, NULL);
colormaps[0] = W_CacheLumpName("COLORMAP", PU_STATIC);
for (i = 1; i < numcolormaps; i++)
colormaps[i] = W_CacheLumpNum(i + firstcolormaplump, PU_STATIC);
}
else
{
colormaps = Z_Malloc(sizeof(*colormaps), PU_STATIC, NULL);
colormaps[0] = W_CacheLumpName("COLORMAP", PU_STATIC);
}
colormapwad = lumpinfo[W_CheckNumForName("COLORMAP")]->wad_file;
C_Output("Using the COLORMAP lump in %s file %s.",
(colormapwad->type == IWAD ? "IWAD" : "PWAD"), uppercase(colormapwad->path));
// [BH] There's a typo in dcolors.c, the source code of the utility Id
// Software used to construct the palettes and colormaps for DOOM (see
// http://www.doomworld.com/idgames/?id=16644). When constructing colormap
// 32, which is used for the invulnerability powerup, the traditional
// Y luminance values are used (see http://en.wikipedia.org/wiki/YIQ), but a
// value of 0.144 is used when it should be 0.114. So I've grabbed the
// offending code from dcolor.c, corrected it, put it here, and now colormap
// 32 is manually calculated rather than grabbing it from the colormap lump.
// The resulting differences are minor.
palsrc = palette = W_CacheLumpName("PLAYPAL", PU_CACHE);
for (i = 0; i < 255; i++)
{
float red = *palsrc++ / 256.0f;
float green = *palsrc++ / 256.0f;
float blue = *palsrc++ / 256.0f;
float gray = red * 0.299f + green * 0.587f + blue * 0.114f/*0.144f*/;
grays[i] = FindNearestColor(palette, (int)(gray * 255.0f),
(int)(gray * 255.0f), (int)(gray * 255.0f));
if (!COLORMAP)
{
gray = (1.0f - gray) * 255.0f;
colormaps[0][32 * 256 + i] = FindNearestColor(palette, (int)gray, (int)gray, (int)gray);
}
}
}
JNIEXPORT jstring JNICALL Java_Sample1_stringMethod
(JNIEnv* env, jobject obj, jstring string) {
const char* str = env->GetStringUTFChars(string, 0);
char cap[128];
strcpy(cap, str);
env->ReleaseStringUTFChars(string, str);
uppercase(cap);
return env->NewStringUTF(cap);
}
int Register::getReg(string regName) {
string key = uppercase(regName);
bool isExist = regs.count(key) > 0;
if (!isExist) {
regs[key] = 0;
}
return regs[key];
}
unsigned int Register::getLabel(string labelName) {
string key = uppercase(labelName);
bool isExist = labels.count(key) > 0;
if (!isExist) {
throw new UndefinedLabelException(labelName);
}
return labels[key];
}
int GetBoolean()
{
if (!IsBoolean(Look)) {
Expected("Boolean Literal");
}
int ret = uppercase(Look) == 'T';
GetChar();
return ret;
}
static void
tstate_to_text(uint_t tstate, uint_t paniced, char *out, size_t out_sz)
{
if (paniced)
mdb_snprintf(out, out_sz, "panic");
else
thread_state_to_text(tstate, out, out_sz);
uppercase(out);
}
int main()
{
char *lib_file = "./build/libex29.so";
void *lib = dlopen(lib_file, RTLD_NOW);
check(lib != NULL, "Failed to open library %s: %s", lib_file, dlerror());
lib_function func;
int success;
char *test_string = "Hello! This is Mission Control!";
int test_string_length = strlen(test_string);
char *lower_string = malloc(sizeof(char) * test_string_length);
func = dlsym(lib, "lowercase");
func(lower_string, test_string, test_string_length);
success = strncmp(lower_string, "hello! this is mission control!", test_string_length);
check(success == 0,
"(dynamic) Lower Case failed: %s -> %s",
test_string,
lower_string
);
char *upper_string = malloc(sizeof(char) * test_string_length);
func = dlsym(lib, "uppercase");
func(upper_string, test_string, test_string_length);
success = strncmp(upper_string, "HELLO! THIS IS MISSION CONTROL!", test_string_length);
check(success == 0,
"(dynamic) Upper Case failed: %s -> %s",
test_string,
upper_string
);
free(lower_string);
free(upper_string);
lower_string = malloc(sizeof(char) * test_string_length);
lowercase(lower_string, test_string, test_string_length);
success = strncmp(lower_string, "hello! this is mission control!", test_string_length);
check(success == 0,
"(static) Lower Case failed: %s -> %s",
test_string,
lower_string
);
upper_string = malloc(sizeof(char) * test_string_length);
uppercase(upper_string, test_string, test_string_length);
success = strncmp(upper_string, "HELLO! THIS IS MISSION CONTROL!", test_string_length);
check(success == 0,
"(static) Upper Case failed: %s -> %s",
test_string,
upper_string
);
return 0;
error:
return 1;
}
void output_submenu()
{
/* this allows the user to select a different output of distances scheme. */
long loopcount;
boolean done = false;
Char ch;
if (tree_pairing == NO_PAIRING)
return;
loopcount = 0;
while (!done) {
printf ("\nDistances output options:\n");
if ((tree_pairing == ALL_IN_1_AND_2) ||
(tree_pairing == ALL_IN_FIRST))
printf (" F Full matrix.\n");
printf (" V One pair per line, verbose.\n");
printf (" S One pair per line, sparse.\n");
if ((tree_pairing == ALL_IN_1_AND_2) ||
(tree_pairing == ALL_IN_FIRST))
printf ("\n Choose one: (F,V,S)\n");
else
printf ("\n Choose one: (V,S)\n");
fflush(stdout);
scanf("%c%*[^\n]", &ch);
getchar();
uppercase(&ch);
if (strchr("FVS", ch) != NULL) {
switch (ch) {
case 'F':
if ((tree_pairing == ALL_IN_1_AND_2) ||
(tree_pairing == ALL_IN_FIRST))
output_scheme = FULL_MATRIX;
else
/* If this can't be a full matrix... */
continue;
break;
case 'V':
output_scheme = VERBOSE;
break;
case 'S':
output_scheme = SPARSE;
break;
}
done = true;
}
countup(&loopcount, 10);
}
} /* output_submenu */
static int
mod_uppercase(char *buf, size_t len)
{
char tmp[EXPAND_BUFFER];
if (! uppercase(tmp, buf, sizeof tmp))
return 0;
if (strlcpy(buf, tmp, len) >= len)
return 0;
return 1;
}
int main()
{
char *none = 0;
static char *strings[] = {"apple", "banana", "carrot", "daikon",
"eggplant", "fig", "grape", 0 };
f(strings[1], strings);
uppercase("huckleberry");
return 0;
}