/* Check that the context c is a valid copy of the reference context r. */
static void
check_context(krb5_context c, krb5_context r)
{
int i;
/* Check fields which should have been propagated from r. */
compare_etypes(c->in_tkt_etypes, r->in_tkt_etypes);
compare_etypes(c->tgs_etypes, r->tgs_etypes);
check(c->os_context.time_offset == r->os_context.time_offset);
check(c->os_context.usec_offset == r->os_context.usec_offset);
check(c->os_context.os_flags == r->os_context.os_flags);
compare_string(c->os_context.default_ccname, r->os_context.default_ccname);
check(c->clockskew == r->clockskew);
check(c->kdc_req_sumtype == r->kdc_req_sumtype);
check(c->default_ap_req_sumtype == r->default_ap_req_sumtype);
check(c->default_safe_sumtype == r->default_safe_sumtype);
check(c->kdc_default_options == r->kdc_default_options);
check(c->library_options == r->library_options);
check(c->profile_secure == r->profile_secure);
check(c->fcc_default_format == r->fcc_default_format);
check(c->udp_pref_limit == r->udp_pref_limit);
check(c->use_conf_ktypes == r->use_conf_ktypes);
check(c->allow_weak_crypto == r->allow_weak_crypto);
check(c->ignore_acceptor_hostname == r->ignore_acceptor_hostname);
check(c->dns_canonicalize_hostname == r->dns_canonicalize_hostname);
compare_string(c->plugin_base_dir, r->plugin_base_dir);
/* Check fields which don't propagate. */
check(c->dal_handle == NULL);
check(c->ser_ctx_count == 0);
check(c->ser_ctx == NULL);
check(c->prompt_types == NULL);
check(c->libkrb5_plugins.files == NULL);
check(c->preauth_context == NULL);
check(c->ccselect_handles == NULL);
check(c->localauth_handles == NULL);
check(c->hostrealm_handles == NULL);
check(c->err.code == 0);
check(c->err.msg == NULL);
check(c->kdblog_context == NULL);
check(c->trace_callback == NULL);
check(c->trace_callback_data == NULL);
for (i = 0; i < PLUGIN_NUM_INTERFACES; i++) {
check(c->plugins[i].modules == NULL);
check(!c->plugins[i].configured);
}
}
static int compare_property(OBJECT *obj, char *propname, FINDOP op, void *value)
{
/** @todo comparisons should type based and not using string representation (ticket #20) */
char buffer[1024];
char *propval = object_property_to_string(obj,propname, buffer, 1023);
if (propval==NULL) return 0;
return compare_string(propval,op,(char*)value);
}
const entry& entry::operator[](char const* key) const
{
dictionary_type::const_iterator i = std::find_if(
dict().begin()
, dict().end()
, compare_string(key));
if (i == dict().end()) throw type_error("key not found");
return i->second;
}
static char* base64_encode_block_encodes_3_bytes()
{
char output[5] = { 0 };
hdr_base64_encode_block((uint8_t*)"Man", output);
mu_assert("Encoding", compare_string("TWFu", output, 4));
return 0;
}
static char* base64_decode_block_decodes_4_chars()
{
uint8_t output[4] = { 0 };
hdr_base64_decode_block("TWFu", output);
mu_assert("Decoding", compare_string("Man", (char*) output, 3));
return 0;
}
int player_name_available(char *name) {
int i;
for (i = 0; i < NUM_PLAYERS; i++) {
if (players[i].active && compare_string(name, GET_NAME(i)))
return 0;
}
return 1;
}
entry const* entry::find_key(char const* key) const
{
dictionary_type::const_iterator i = std::find_if(
dict().begin()
, dict().end()
, compare_string(key));
if (i == dict().end()) return 0;
return &i->second;
}
device *get_device_by_name(char *name){
device *d;
for(d=list_head(device_table);
d!=NULL;
d=list_item_next(d)){
if(compare_string(d->deviceName, name)){
return d;
}
}
return NULL;
}
static bool assert_base64_decode(const char* base64_encoded, const char* expected)
{
size_t encoded_len = strlen(base64_encoded);
size_t output_len = (encoded_len / 4) * 3;
uint8_t* output = calloc(sizeof(uint8_t), output_len);
int result = hdr_base64_decode(base64_encoded, encoded_len, output, output_len);
return result == 0 && compare_string(expected, (char*)output, output_len);
}
void delete_device_by_name(char *name){
device *d;
for(d=list_head(device_table);
d!=NULL;
d=list_item_next(d)){
if(compare_string(d->deviceName, name)){
list_remove(device_table, d);
memb_free(&device_mem, d);
break;
}
}
}
void* get_global(char *n){
globe *c;
int i=0;
c = (globe*)get_data(&GLOBAL_VARIABLE_LIST, i);
while (!compare_string(c->name, n)){
i++;
c = (globe*)get_data(&GLOBAL_VARIABLE_LIST, i);
if (i == GLOBAL_VARIABLE_LIST.size) return 0;
}
c->access_time = CURRENT_TICK;
return c->data;
}
/** Compares the first string to the leading part of the second string
*
*/
static int compare_string_leading(
size_t len1,
const char *str1,
size_t len2,
const char *str2)
{
size_t len = min(len1, len2);
int result = compare_string(len, str1, len, str2);
if (result == 0)
return (int)len1 - (int)len;
return result;
}
entry& entry::operator[](char const* key)
{
dictionary_type::iterator i = std::find_if(
dict().begin()
, dict().end()
, compare_string(key));
if (i != dict().end()) return i->second;
dictionary_type::iterator ret = dict().insert(
dict().end()
, std::make_pair(std::string(key), entry()));
return ret->second;
}
void
string_minmax (GFC_INTEGER_4 *rlen, void **dest, int op, int nargs, ...)
{
va_list ap;
int i;
char * next, * res;
GFC_INTEGER_4 nextlen, reslen;
va_start (ap, nargs);
reslen = va_arg (ap, GFC_INTEGER_4);
res = va_arg (ap, char *);
*rlen = reslen;
if (res == NULL)
runtime_error ("First argument of '%s' intrinsic should be present",
op > 0 ? "MAX" : "MIN");
for (i = 1; i < nargs; i++)
{
nextlen = va_arg (ap, GFC_INTEGER_4);
next = va_arg (ap, char *);
if (next == NULL)
{
if (i == 1)
runtime_error ("Second argument of '%s' intrinsic should be "
"present", op > 0 ? "MAX" : "MIN");
else
continue;
}
if (nextlen > *rlen)
*rlen = nextlen;
if (op * compare_string (reslen, res, nextlen, next) < 0)
{
reslen = nextlen;
res = next;
}
}
va_end (ap);
if (*rlen == 0)
*dest = &zero_length_string;
else
{
char * tmp = internal_malloc_size (*rlen);
memcpy (tmp, res, reslen);
memset (&tmp[reslen], ' ', *rlen - reslen);
*dest = tmp;
}
}
void
string_minmax (gfc_charlen_type *rlen, CHARTYPE **dest, int op, int nargs, ...)
{
va_list ap;
int i;
CHARTYPE *next, *res;
gfc_charlen_type nextlen, reslen;
va_start (ap, nargs);
reslen = va_arg (ap, gfc_charlen_type);
res = va_arg (ap, CHARTYPE *);
*rlen = reslen;
if (res == NULL)
runtime_error ("First argument of '%s' intrinsic should be present",
op > 0 ? "MAX" : "MIN");
for (i = 1; i < nargs; i++)
{
nextlen = va_arg (ap, gfc_charlen_type);
next = va_arg (ap, CHARTYPE *);
if (next == NULL)
{
if (i == 1)
runtime_error ("Second argument of '%s' intrinsic should be "
"present", op > 0 ? "MAX" : "MIN");
else
continue;
}
if (nextlen > *rlen)
*rlen = nextlen;
if (op * compare_string (reslen, res, nextlen, next) < 0)
{
reslen = nextlen;
res = next;
}
}
va_end (ap);
if (*rlen == 0)
*dest = &zero_length_string;
else
{
CHARTYPE *tmp = xmalloc (*rlen * sizeof (CHARTYPE));
memcpy (tmp, res, reslen * sizeof (CHARTYPE));
MEMSET (&tmp[reslen], ' ', *rlen - reslen);
*dest = tmp;
}
}
static int
compare_one(const char *x, const char *y)
{
int m;
int n;
if ((x[0] == NUL) && (y[0] == NUL))
return (0);
if (x[0] == NUL)
return (-1);
if (y[0] == NUL)
return (1);
m = group_type(x);
n = group_type(y);
/* both pure digits */
if ((m >= 0) && (n >= 0))
return (m - n);
/* x digit, y non-digit */
if (m >= 0) {
if (german_sort)
return (1);
else
return ((n == -1) ? 1 : -1);
}
/* x non-digit, y digit */
if (n >= 0) {
if (german_sort)
return (-1);
else
return ((m == -1) ? -1 : 1);
}
/* strings started with a symbol (including digit) */
if ((m == SYMBOL) && (n == SYMBOL))
return (check_mixsym(x, y));
/* x symbol, y non-symbol */
if (m == SYMBOL)
return (-1);
/* x non-symbol, y symbol */
if (n == SYMBOL)
return (1);
/* strings with a leading letter, the ALPHA type */
return (compare_string((const unsigned char*)x, (const unsigned char*)y));
}
// returns NULL
String_ * search(Env * xs, String_ * s)
{
if (xs -> Nil) {
free_string(s);
return NULL;
} else {
if (compare_string(xs -> key, s)) { // found
free_string(s);
return copy_string(xs -> val);
} else {
return search(xs -> Cons, s);
}
}
}
static bool assert_base64_encode(const char* input, const char* expected)
{
size_t input_len = strlen(input);
int output_len = (int) (ceil(input_len / 3.0) * 4.0);
char* output = calloc(sizeof(char), output_len);
int r = hdr_base64_encode((uint8_t*)input, input_len, output, output_len);
bool result = r == 0 && compare_string(expected, output, output_len);
free(output);
return result;
}
void free_global(char *n){
unsigned short i = 0;
globe *c;
while (i < GLOBAL_VARIABLE_LIST.size){
i++;
c = (globe*)get_data(&GLOBAL_VARIABLE_LIST, i);
if (compare_string(n, c->name)){
free(c->name, size(c->name));
free(c->data, c->size);
return;
}
}
return;
}
/**
* Searches specified string in the array record field
* Reads strings from a current field of a current
* record and compares it with a passed value.
*
* @param key compare key
* @param cond internal ID of comparision mode
* @return 1 if strings are equal (for the given mode)
*/
static int compare_array(const pcsl_string* key, jsr211_boolean case_sensitive,
find_condition cond) {
int array_size, array_len, current_string;
storageRead(&io_error_message, table_file, (char *)&array_size, sizeof(int));
storageRead(&io_error_message, table_file, (char *)&array_len, sizeof(int));
for (current_string = 0; current_string < array_len; current_string++) {
if (compare_string(key, case_sensitive, cond)) {
return 1;
}
}
return 0;
}
Env * insert(Env * xs, String_ * k, String_ * v)
{
if (xs -> Nil) { // not found, insert
return cons_env(k, v, xs);
} else {
if (compare_string(xs -> key, k)) { // found, update
free_string(xs -> val); // release old value
free_string(k);
xs -> val = v;
return xs;
} else {
xs -> Cons = insert(xs -> Cons, k, v);
return xs;
}
}
}
//sap xep theo shellsort
void sort_by_shell(BAN ban[],int size)
{
int i,j,interrup;
BAN temp;
for(interrup=size/2;interrup>0;interrup=interrup/2){
for(i=0;i<size;i=i+interrup){
temp=ban[i];
//strcpy(temp.numberphone,ban[i].numberphone);
for(j=i;j>0 && compare_string(ban[j-interrup].numberphone,ban[j].numberphone)==1;j--){
//strcpy(ban[j].numberphone,ban[j-interrup].numberphone);
ban[j] = ban[j-interrup];
}
ban[j] = temp;
//strcpy(ban[j].numberphone,temp.numberphone);
}
}
PrintAll(ban,size);
}
/**
* Searches the next content handler in the file by specified conditions.
*
* @param caller_id caller ID
* @param number number of key field
* @param key search key
* @param case_sensitive case sensivity flag
* @param cond comparision mode
* @return offset of found record or -1
*/
static long find_next_by_field(const pcsl_string* caller_id,
jsr211_field number, const pcsl_string* key,
jsr211_boolean case_sensitive, find_condition cond) {
long current_position;
int current_size, access;
int found = 0;
int chr = CHR_INDEX((int)(number)); // Content Handler Record index
int isString;
switch (record_struct[chr]) {
case field_string:
isString = 1;
break;
case field_array:
isString = 0;
break;
default:
return -1;
}
current_position = storageRelativePosition(&io_error_message, table_file, 0);
for (;;) {
/* check access */
access = check_access(caller_id, current_position, ¤t_size);
if (access == -1) {
return -1;
}
else if (access) {
position_field(chr);
found = (isString?
compare_string(key, case_sensitive, cond):
compare_array(key, case_sensitive, cond));
}
storagePosition(&io_error_message, table_file, current_position);
if (found) {
break;
}
current_position += current_size;
goto_next_record();
}
return current_position;
}
int main()
{
char first[1000], second[1000], result;
printf("Input first string\n");
gets(first);
printf("Input second string\n");
gets(second);
result = compare_string(first, second);
if (result == 0)
printf("Both strings are same.\n");
else
printf("Entered strings are not equal.\n");
return 0;
}
Env * remove_env(Env * xs, String_ * s)
{
if (xs -> Nil) {
free_string(s);
return xs;
} else {
if (compare_string(xs -> key, s)) { // found
Env * rest = xs -> Cons;
free_string(xs -> key);
free_string(xs -> val);
free(xs);
free_string(s);
return rest;
} else {
xs -> Cons = remove_env(xs -> Cons, s);
return xs;
}
}
}
uint8_t drv_R8025T_check_read(uint8_t* buffer)
{
uint8_t drv_R8025T_read(uint8_t addr,uint8_t* data,uint8_t len);
extern INT16S compare_string(INT8U *str1,INT8U *str2,INT16U len);
extern bool is_valid_bcd(INT8U *bcd,INT8U bytes);
uint8_t data[32];
while(1)
{
drv_R8025T_read(0,data,32);
if(compare_string(data,data+16,16)!=0)//读到不同，需要重新读取
{
continue;
}
//检查数据是否合法，不合法，重新读取
if((is_valid_bcd(data,3)==false) || (is_valid_bcd(data+4,3)==false))
{
continue;
}
if(data[0]>=0x60) continue;
if(data[1]>=0x60) continue;
if(data[2]>=0x24) continue;
if(data[4]>=0x32) continue;
if(data[5]>=0x13) continue;
if(data[4]==0x00) continue;
if(data[5]==0x00) continue;
mem_cpy(buffer,data,16);
return 16;
}
return 0;
}
int
select_string (select_struct *table, int table_len, const CHARTYPE *selector,
gfc_charlen_type selector_len)
{
select_struct *t;
int i, low, high, mid;
int default_jump = -1;
if (table_len == 0)
return -1;
/* Record the default address if present */
if (table->low == NULL && table->high == NULL)
{
default_jump = table->address;
table++;
table_len--;
if (table_len == 0)
return default_jump;
}
/* Try the high and low bounds if present. */
if (table->low == NULL)
{
if (compare_string (table->high_len, table->high,
selector_len, selector) >= 0)
return table->address;
table++;
table_len--;
if (table_len == 0)
return default_jump;
}
t = table + table_len - 1;
if (t->high == NULL)
{
if (compare_string (t->low_len, t->low, selector_len, selector) <= 0)
return t->address;
table_len--;
if (table_len == 0)
return default_jump;
}
/* At this point, the only table entries are bounded entries. Find
the right entry with a binary chop. */
low = -1;
high = table_len;
while (low + 1 < high)
{
mid = (low + high) / 2;
t = table + mid;
i = compare_string (t->low_len, t->low, selector_len, selector);
if (i == 0)
return t->address;
if (i < 0)
low = mid;
else
high = mid;
}
/* The string now lies between the low indeces of the now-adjacent
high and low entries. Because it is less than the low entry of
'high', it can't be that one. If low is still -1, then no
entries match. Otherwise, we have to check the high entry of
'low'. */
if (low == -1)
return default_jump;
t = table + low;
if (compare_string (selector_len, selector, t->high_len, t->high) <= 0)
return t->address;
return default_jump;
}
static Boolean
replace_text_in_compound(F_compound *com, char *pattern, char *dst)
{
F_compound *c;
F_text *t;
PR_SIZE size;
Boolean replaced, processed;
int pat_len, i, j;
char str[300];
pat_len = strlen(pattern);
if (pat_len == 0)
return False;
processed = False;
for (c = com->compounds; c != NULL; c = c->next) {
if (replace_text_in_compound(c, pattern, dst))
processed = True;
}
for (t = com->texts; t != NULL; t = t->next) {
replaced = False;
if (pat_len <= strlen(t->cstring)) {
str[0] = '\0';
j = 0;
for (i = 0; i <= strlen(t->cstring) - pat_len; i++) {
if (compare_string(&t->cstring[i], pattern)) {
if (strlen(str) + strlen(dst) < sizeof(str)) {
strncat(str, &t->cstring[j], i - j);
strcat(str, dst);
i += pat_len - 1;
j = i + 1;
replaced = True;
} else { /* string becomes too long; don't replace it */
replaced = False;
}
}
}
if (replaced && j < strlen(t->cstring)) {
if (strlen(str) + strlen(&t->cstring[j]) < sizeof(str)) {
strcat(str, &t->cstring[j]);
} else {
replaced = False;
}
}
if (replaced) { /* replace the text object */
if (strlen(t->cstring) != strlen(str)) {
free(t->cstring);
t->cstring = new_string(strlen(str));
}
strcpy(t->cstring, str);
size = textsize(lookfont(x_fontnum(psfont_text(t), t->font),
t->size), strlen(t->cstring), t->cstring);
t->ascent = size.ascent;
t->descent = size.descent;
t->length = size.length;
processed = True;
}
}
}
if (processed)
compound_bound(com, &com->nwcorner.x, &com->nwcorner.y,
&com->secorner.x, &com->secorner.y);
return processed;
}
Local int
compare_page(FIELD_PTR *a, FIELD_PTR *b)
{
int m = 0;
short i = 0;
while((i < (*a)->count) && (i < (*b)->count) &&
((m = (*a)->npg[i] - (*b)->npg[i]) == 0))
{
i++;
}
if(m == 0)
{ /* common leading page numbers match */
if((i == (*a)->count) && (i == (*b)->count))
{ /* all page numbers match */
/***********************************************************
We have identical entries, except possibly in encap fields.
The ordering is tricky here. Consider the following input
sequence of index names, encaps, and page numbers:
foo|( 2
foo|) 6
foo|( 6
foo|) 10
This might legimately occur when a page range ends, and
subsequently, a new range starts, on the same page. If we
just order by range_open and range_close (here, parens),
then we will produce
foo|( 2
foo|( 6
foo|) 6
foo|) 10
This will later generate the index entry
foo, 2--6, \({6}, 10
which is not only wrong, but has also introduced an illegal
LaTeX macro, \({6}, because the merging step treated this
like a \see{6} entry.
The solution is to preserve the original input order, which
we can do by treating range_open and range_close as equal,
and then ordering by input line number. This will then
generate the correct index entry
foo, 2--10
Ordering inconsistencies from missing range open or close
entries, or mixing roman and arabic page numbers, will be
detected later.
***********************************************************/
#define isrange(c) ( ((c) == idx_ropen) || ((c) == idx_rclose) )
/* Order two range values by input line number */
if(isrange(*(*a)->encap) && isrange(*(*b)->encap))
m = (*a)->lc - (*b)->lc;
/* Handle identical encap fields; neither is a range delimiter */
else if(STREQ((*a)->encap, (*b)->encap))
{
/* If neither are yet marked duplicate, mark the second
of them to be ignored. */
if(((*a)->type != DUPLICATE) && ((*b)->type != DUPLICATE))
(*b)->type = DUPLICATE;
/* leave m == 0 to show equality */
}
/* Encap fields differ: only one may be a range delimiter, */
/* or else neither of them is. If either of them is a range */
/* delimiter, order by input line number; otherwise, order */
/* by name. */
else
{
if(isrange(*(*a)->encap) || isrange(*(*b)->encap))
m = (*a)->lc - (*b)->lc; /* order by input line number */
else /* order non-range items by */
/* their encap strings */
m = compare_string((unsigned char*)((*a)->encap),
(unsigned char*)((*b)->encap));
}
}
else if((i == (*a)->count) && (i < (*b)->count))
m = -1;
else if((i < (*a)->count) && (i == (*b)->count))
m = 1;
}
return(m);
}
/** Fetches the property requested and uses the appropriate op on the value.
@return boolean value
**/
static int compare_property_alt(OBJECT *obj, char *propname, FINDOP op, void *value){
complex *complex_target = NULL;
char *char_target = NULL;
int16 *int16_target = NULL;
int32 *int32_target = NULL;
int64 *int64_target = NULL;
PROPERTY *prop = object_get_property(obj, propname);
if(prop == NULL){
/* property not found in object ~ normal operation */
return 0;
}
switch(prop->ptype){
case PT_void:
return 0; /* no comparsion to be made */
case PT_double:
break;
case PT_complex:
complex_target = object_get_complex(obj, prop);
if(complex_target == NULL)
return 0; /* error value */
break;
case PT_enumeration:
case PT_set:
break; /* not 100% sure how to make these cooperate yet */
case PT_int16:
int16_target = (int16 *)object_get_int16(obj, prop);
if(int16_target == NULL)
return 0;
return compare_int16(*int16_target, op, *(int64 *)value);
case PT_int32:
int32_target = (int32 *)object_get_int32(obj, prop);
return compare_int32(*int32_target, op, *(int64 *)value);
break;
case PT_int64:
int64_target = (int64 *)object_get_int64(obj, prop);
return compare_int64(*int64_target, op, *(int64 *)value);
break;
case PT_char8:
case PT_char32:
case PT_char256:
case PT_char1024:
char_target = (char *)object_get_string(obj, prop);
if(char_target == NULL)
return 0;
return compare_string(char_target, op, value);
break;
case PT_object:
break;
case PT_bool:
break;
case PT_timestamp:
case PT_double_array:
case PT_complex_array:
break;
#ifdef USE_TRIPLETS
case PT_triple:
case PT_triplex:
break;
#endif
default:
output_error("comparison operators not supported for property type %s", class_get_property_typename(prop->ptype));
/* TROUBLESHOOT
This error is caused when an object find procedure uses a comparison operator
that isn't allowed on a that type of property. Make sure the property type
and the comparison operator are compatible and try again. If your GLM file
isn't the cause of the problem, try reducing the complexity of the GLM file
you are using to isolate which module is causing the error and file a report
with the GLM file attached.
*/
return 0;
}
}