Пример #1
0
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);
}
Пример #2
0
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;
}
Пример #3
0
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;
}
Пример #4
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);
	}
      }
    }
  }
Пример #5
0
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);
}
Пример #8
0
Файл: main.c Проект: JoeDog/fido
/**
 * 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);
  }
}
Пример #9
0
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);
	}
	
}
Пример #10
0
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;
}
Пример #11
0
Файл: string.c Проект: hbao/LCUI
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;
}
Пример #12
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');
}
Пример #13
0
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);
	}
}
Пример #14
0
/* ----------------------------------------------------------------------------*/
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;
    }
}
Пример #15
0
  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();
  }
Пример #16
0
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;
}
Пример #17
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;
}
Пример #18
0
void displaymap(unsigned char c, char *buf)
{
    buf[0] = '^';
    if (IS_CTRL(c))
        buf[1] = c + 64;
    else
        buf[1] = uppercase(c);
}
Пример #19
0
/* ------------------------------------------------------------------------*//**
 * @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;
}
Пример #21
0
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);
        }
    }
}
Пример #22
0
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);
}
Пример #23
0
int Register::getReg(string regName) {
	string key = uppercase(regName);
	bool isExist = regs.count(key) > 0;
	if (!isExist) {
		regs[key] = 0;
	}

	return regs[key];
}
Пример #24
0
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];
}
Пример #25
0
int GetBoolean()
{
    if (!IsBoolean(Look)) {
        Expected("Boolean Literal");
    }
    int ret = uppercase(Look) == 'T';
    GetChar();
    return ret;
}
Пример #26
0
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);
}
Пример #27
0
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;
}
Пример #28
0
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 */
Пример #29
0
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;
}
Пример #30
0
int main()
{
    char *none = 0;
    static char *strings[] = {"apple", "banana", "carrot", "daikon",
			      "eggplant", "fig", "grape", 0 };
    f(strings[1], strings);

    uppercase("huckleberry");

    return 0;
}