string uppercasify P1C(const_string, s) { string target; string ret = xstrdup (s); for (target = ret; *target; target++) { *target = TOUPPER (*target); } return ret; }
char * uppercase(char *s, size_t len){ unsigned char *c, *e; c = (unsigned char*)s; e = c+len; while(c < e){ *c = TOUPPER((unsigned char)(*c)); c++; } return s; }
static void get_unique_type_string (char *string, gfc_symbol *derived) { char dt_name[GFC_MAX_SYMBOL_LEN+1]; sprintf (dt_name, "%s", derived->name); dt_name[0] = TOUPPER (dt_name[0]); if (derived->module) sprintf (string, "%s_%s", derived->module, dt_name); else if (derived->ns->proc_name) sprintf (string, "%s_%s", derived->ns->proc_name->name, dt_name); else sprintf (string, "_%s", dt_name); }
// P R I V A T E M E T H O D S int ACLStr::_FindCh ( IN const TCHAR charToFind, IN BOOL caseSensitive /*=TRUE*/, IN BOOL reverseFind /*=FALSE*/ ) { LPTSTR string = NULL; TCHAR ib[MAX_STRING]; // Initialize this to the // internal buffer. LPTSTR ibPtr = _string; TCHAR chToFind = charToFind; // If the internal string is NULL or the lenght is // zero then we will just bail and say we couldn't // find the string we were searching for. if (ibPtr != NULL || 0 != _length) { if (caseSensitive == TRUE) { chToFind = TOUPPER(charToFind); // Now copy the internal ACLStr buffer to the new // tempory Upper case version. if (_string) { // NOTE: STRCPY_S(target, length, source) - The length parameter is for // the length of the target string, not the source string. STRCPY_S(ib, MAX_STRING, _string); AnsiUpper(ib); ibPtr = ib; } } // case sensitive search? // Go look for the starting point of the string. // if we do NOT find it return STR_NOTFOUND if (reverseFind == TRUE) { string = STRRCHR(ibPtr, chToFind); } else { string = STRCHR(ibPtr, chToFind); } } // search string NULL? return (string == NULL) ? STR_NOTFOUND : (int)(string - ibPtr); } // ::_FindCh
char *tokcasecmp(char *tok, char *target) { char c1, c2; char *t = (char *)target; do { c1 = TOUPPER(*tok); c2 = TOUPPER(pgm_read_byte(t)); if (c2 <= ' ') { /* Match */ if (c1 != 0) { return t; // oops; both strings didn't end. } return 0; //match! } tok++; t++; } while (c1 == c2); /* Non-match. Advance target ptr */ while (pgm_read_byte(t) > ' ') { t++; } return t; }
char * ldap_pvt_str2upper( char *str ) { char *s; /* to upper */ if ( str ) { for ( s = str; *s; s++ ) { *s = TOUPPER( (unsigned char) *s ); } } return( str ); }
PRIVATE BOOL is_html (char * buf) { char * p = strchr(buf,'<'); if (p && (!strncasecomp(p, "<HTML>", 6) || !strncasecomp(p, "<!DOCTYPE HTML", 13) || !strncasecomp(p, "<HEAD", 5) || !strncasecomp(p, "<TITLE>", 7) || !strncasecomp(p, "<BODY>", 6) || !strncasecomp(p, "<PLAINTEXT>", 11) || (p[0]=='<' && TOUPPER(p[1]) == 'H' && p[3]=='>'))) return YES; else return NO; }
/* ARGSUSED */ int capword(int f, int n) { int c, s; RSIZE size; if ((s = checkdirty(curbp)) != TRUE) return (s); if (curbp->b_flag & BFREADONLY) { dobeep(); ewprintf("Buffer is read-only"); return (FALSE); } if (n < 0) return (FALSE); while (n--) { while (inword() == FALSE) { if (forwchar(FFRAND, 1) == FALSE) return (TRUE); } size = countfword(); undo_add_change(curwp->w_dotp, curwp->w_doto, size); if (inword() != FALSE) { c = lgetc(curwp->w_dotp, curwp->w_doto); if (ISLOWER(c) != FALSE) { c = TOUPPER(c); lputc(curwp->w_dotp, curwp->w_doto, c); lchange(WFFULL); } if (forwchar(FFRAND, 1) == FALSE) return (TRUE); while (inword() != FALSE) { c = lgetc(curwp->w_dotp, curwp->w_doto); if (ISUPPER(c) != FALSE) { c = TOLOWER(c); lputc(curwp->w_dotp, curwp->w_doto, c); lchange(WFFULL); } if (forwchar(FFRAND, 1) == FALSE) return (TRUE); } } } return (TRUE); }
const char *fullname(void) { static VSTRING *result; char *cp; int ch; uid_t uid; struct passwd *pwd; if (result == 0) result = vstring_alloc(10); /* * Try the environment. */ if ((cp = safe_getenv("NAME")) != 0) return (vstring_str(vstring_strcpy(result, cp))); /* * Try the password file database. */ uid = getuid(); if ((pwd = getpwuid(uid)) == 0) return (0); /* * Replace all `&' characters by the login name of this user, first * letter capitalized. Although the full name comes from the protected * password file, the actual data is specified by the user so we should * not trust its sanity. */ VSTRING_RESET(result); for (cp = pwd->pw_gecos; (ch = *(unsigned char *) cp) != 0; cp++) { if (ch == ',' || ch == ';' || ch == '%') break; if (ch == '&') { if (pwd->pw_name[0]) { VSTRING_ADDCH(result, TOUPPER(pwd->pw_name[0])); vstring_strcat(result, pwd->pw_name + 1); } } else { VSTRING_ADDCH(result, ch); } } VSTRING_TERMINATE(result); return (vstring_str(result)); }
static void writeHeader(FILE * const headerFileP, const char * const prefix, unsigned int const width, unsigned int const height, unsigned int const nfiles, const char ** const names, const Coord * const coords, const struct pam * imgs) { unsigned int i; fprintf(headerFileP, "#define %sOVERALLX %u\n", prefix, width); fprintf(headerFileP, "#define %sOVERALLY %u\n", prefix, height); fprintf(headerFileP, "\n"); for (i = 0; i < nfiles; ++i) { char * const buffer = strdup(names[i]); Coord const coord = coords[i]; struct pam const img = imgs[i]; unsigned int j; *strchr(buffer, '.') = 0; for (j = 0; buffer[j]; ++j) { if (ISLOWER(buffer[j])) buffer[j] = TOUPPER(buffer[j]); } fprintf(headerFileP, "#define %s%sX %u\n", prefix, buffer, coord.x); fprintf(headerFileP, "#define %s%sY %u\n", prefix, buffer, coord.y); fprintf(headerFileP, "#define %s%sSZX %u\n", prefix, buffer, img.width); fprintf(headerFileP, "#define %s%sSZY %u\n", prefix, buffer, img.height); fprintf(headerFileP, "\n"); } }
static void gen_attr (rtx attr) { const char *p, *tag; int is_const = GET_CODE (XEXP (attr, 2)) == CONST; printf ("#define HAVE_ATTR_%s\n", XSTR (attr, 0)); /* If numeric attribute, don't need to write an enum. */ p = XSTR (attr, 1); if (*p == '\0') printf ("extern int get_attr_%s (%s);\n", XSTR (attr, 0), (is_const ? "void" : "rtx")); else { printf ("enum attr_%s {", XSTR (attr, 0)); while ((tag = scan_comma_elt (&p)) != 0) { write_upcase (XSTR (attr, 0)); putchar ('_'); while (tag != p) putchar (TOUPPER (*tag++)); if (*p == ',') fputs (", ", stdout); } fputs ("};\n", stdout); printf ("extern enum attr_%s get_attr_%s (%s);\n\n", XSTR (attr, 0), XSTR (attr, 0), (is_const ? "void" : "rtx")); } /* If `length' attribute, write additional function definitions and define variables used by `insn_current_length'. */ if (! strcmp (XSTR (attr, 0), "length")) { puts ("\ extern void shorten_branches (rtx);\n\ extern int insn_default_length (rtx);\n\ extern int insn_min_length (rtx);\n\ extern int insn_variable_length_p (rtx);\n\ extern int insn_current_length (rtx);\n\n\ #include \"insn-addr.h\"\n"); }
struct berval * ldap_pvt_str2upperbv( char *str, struct berval *bv ) { char *s = NULL; assert( bv != NULL ); /* to upper */ if ( str ) { for ( s = str; *s; s++ ) { *s = TOUPPER( (unsigned char) *s ); } } bv->bv_val = str; bv->bv_len = (ber_len_t)(s - str); return( bv ); }
boolean_t mu_interactive(caddr_t message) { boolean_t done = FALSE, mur_error_allowed; unsigned short len; int index; char res[8]; char *fgets_res; util_out_print(PROCEED_PROMPT, TRUE); while (FALSE == done) { fgets_res = util_input(res, SIZEOF(res), stdin, FALSE); if (NULL != fgets_res) { len = strlen(res); if (0 < len) { for (index = 0; index < len; index++) res[index] = TOUPPER(res[index]); if (0 == memcmp(res, YES_STRING, len)) { done = TRUE; mur_error_allowed = TRUE; break; } else if (0 == memcmp(res, NO_STRING, len)) { done = TRUE; mur_error_allowed = FALSE; break; } } util_out_print(CORRECT_PROMPT, TRUE); } else { mur_error_allowed = FALSE; break; } } if (FALSE == mur_error_allowed) util_out_print(message, TRUE); return (mur_error_allowed); }
NATIVE_CHAR * acpi_ut_strupr ( NATIVE_CHAR *src_string) { NATIVE_CHAR *string; FUNCTION_ENTRY (); /* Walk entire string, uppercasing the letters */ for (string = src_string; *string; ) { *string = (char) TOUPPER (*string); string++; } return (src_string); }
NATIVE_CHAR * AcpiUtStrupr ( NATIVE_CHAR *SrcString) { NATIVE_CHAR *String; FUNCTION_ENTRY (); /* Walk entire string, uppercasing the letters */ for (String = SrcString; *String; ) { *String = (char) TOUPPER (*String); String++; } return (SrcString); }
void _Py_bytes_upper(char *result, const char *cptr, Py_ssize_t len) { Py_ssize_t i; /* newobj = PyString_FromStringAndSize(NULL, len); if (!newobj) return NULL; s = PyString_AS_STRING(newobj); */ Py_MEMCPY(result, cptr, len); for (i = 0; i < len; i++) { int c = Py_CHARMASK(result[i]); if (ISLOWER(c)) result[i] = TOUPPER(c); } }
/* PUBLIC HTAAScheme_enum() ** TRANSLATE SCHEME NAME INTO ** A SCHEME ENUMERATION ** ** ON ENTRY: ** name is a string representing the scheme name. ** ** ON EXIT: ** returns the enumerated constant for that scheme. */ PUBLIC HTAAScheme HTAAScheme_enum ARGS1(CONST char*, name) { static char *upcased = NULL; char *cur; if (!name) return HTAA_UNKNOWN; StrAllocCopy(upcased, name); cur = upcased; while (*cur) { *cur = TOUPPER(*cur); cur++; } if (!strncmp(upcased, "NONE", 4)) return HTAA_NONE; else if (!strncmp(upcased, "BASIC", 5)) return HTAA_BASIC; else if (!strncmp(upcased, "PUBKEY", 6)) return HTAA_PUBKEY; else if (!strncmp(upcased, "KERBEROSV4", 10)) return HTAA_KERBEROS_V4; else if (!strncmp(upcased, "KERBEROSV5", 10)) return HTAA_KERBEROS_V5; else return HTAA_UNKNOWN; }
PUBLIC BOOL HTConfirm (HTRequest * request, HTAlertOpcode op, int msgnum, const char * dfault, void * input, HTAlertPar * reply) { char response[4]; /* One more for terminating NULL -- AL */ HTPrint("%s", HTDialogs[msgnum]); if (input) HTPrint(" (%s)", (char *) input); HTPrint(" (y/n) "); if (fgets(response, 4, stdin)) { /* get reply, max 3 chars */ char *ptr = response; while (*ptr) { if (*ptr == '\n') { *ptr = '\0'; break; } *ptr = TOUPPER(*ptr); ptr++; } return (!strcmp(response, "YES") || !strcmp(response, "Y")) ? YES : NO; } return NO; }
/* PUBLIC HTAAMethod_enum() ** TRANSLATE METHOD NAME INTO AN ENUMERATED VALUE ** ON ENTRY: ** name is the method name to translate. ** ** ON EXIT: ** returns HTAAMethod enumerated value corresponding ** to the given name. */ PUBLIC HTAAMethod HTAAMethod_enum ARGS1(CONST char *, name) { char tmp[MAX_METHODNAME_LEN+1]; CONST char *src = name; char *dest = tmp; if (!name) return METHOD_UNKNOWN; while (*src) { *dest = TOUPPER(*src); dest++; src++; } *dest = 0; if (0==strcmp(tmp, "GET")) return METHOD_GET; else if (0==strcmp(tmp, "PUT")) return METHOD_PUT; else return METHOD_UNKNOWN; }
/* * Emit the GNU standard type wrapped up in such a way that * this thing can be encountered countless times during a compile * and not cause even a warning. */ static const char* emit_gnu_type (const char* text, regmatch_t* rm ) { char z_TYPE[ 64 ]; char z_type[ 64 ]; fwrite (text, rm[0].rm_so, 1, stdout); { const char* ps = text + rm[1].rm_so; const char* pe = text + rm[1].rm_eo; char* pd = z_type; char* pD = z_TYPE; while (ps < pe) *(pD++) = TOUPPER( *(pd++) = *(ps++) ); *pD = *pd = NUL; } /* * Now print out the reformed typedef, * with a C++ guard for WCHAR */ { tSCC z_fmt[] = "\ #if !defined(_GCC_%s_T)%s\n\ #define _GCC_%s_T\n\ typedef __%s_TYPE__ %s_t;\n\ #endif\n"; const char *const pz_guard = (strcmp (z_type, "wchar") == 0) ? " && ! defined(__cplusplus)" : ""; printf (z_fmt, z_TYPE, pz_guard, z_TYPE, z_TYPE, z_type); } return text += rm[0].rm_eo; }
// ComResWords::isSqlReservedWord() ================================ // Determine if the given word is a reserved identifier. // ================================================================= // NABoolean ComResWords::isSqlReservedWord(const char *word,NABoolean mp_context, UInt32 ifSetFlags) { // no reserved words in mode_special_4 if ((ifSetFlags & MODE_SPECIAL_4_) != 0) return FALSE; char uword[MAX_RESWORD_LENGTH]; NABoolean lookup = TRUE; UInt32 i = 0; while (word[i]) { if(i >= (MAX_RESWORD_LENGTH - 1)) { lookup = FALSE; break; } // Upper case all words since all the words in the resword table // are also uppercase. // #pragma nowarn(1506) // warning elimination uword[i] = TOUPPER(word[i]); #pragma warn(1506) // warning elimination i++; } uword[i] = '\0'; if (lookup) { // search for uppercase word in the reserved word table // ComResWord resWord = { uword, 0 }; //resWord.setResWord(uword, 0); ComResWord *entry = searchResWordTbl(&resWord); return (entry && entry->isReserved(mp_context,ifSetFlags)); } else { return FALSE; } }
static void gen_attr (rtx attr) { const char *p, *tag; p = XSTR (attr, 1); if (*p != '\0') { printf ("enum attr_%s {", XSTR (attr, 0)); while ((tag = scan_comma_elt (&p)) != 0) { write_upcase (XSTR (attr, 0)); putchar ('_'); while (tag != p) putchar (TOUPPER (*tag++)); if (*p == ',') fputs (", ", stdout); } fputs ("};\n", stdout); } }
/* Print out a wrapper macro for a function which corrects the number of arguments it takes. Any missing arguments are assumed to be at the end. */ static void gen_macro (const char *name, int real, int expect) { int i; gcc_assert (real <= expect); gcc_assert (real); /* #define GEN_CALL(A, B, C, D) gen_call((A), (B)) */ fputs ("#define GEN_", stdout); for (i = 0; name[i]; i++) putchar (TOUPPER (name[i])); putchar('('); for (i = 0; i < expect - 1; i++) printf ("%c, ", i + 'A'); printf ("%c) gen_%s (", i + 'A', name); for (i = 0; i < real - 1; i++) printf ("(%c), ", i + 'A'); printf ("(%c))\n", i + 'A'); }
void bn_read_str(bn_t a, const char *str, int len, int radix) { int sign, i, j; char c; bn_zero(a); if (radix < 2 || radix > 64) { THROW(ERR_NO_VALID) } j = 0; if (str[0] == '-') { j++; sign = BN_NEG; } else { sign = BN_POS; } while (str[j] && j < len) { c = (char)((radix < 36) ? TOUPPER(str[j]) : str[j]); for (i = 0; i < 64; i++) { if (c == util_conv_char(i)) { break; } } if (i < radix) { bn_mul_dig(a, a, (dig_t)radix); bn_add_dig(a, a, (dig_t)i); } else { break; } j++; } a->sign = sign; }
/*ARGSUSED*/ upperregion(f, n) { register LINE *linep; register int loffs; register int c; register int s; REGION region; VOID lchange(); #ifdef READONLY /* 91.01.05 by S.Yoshida */ if (curbp->b_flag & BFRONLY) { /* If this buffer is read-only, */ warnreadonly(); /* do only displaying warning. */ return TRUE; } #endif /* READONLY */ if ((s=getregion(®ion)) != TRUE) return s; #ifdef UNDO undo_reset(curbp); /* this function cannot undo */ #endif lchange(WFHARD); linep = region.r_linep; loffs = region.r_offset; while (region.r_size--) { if (loffs == llength(linep)) { linep = lforw(linep); loffs = 0; } else { c = lgetc(linep, loffs); if (ISLOWER(c) != FALSE) lputc(linep, loffs, TOUPPER(c)); ++loffs; } } return TRUE; }
void _Py_bytes_swapcase(char *result, char *s, Py_ssize_t len) { Py_ssize_t i; /* newobj = PyString_FromStringAndSize(NULL, len); if (newobj == NULL) return NULL; s_new = PyString_AsString(newobj); */ for (i = 0; i < len; i++) { int c = Py_CHARMASK(*s++); if (ISLOWER(c)) { *result = TOUPPER(c); } else if (ISUPPER(c)) { *result = TOLOWER(c); } else *result = c; result++; } }
static int match_longchar(longchar * a, longchar * b, int ignore) { #ifdef USE_M17N if (a->type != b->type) return 0; if (a->type == RE_TYPE_WCHAR_T) { #ifdef USE_UNICODE if (ignore) { wc_uint32 ua = wc_any_to_ucs(a->wch), ub = wc_any_to_ucs(b->wch); return (ua == ub || ua == wc_ucs_tolower(ub) || ua == wc_ucs_toupper(ub) || ua == wc_ucs_totitle(ub)); } #endif return (a->wch.ccs == b->wch.ccs) && (a->wch.code == b->wch.code); } #endif if (ignore && IS_ALPHA(b->ch)) return (a->ch == TOLOWER(b->ch) || a->ch == TOUPPER(b->ch)); else return a->ch == b->ch; }
acpi_status acpi_ns_build_internal_name ( acpi_namestring_info *info) { u32 num_segments = info->num_segments; NATIVE_CHAR *internal_name = info->internal_name; NATIVE_CHAR *external_name = info->next_external_char; NATIVE_CHAR *result = NULL; u32 i; FUNCTION_TRACE ("Ns_build_internal_name"); /* Setup the correct prefixes, counts, and pointers */ if (info->fully_qualified) { internal_name[0] = '\\'; if (num_segments <= 1) { result = &internal_name[1]; } else if (num_segments == 2) { internal_name[1] = AML_DUAL_NAME_PREFIX; result = &internal_name[2]; } else { internal_name[1] = AML_MULTI_NAME_PREFIX_OP; internal_name[2] = (char) num_segments; result = &internal_name[3]; } } else { /* * Not fully qualified. * Handle Carats first, then append the name segments */ i = 0; if (info->num_carats) { for (i = 0; i < info->num_carats; i++) { internal_name[i] = '^'; } } if (num_segments == 1) { result = &internal_name[i]; } else if (num_segments == 2) { internal_name[i] = AML_DUAL_NAME_PREFIX; result = &internal_name[i+1]; } else { internal_name[i] = AML_MULTI_NAME_PREFIX_OP; internal_name[i+1] = (char) num_segments; result = &internal_name[i+2]; } } /* Build the name (minus path separators) */ for (; num_segments; num_segments--) { for (i = 0; i < ACPI_NAME_SIZE; i++) { if (acpi_ns_valid_path_separator (*external_name) || (*external_name == 0)) { /* Pad the segment with underscore(s) if segment is short */ result[i] = '_'; } else { /* Convert the character to uppercase and save it */ result[i] = (char) TOUPPER (*external_name); external_name++; } } /* Now we must have a path separator, or the pathname is bad */ if (!acpi_ns_valid_path_separator (*external_name) && (*external_name != 0)) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Move on the next segment */ external_name++; result += ACPI_NAME_SIZE; } /* Terminate the string */ *result = 0; if (info->fully_qualified) { ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "returning [%p] (abs) \"\\%s\"\n", internal_name, &internal_name[0])); } else { ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "returning [%p] (rel) \"%s\"\n", internal_name, &internal_name[2])); } return_ACPI_STATUS (AE_OK); }
int NAME(char *UPLO, blasint *N, FLOAT *a, blasint *ldA, blasint *Info){ blas_arg_t args; blasint uplo_arg = *UPLO; blasint uplo; blasint info; FLOAT *buffer; #ifdef PPC440 extern #endif FLOAT *sa, *sb; PRINT_DEBUG_NAME; args.n = *N; args.a = (void *)a; args.lda = *ldA; TOUPPER(uplo_arg); uplo = -1; if (uplo_arg == 'U') uplo = 0; if (uplo_arg == 'L') uplo = 1; info = 0; if (args.lda < MAX(1,args.n)) info = 4; if (args.n < 0) info = 2; if (uplo < 0) info = 1; if (info) { BLASFUNC(xerbla)(ERROR_NAME, &info, sizeof(ERROR_NAME)); *Info = - info; return 0; } *Info = 0; if (args.n == 0) return 0; IDEBUG_START; FUNCTION_PROFILE_START(); #ifndef PPC440 buffer = (FLOAT *)blas_memory_alloc(1); sa = (FLOAT *)((BLASLONG)buffer + GEMM_OFFSET_A); sb = (FLOAT *)(((BLASLONG)sa + ((GEMM_P * GEMM_Q * COMPSIZE * SIZE + GEMM_ALIGN) & ~GEMM_ALIGN)) + GEMM_OFFSET_B); #endif #ifdef SMP args.common = NULL; args.nthreads = num_cpu_avail(4); if (args.nthreads == 1) { #endif *Info = (lauum_single[uplo])(&args, NULL, NULL, sa, sb, 0); #ifdef SMP } else { *Info = (lauum_parallel[uplo])(&args, NULL, NULL, sa, sb, 0); } #endif #ifndef PPC440 blas_memory_free(buffer); #endif FUNCTION_PROFILE_END(1, .5 * args.n * args.n, 2. * args.n * (1./3. + args.n * ( 1./2. + args.n * 1./6.)) + args.n * (args.n * args.n - 1)); IDEBUG_END; return 0; }
char * xstormy16_cgen_build_insn_regex (CGEN_INSN *insn) { CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn); const char *mnem = CGEN_INSN_MNEMONIC (insn); char rxbuf[CGEN_MAX_RX_ELEMENTS]; char *rx = rxbuf; const CGEN_SYNTAX_CHAR_TYPE *syn; int reg_err; syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc)); /* Mnemonics come first in the syntax string. */ if (! CGEN_SYNTAX_MNEMONIC_P (* syn)) return _("missing mnemonic in syntax string"); ++syn; /* Generate a case sensitive regular expression that emulates case insensitive matching in the "C" locale. We cannot generate a case insensitive regular expression because in Turkish locales, 'i' and 'I' are not equal modulo case conversion. */ /* Copy the literal mnemonic out of the insn. */ for (; *mnem; mnem++) { char c = *mnem; if (ISALPHA (c)) { *rx++ = '['; *rx++ = TOLOWER (c); *rx++ = TOUPPER (c); *rx++ = ']'; } else *rx++ = c; } /* Copy any remaining literals from the syntax string into the rx. */ for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn) { if (CGEN_SYNTAX_CHAR_P (* syn)) { char c = CGEN_SYNTAX_CHAR (* syn); switch (c) { /* Escape any regex metacharacters in the syntax. */ case '.': case '[': case '\\': case '*': case '^': case '$': #ifdef CGEN_ESCAPE_EXTENDED_REGEX case '?': case '{': case '}': case '(': case ')': case '*': case '|': case '+': case ']': #endif *rx++ = '\\'; *rx++ = c; break; default: if (ISALPHA (c)) { *rx++ = '['; *rx++ = TOLOWER (c); *rx++ = TOUPPER (c); *rx++ = ']'; } else *rx++ = c; break; } } else { /* Replace non-syntax fields with globs. */ *rx++ = '.'; *rx++ = '*'; } } /* Trailing whitespace ok. */ * rx++ = '['; * rx++ = ' '; * rx++ = '\t'; * rx++ = ']'; * rx++ = '*'; /* But anchor it after that. */ * rx++ = '$'; * rx = '\0'; CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t)); reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB); if (reg_err == 0) return NULL; else { static char msg[80]; regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80); regfree ((regex_t *) CGEN_INSN_RX (insn)); free (CGEN_INSN_RX (insn)); (CGEN_INSN_RX (insn)) = NULL; return msg; } }