static void
render_tone (PangoFont *font, gunichar tone, PangoGlyphString *glyphs,
int *n_glyphs, int cluster_offset)
{
int index;
index = find_char (font, tone);
pango_glyph_string_set_size (glyphs, *n_glyphs + 1);
if (index)
{
set_glyph_tone (font, glyphs, *n_glyphs, cluster_offset, index);
}
else
{
/* fall back : HTONE1(0x302e) => middle-dot, HTONE2(0x302f) => colon */
index = find_char (font, tone == HTONE1 ? 0x00b7 : 0x003a);
if (index)
{
set_glyph_tone (font, glyphs, *n_glyphs, cluster_offset, index);
}
else
set_glyph (font, glyphs, *n_glyphs, cluster_offset,
get_unknown_glyph (font, tone));
}
(*n_glyphs)++;
}
main(){
char *source = "ABCDEFG";
char *s1 = "XYZ";
char *s2 = "JURY";
char *s3 = "QQQQ";
char *s4 = "XRCQEF";
char *result;
if((result = find_char(source, s1)) == NULL) {
printf("Given %s %s Returned NULL\n", source, s1);
} else {
printf("Given %s %s Returned %c\n", source, s1, *result);
}
if((result = find_char(source, s2)) == NULL) {
printf("Given %s %s Returned NULL\n", source, s2);
} else {
printf("Given %s %s Returned %c\n", source, s2, *result);
}
if((result = find_char(source, s3)) == NULL) {
printf("Given %s %s Returned NULL\n", source, s3);
} else {
printf("Given %s %s Returned %c\n", source, s3, *result);
}
if((result = find_char(source, s4)) == NULL) {
printf("Given %s %s Returned NULL\n", source, s4);
} else {
printf("Given %s %s Returned %c\n", source, s4, *result);
}
}
/**
* Cut spaces (or other char) from left/right of the string
*/
p2String& p2String::trim(int left, int right, char ch)
{
if(string != NULL)
{
unsigned int pos_left = find_char(ch, 0);
unsigned int pos_right = find_char(ch, 1);
if(left)
{
if(pos_left > 0)
{
memcpy(string, &string[pos_left], size - pos_left);
string[size - pos_left] = 0;
}
}
if(right)
{
if(pos_right < size - 1)
{
string[pos_right - pos_left + 1] = '\0';
}
}
update();
}
return(*this);
}
/* This is a fallback for when we get a tone mark not preceded
* by a syllable.
*/
static void
render_isolated_tone (PangoFont *font, gunichar tone, PangoGlyphString *glyphs,
int *n_glyphs, int cluster_offset)
{
#if 0 /* FIXME: what kind of hack is it? it draws dummy glyphs. */
/* Find a base character to render the mark on
*/
int index = find_char (font, 0x25cc); /* DOTTED CIRCLE */
if (!index)
index = find_char (font, 0x25cb); /* WHITE CIRCLE, in KSC-5601 */
if (!index)
index = find_char (font, ' '); /* Space */
if (!index) /* Unknown glyph box with 0000 in it */
index = find_char (font, PANGO_GET_UNKNOWN_GLYPH (0));
/* Add the base character
*/
pango_glyph_string_set_size (glyphs, *n_glyphs + 1);
set_glyph (font, glyphs, *n_glyphs, cluster_offset, index);
(*n_glyphs)++;
#endif
/* And the tone mark
*/
render_tone(font, tone, glyphs, n_glyphs, cluster_offset);
}
/* Return a pointer to a string containing the array size */
char *parse_array_size (char string[]) {
char output_buffer[BUFFER_LEN];
int length;
char *size_string, *ptr = string;
memset (output_buffer, '\0', BUFFER_LEN);
ptr = find_char (ptr, '(');
while (ptr < find_char(string,')')) {
if (strlen(output_buffer) != 0) strcat (output_buffer, "*");
length = min (find_char(ptr,',')-ptr, find_char(ptr,')')-ptr) - 1;
strcat (output_buffer, "(");
if (find_char(ptr,':')-ptr < length) {
strcat (output_buffer, "1-");
strncat (output_buffer, ptr, find_char(ptr,':')-ptr-1);
strcat (output_buffer, "+");
ptr = find_char (ptr, ':');
length = min (find_char(ptr,',')-ptr, find_char(ptr,')')-ptr) - 1;
}
strncat (output_buffer, ptr, length);
strcat (output_buffer, ")");
ptr = skip_blanks (find_char (ptr, ','));
}
size_string = malloc (strlen(output_buffer)+1);
if (size_string == NULL) memory_error ();
strcpy (size_string, output_buffer);
return (size_string);
}
static void parse_KernData_line(struct temp_font *tf, char *line) {
int ch, ch2, kern;
char name[200], name2[200];
struct kern_info *ki;
while ( isspace(*line)) ++line;
if ( *line=='\0' )
return;
if ( sscanf(line,"KPX %s %s %d", name, name2, &kern )!= 3 ) {
if ( sscanf(line,"KP %s %s %d", name, name2, &kern )!= 3 ) {
fprintf( stderr, "Bad afm kern line <%s>\n", line );
return;
}
}
if ( (ch = find_char(tf,name))== -1 ) {
if ( tf->is_8859_1 )
fprintf( stderr, "Unknown character name <%s>\n", name );
return;
}
if ( (ch2 = find_char(tf,name2))== -1 ) {
if ( tf->is_8859_1 )
fprintf( stderr, "Unknown character name <%s>\n", name2 );
return;
}
tf->per_char[ch].attributes |= AFM_KERN;
ki = malloc(sizeof(struct kern_info));
ki->next = tf->kerns[ch];
tf->kerns[ch] = ki;
ki->following = ch2;
ki->kern = kern;
}
/*
* This function forms a search string, to look for the best
* letter to underline in a menu item. It first tries the
* accelerator key, then the uppercase letters from the menu name,
* then the digits, and finally the lowercase letters.
* It ignores spaces.
*/
static void set_search_string(char *search, const char *name, int key)
{
int source;
int dest = 0;
int mb_len;
mbstate_t mb_st;
/* handle a couple of special cases first */
if (! string_diff(name, "Cut")) search[dest++] = 't';
if (! string_diff(name, "Exit")) search[dest++] = 'x';
if (! string_diff(name, "?")) search[dest++] = '?';
{
/* If there is an '&' in the string, use the next letter first */
char *p = strchr(name, '&');
if (p && *(p+1)) search[dest++] = *(p+1);
}
/* add the accelerator key if it is in the name string */
if (key) {
key = toupper(key);
if (find_char(key, name) >= 0)
search[dest++] = (char) key;
else {
key = tolower(key);
if (find_char(key, name) >= 0)
search[dest++] = (char) key;
}
}
/* add the uppercase letters */
for (source=0; name[source]; source++) {
mbs_init(mb_st);
mb_len = Rf_mbrtowc(NULL, name + source, MB_CUR_MAX,&mb_st);
if (mb_len > 1) source += mb_len-1;
else
if (isupper(name[source])) search[dest++] = name[source];
}
/* add the digits */
for (source=0; name[source]; source++) {
mbs_init(mb_st);
mb_len = Rf_mbrtowc(NULL, name + source, MB_CUR_MAX,&mb_st);
if (mb_len > 1) source += mb_len-1;
else
if (isdigit(name[source])) search[dest++] = name[source];
}
/* add the lowercase letters */
for (source=0; name[source]; source++) {
mbs_init(mb_st);
mb_len = Rf_mbrtowc(NULL, name + source, MB_CUR_MAX,&mb_st);
if (mb_len > 1) source += mb_len-1;
else
if (islower(name[source])) search[dest++] = name[source];
}
/* end the search string */
search[dest] = '\0';
}
//////////////////////////////////////////////////////////
// PRE:
// POST: RetVal == vector of Strings split from this by ch
//
//
std::vector<String> String::split(char ch) const
{
std::vector<String> result;
int start = 0;
int end = find_char(ch, 0); // find the first occurance of ch
while(end < length() && end != -1)
{
result.push_back(substr(start, end)); // add the substring between start and end to result
start = end + 1; // move start to one after end
end = find_char(ch, start); // find the next occurance of ch
}
return result;
}
mod_pointer get_module_name (void)
{
{ eight_bits c; char* k=mod_text; /* points to last recorded character */
do
{ if (!find_char())
{ err_print("! Input ended in module name"); break; }
c=*loc++;
if (c=='@')
{ if ((c=*loc++)=='>') break;
if (isspace(c) || c=='*' || c=='~')
{ err_print("! Module name didn't end"); loc-=2; break; }
if (k<mod_text_end-1) *++k='@';
/* record the `\.{@}', now |c==loc[-1]| again */
}
if (isspace(c)) c=' '; /* convert tabs, newlines etc. */
if (k<mod_text_end-1 && !(c==' ' && *k==' ') ) *++k=c;
} while(true);
id_first=&mod_text[1];
if (k>=mod_text_end-1)
{ print("\n! Module name too long: ");
term_write(id_first,25); err_print("..");
}
id_loc= *k==' ' && k>mod_text ? k : k+1;
/* point after last non-space character */
}
{ int l=(int)(id_loc-id_first);
return l>=3 && strncmp(id_loc-3,"...",3)==0
? prefix_lookup(id_first,l-3) : mod_name_lookup(id_first,l);
}
}
gboolean
ide_xml_find_previous_element (const GtkTextIter *iter,
GtkTextIter *start,
GtkTextIter *end)
{
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (start != NULL, FALSE);
g_return_val_if_fail (end != NULL, FALSE);
if(find_char (gtk_text_iter_backward_char, iter, end, '>') &&
find_char (gtk_text_iter_backward_char, end, start, '<') &&
gtk_text_iter_compare (start, end) < 0)
return TRUE;
return FALSE;
}
/* current should point to the opening quote
* here we return the location of the ending quote
*
* We allow empty strings and escaped quote characters
*
* on error we return zero and status is set
*/
static size_t find_end_of_quoted_string(const struct cfg_string *str,
size_t current,
enum cfg_status *status)
{
size_t loc=0;
*status = CFG_EOF;
if (current == (str->size-1)) {
return 0;
}
// skip past the quote
current++;
while (1) {
loc = find_char(str, current, CFG_QUOTE, status);
// the end of the word could come with no white space, that is OK too
if (*status) {
break;
}
if (str->data[loc-1] == CFG_ESCAPE) {
current=loc+1;
continue;
} else {
break;
}
}
return loc;
}
/*
* end will be left on the assignment character
*/
static void find_next_identifier(const struct cfg_string *str,
size_t current,
size_t *beg,
size_t *end,
enum cfg_status *status)
{
while (1) {
// skip any whitespace and comments
current = find_nonwhite(str, current, status);
if (*status) { // EOF
return;
}
*beg=current;
// now find the assignment character
current = find_char(str, current, CFG_ASSIGN, status);
if (*status) {
// this can't be good; must have left off the assignment char
return;
}
*status = CFG_SUCCESS;
*end=current;
break;
}
}
int main(void)
{
char st[SIZE];
char *found;
char ch;
puts("Enter a string:");
while (s_gets(st, SIZE) && st[0] != '\n')
{
puts("Enter a character you want to find:");
ch = getchar();
while (getchar() != '\n')
{
continue;
}
found = find_char(st, ch);
if (found != NULL)
{
puts(found);
}
else
{
printf("%c not found in string.\n", ch);
}
puts("Enter next string:");
}
puts("Done!");
return 0;
}
static int
display_char(FILE *fp, int chr)
{
char *s;
int bit, n, high;
char bits[6][MAX_WIDTH];
s = find_char(chr);
if (s != 0) {
fprintf(fp, "Glyph '%c'\n", chr);
bit = 0;
high = 0;
do {
if (*s >= '?' && *s <= '~') {
for (n = 0; n < 6; n++)
bits[n][bit] = (char) (((*s - '?') & 1 << n) ? 'O' : '.');
bit++;
} else if ((*s == ';' || *s == '/') && bit) {
for (n = 0; (n < 6) && (high++ < MatrixHigh); n++) {
bits[n][bit] = '\0';
fprintf(fp, "%s\n", bits[n]);
}
bit = 0;
}
} while (*s++ != ';');
return TRUE;
}
return FALSE;
}
int main ()
{
char *StringOne = (char *)malloc(StringSize*sizeof(char));
char *StringTwo = (char *)malloc(StringSize*sizeof(char));
if(StringOne==NULL || StringTwo == NULL)
{
printf("The application for RAM failed!Process end.\n\n");
return 0;
}
printf("Please enter the first string and make sure the\
length of the string shorter than 100 characeter(include\
the empty charater)\n\n");
gets(StringOne);
printf("Please enter the second string and make sure the \
length of the string shorter than 100 characeter(include \
the empty charater)\n\n");
gets(StringTwo);
printf("%c\n",*(find_char(StringOne,StringTwo)));
free(StringOne);
free(StringTwo);
StringOne = NULL;
StringTwo = NULL;
return 0;
}
/* Add a variable to a linked list */
void create (struct node *start, int vartype, char string[], char comment[]) {
struct node *end = start, *temp;
if (find_node (start, string) == NULL) {
/* Create a new node and add it to the end of the linked list */
while (end->next != NULL) end = end->next;
end->next = malloc (sizeof(struct node));
if (end->next == NULL) memory_error ();
end = end->next;
end->vartype = vartype;
end->action = NOP;
end->calltype = current_calltype;
end->line_number = current_line;
end->name = calloc (extract_text(string)+1, sizeof(char));
if (end->name == NULL) memory_error ();
copy (end->name, string, extract_text(string));
if ((find_char (string, '(') < find_char (string, ',')) &&
(find_char (string, '(') < find_char (string, '!'))) {
/* Variable is an array */
if (start == common_start) {
/* Array is defined in a common block, so print a warning */
eprint_newline ();
eprint ("Warning - Array size defined in common block:");
eprint_newline ();
eprint_line (current_line);
eprintn (string, find_char(string, ')') - string);
eprint_newline ();
temp = find_node (register_start, string);
if (temp != NULL) {
if (temp->vartype > 0) array_flags[temp->calltype][temp->vartype]=1;
free (temp->size);
temp->size = parse_array_size (string);
end->size = NULL;
}
}
else end->size = parse_array_size (string);
}
else (end->size = NULL);
if (comment != NULL) {
end->title = calloc (strlen(comment), sizeof(char));
if (end->title == NULL) memory_error ();
copy (end->title, comment, strlen(comment)-1);
}
else end->title = NULL;
end->next = NULL;
}
}
char *wordcpy(char *str, char *sep, int i)
{
char *word;
int j;
j = i;
while (find_char(str[j], sep) == 1 && str[j] != '\0')
j++;
if ((word = malloc(sizeof(char) * j - i + 1)) == NULL)
return (NULL);
j = 0;
while (find_char(str[i], sep) == 1 && str[i] != '\0')
word[j++] = str[i++];
word[j] = '\0';
word = epur_str(word);
return (word);
}
void read_white(char* data, esize_t size, esize_t* pos, esize_t* line, herror_t* perror)
{
bool_t condition;
condition = find_char(data[*pos], white_space);
if (!condition) {
*perror = 1;
return;
}
while (condition) {
condition = find_char(data[*pos], white_space);
if (data[*pos] == '\n') {
(*line)++;
}
(*pos)++;
}
}
int main(int argc, char *argv[])
{
int n_states, n_symbols, n_accepting_states;
int i, j;
char string[MAX_LEN];
scanf("%d %d\n", &n_states, &n_symbols);
char alphab[n_symbols];
int table[n_states][n_symbols];
for (i = 0; i < n_symbols; ++i)
scanf("%c", &alphab[i]);
for (i = 0; i < n_states; ++i)
for (j = 0; j < n_symbols; ++j)
scanf("%d", &table[i][j]);
scanf("%d", &n_accepting_states);
int accepting_states[n_accepting_states];
for (i = 0; i < n_accepting_states; ++i)
scanf("%d ", &accepting_states[i]);
fgets(string, MAX_LEN, stdin);
int current_state = 0;
int word_length = strlen(string) - 1;
int done = 0;
// if (word_length == 0)
if (string[word_length] == '\n')
string[word_length] = '\0';
while(done != 1)
{
for (i = 0; i < word_length; ++i)
{
if (string[i] == '.')
{
done = 1;
break;
}
int char_index = find_char(alphab, n_symbols, string[i]);
current_state = table[current_state][char_index];
}
}
printf("DFA has %saccepted input %s Ended in state %d.\n",
find_state(accepting_states, n_accepting_states, current_state) == -1
? "NOT " : "",
strtok(string, "."),
current_state);
return 0;
}
int main()
{
char *source = "ABCDEF";
char *chars = "ESmSG";
char *result;
result = find_char(source, chars);
printf("%c\r\n", *result);
return 0;
}
int main(void) {
char *source = "ABCDEF";
char *chars = "XRCEF";
char *res = find_char(source, chars);
if (res == NULL) {
printf("res is null\n");
} else {
printf("%c\n", *res);
}
}
int nb_word(char *str, char *sep)
{
int i;
int nb;
i = 0;
nb = 0;
while (str[i])
{
if (find_char(str[i], sep) == 1)
{
++nb;
while (str[i] != '\0' && find_char(str[i], sep) == 1)
++i;
}
else
++i;
}
return (nb);
}
int main(int argc, char const *argv[]) {
char *source = "ABCDEF";
char *chars = "erwtwEt";
char const *ch = NULL;
if( (ch = find_char( source, chars ) ) != NULL )
printf("%c\n", *ch );
else
printf("NULL \n" );
return 0;
}
/*
* On entry, current should point to the opening array character
* On exit end will point to the closing character.
*/
static size_t copy_array(struct cfg_field *self,
const struct cfg_string *str,
size_t current,
enum cfg_status *status)
{
// skip past the opening brace
current++;
CFG_FIELD_ELTYPE(self) = CFG_ELTYPE_UNKNOWN;
while (1) {
current = find_nonwhite(str, current, status);
if (*status) { // EOF
goto _copy_array_bail;
}
if (str->data[current] == CFG_ARRAY_SEP) {
// this is the separator between elements of array, skip
current++;
continue;
}
if (str->data[current] == CFG_ARRAY_END) {
break;
}
if (str->data[current] == '#') {
// found a comment, skip to next EOL
current = find_char(str, current, '\n', status);
if (*status) { // EOF
goto _copy_array_bail;
}
continue;
}
if (str->data[current] == CFG_QUOTE) {
current = copy_quoted_string(self, str, current, status);
if (*status) {
goto _copy_array_bail;
}
CFG_FIELD_ELTYPE(self) = CFG_ELTYPE_QUOTED_STRING;
// skip ending quote
current ++;
} else {
current = copy_bare_array_token(self, str, current, status);
}
}
_copy_array_bail:
if (CFG_ELTYPE_QUOTED_STRING != CFG_FIELD_ELTYPE(self)) {
// no quoted strings were found, use bare
CFG_FIELD_ELTYPE(self)=CFG_ELTYPE_BARE;
}
return current;
}
int main(int argc, char *argv[])
{
if (1 == argc) {
printf("Enter text as an argument.\n");
return 1;
}
if (!bcm2835_init()) {
printf("Unable to init bcm2835.\n");
return 2;
}
bcm2835_spi_begin();
bcm2835_spi_setBitOrder(BCM2835_SPI_BIT_ORDER_MSBFIRST); // The default
bcm2835_spi_setDataMode(BCM2835_SPI_MODE0); // The default
bcm2835_spi_setClockDivider(BCM2835_SPI_CLOCK_DIVIDER_256); // The default
bcm2835_gpio_fsel(Max7219_pinCS, BCM2835_GPIO_FSEL_OUTP);
bcm2835_gpio_write(disp1[0][0],HIGH);
Delay_xms(50);
Init_MAX7219();
size_t index = 0;
while (index < strlen(argv[1])) {
// Retrive first letter
char letter1 = toupper(argv[1][index]);
index++;
// Retrieve second letter
// If it does not exist use space
char letter2 = (index < strlen(argv[1])) ? toupper(argv[1][index]) : (char) 0;
led_print(find_char(letter1), find_char(letter2));
Delay_xms(1000);
index++;
}
// Clear screen
led_print(36, 36);
bcm2835_spi_end();
bcm2835_close();
return 0;
}
//
// handles "find" and "purge" in one function
bool try_reset_old_mobile(RESET_DATA *reset, void *initiator,int initiator_type,
int reset_cmd, const char *locale) {
const char *fullkey = get_fullkey_relative(resetGetArg(reset), locale);
CHAR_DATA *mob = NULL;
// is it the room?
if(initiator_type == INITIATOR_ROOM)
mob = find_char(NULL, roomGetCharacters(initiator),1, NULL, fullkey, FALSE);
// is it furniture?
else if(initiator_type == INITIATOR_ON_OBJ)
mob = find_char(NULL, objGetUsers(initiator), 1, NULL, fullkey, FALSE);
// after an object
else if(initiator_type == INITIATOR_THEN_OBJ) {
if(objGetRoom(initiator) == NULL)
return FALSE;
mob = find_char(NULL, roomGetCharacters(objGetRoom(initiator)), 1, NULL,
fullkey, FALSE);
}
// after another mob
else if(initiator_type == INITIATOR_THEN_MOB)
mob = find_char(NULL, roomGetCharacters(charGetRoom(initiator)), 1, NULL,
fullkey, FALSE);
// if we didn't find it, return FALSE
if(mob == NULL)
return FALSE;
// if we found it, do the reset of the commands
resetRunOn(reset->on, mob, INITIATOR_ON_MOB, locale);
resetRunOn(reset->in, mob, INITIATOR_IN_MOB, locale);
resetRunOn(reset->then, mob, INITIATOR_THEN_MOB, locale);
// if this is a purge and it wasn't our initiator, kill it
// if we purge our initiator, we might run into some problems
if(mob != initiator && reset_cmd == RESET_PURGE_MOBILE)
extract_mobile(mob);
return TRUE;
}
static int name_char(struct temp_font *tf,int ch, char *name) {
if ( tf->is_adobe )
return( find_char(tf,name));
if ( ch>=tf->max_alloc ) {
if ( tf->max_alloc==256 ) tf->max_alloc = 128*256; else tf->max_alloc = 65536;
tf->per_char = realloc(tf->per_char,tf->max_alloc*sizeof(XCharStruct));
tf->kerns = realloc(tf->kerns,tf->max_alloc*sizeof(struct kern_info *));
}
if ( ch!=-1 && ch<256 && name[0]!='\0')
tf->names[ch] = copy(name);
return( ch );
}
char *get_env(char *name, char **env)
{
int n, i;
for (i = 0; env[i] != NULL ; i++)
{
if (str_ncmp(env[i], name, str_len(name)) == 0 )
{
n = find_char(env[i], '=');
return env[i] + n + 1;
}
}
return "";
}
static void quote_author_pack(const char *begin, const char *end, FILE *fp,
filter_t filter)
{
const char *user_begin = begin + sizeof("发信人: ") - 1;
const char *lend = get_newline(begin, end);
const char *user_end = reverse_find_char(begin, lend, ',');
begin = get_newline(lend, end);
lend = get_newline(begin, end);
const char *date_begin = find_char(begin, lend, '(');
if (date_begin)
++date_begin;
const char *date_end = find_char(begin, lend, ')');
PRINT_CONST_STRING(" \033[0;1;32m");
if (user_end && user_end > user_begin)
filter(user_begin, user_end - user_begin, fp);
PRINT_CONST_STRING(" 于 \033[1;36m");
if (date_begin && date_end > date_begin)
filter(date_begin, date_end - date_begin, fp);
PRINT_CONST_STRING("\033[0;1m 提到：\033[0m\n\n");
}
int main(void)
{
char str[CLIMIT], strc[CLIMIT], src[CLIMIT], c, pch;
printf("Enter a string, a substring, and a character:\n");
if(scanf("%s", str) !=1){
printf("Invalid input.\n");
return EXIT_FAILURE;
}
pch = getc(stdin);
if(pch != ' '){
printf("Invalid input.\n");
return EXIT_FAILURE;
}
if(scanf("%s", src) !=1){
printf("Invalid input.\n");
return EXIT_FAILURE;
}
pch = getc(stdin);
if(pch != ' '){
printf("Invalid input.\n");
return EXIT_FAILURE;
}
c = getc(stdin);
if((c == '\n') ||(c == '\0')){
printf("Invalid input.\n");
return EXIT_FAILURE;
}
pch = getc(stdin);
if(pch != '\n'){
printf("Invalid input.\n");
return EXIT_FAILURE;
}
strncpy(strc, str, CLIMIT);
if(find_string(str, src) != EXIT_SUCCESS)
return EXIT_FAILURE;
if(find_char(strc, c) != EXIT_SUCCESS)
return EXIT_FAILURE;
return EXIT_SUCCESS;
}
