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;
}
}
