JSONObject::JSONObject(char* _buffer) : JSONBase(_buffer) { if ( !buffer ) return; try { SKIP_WHITESPACE(); ERROR_IF_NOT('{'); buffer++; while ( readValue() ) {} SKIP_WHITESPACE(); ERROR_IF_NOT('}'); *buffer++ = 0; } catch(...) { for ( auto &m : values ) { if ( m.second ) { delete m.second; m.second = 0; } } values.clear(); if ( dynamic_cast<JSONDocument*>(this) ) { buffer.free(); } throw; } }
bool JSONArray::readValue() { // Read string chunk terminated by ending quote. SKIP_WHITESPACE(); if ( *buffer == ']' ) return false; JSONBase *value = nullptr; SKIP_WHITESPACE(); if ( *buffer == '"' ) { value = new JSONString(readQuotedValue()); } else if ( *buffer == '[' ) { value = new JSONArray(buffer); buffer = value->buffer; } else if ( *buffer == '{' ) { value = new JSONObject(buffer); buffer = value->buffer; } else if ( *buffer != ',' ) { value = new JSONString(readUnquotedValue()); } else { throw sfx::bad_json(); } values.push_back(value); SKIP_WHITESPACE(); if ( *buffer == ',' ) { *buffer++=0; return true; } return false; }
static void obj_mach_o_weak (int ignore ATTRIBUTE_UNUSED) { char *name; int c; symbolS *symbolP; do { /* Get symbol name. */ name = input_line_pointer; c = get_symbol_end (); symbolP = symbol_find_or_make (name); S_SET_WEAK (symbolP); *input_line_pointer = c; SKIP_WHITESPACE (); if (c != ',') break; input_line_pointer++; SKIP_WHITESPACE (); } while (*input_line_pointer != '\n'); demand_empty_rest_of_line (); }
/****************************************************************************** * * * Function: json_parse_array * * * * Purpose: Parses JSON array value * * * * Parameters: start - [IN] the JSON data without leading whitespace * * error - [OUT] the parsing error message (can be NULL) * * * * Return value: The number of characters parsed. On error 0 is returned and * * error parameter (if not NULL) contains allocated error * * message. * * * * Author: Andris Zeila * * * ******************************************************************************/ static int json_parse_array(const char *start, char **error) { const char *ptr = start; int len; ptr++; SKIP_WHITESPACE(ptr); if (']' != *ptr) { while (1) { /* json_parse_value strips leading whitespace, so we don't have to do it here */ if (0 == (len = json_parse_value(ptr, error))) return 0; ptr += len; SKIP_WHITESPACE(ptr); if (',' != *ptr) break; ptr++; } /* no closing ], failing */ if (']' != *ptr) return json_error("invalid array format, expected closing character ']'", ptr, error); } return ptr - start + 1; }
/****************************************************************************** * * * Function: json_parse_object * * * * Purpose: Parses JSON object * * * * Parameters: start - [IN] the JSON data * * error - [OUT] the parsing error message (can be NULL) * * * * Return value: The number of characters parsed. On error 0 is returned and * * error parameter (if not NULL) contains allocated error * * message. * * * * Author: Andris Zeila * * * ******************************************************************************/ static int json_parse_object(const char *start, char **error) { const char *ptr = start; int len; /* parse object name */ SKIP_WHITESPACE(ptr); /* not an object, failing */ if ('{' != *ptr) return json_error("invalid object format, expected opening character '{'", ptr, error); ptr++; SKIP_WHITESPACE(ptr); if ('}' != *ptr) { while (1) { if ('"' != *ptr) return json_error("invalid object name", ptr, error); /* cannot parse object name, failing */ if (0 == (len = json_parse_string(ptr, error))) return 0; ptr += len; /* parse name:value separator */ SKIP_WHITESPACE(ptr); if (':' != *ptr) return json_error("invalid object name/value separator", ptr, error); ptr++; if (0 == (len = json_parse_value(ptr, error))) return 0; ptr += len; SKIP_WHITESPACE(ptr); if (',' != *ptr) break; ptr++; SKIP_WHITESPACE(ptr); } /* object is not properly closed, failing */ if ('}' != *ptr) return json_error("invalid object format, expected closing character '}'", ptr, error); } return ptr - start + 1; }
void dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) { offsetT filenum, line, column; filenum = get_absolute_expression (); SKIP_WHITESPACE (); line = get_absolute_expression (); SKIP_WHITESPACE (); column = get_absolute_expression (); demand_empty_rest_of_line (); if (filenum < 1) { as_bad (_("file number less than one")); return; } if (filenum >= (int) files_in_use || files[filenum].filename == 0) { as_bad (_("unassigned file number %ld"), (long) filenum); return; } current.filenum = filenum; current.line = line; current.column = column; current.flags = DWARF2_FLAG_BEGIN_STMT; loc_directive_seen = TRUE; #ifndef NO_LISTING if (listing) { if (files[filenum].dir) { size_t dir_len = strlen (dirs[files[filenum].dir]); size_t file_len = strlen (files[filenum].filename); char *cp = (char *) alloca (dir_len + 1 + file_len + 1); memcpy (cp, dirs[files[filenum].dir], dir_len); cp[dir_len] = '/'; memcpy (cp + dir_len + 1, files[filenum].filename, file_len); cp[dir_len + file_len + 1] = '\0'; listing_source_file (cp); } else listing_source_file (files[filenum].filename); listing_source_line (line); } #endif }
str_list_t DLLCALL getNameServerList(void) { #ifdef __unix__ /* Look up DNS server address */ FILE* fp; char* p; char str[128]; str_list_t list; if((list=strListInit())==NULL) return(NULL); if((fp=fopen("/etc/resolv.conf","r"))!=NULL) { while(!feof(fp)) { if(fgets(str,sizeof(str),fp)==NULL) break; truncsp(str); p=str; SKIP_WHITESPACE(p); if(strnicmp(p,"nameserver",10)!=0) /* no match */ continue; FIND_WHITESPACE(p); /* skip "nameserver" */ SKIP_WHITESPACE(p); /* skip more white-space */ strListPush(&list,p); } fclose(fp); } return(list); #elif defined(_WIN32) FIXED_INFO* FixedInfo=NULL; ULONG FixedInfoLen=0; IP_ADDR_STRING* ip; str_list_t list; if((list=strListInit())==NULL) return(NULL); if(GetNetworkParams(FixedInfo,&FixedInfoLen) == ERROR_BUFFER_OVERFLOW) { FixedInfo=(FIXED_INFO*)malloc(FixedInfoLen); if(GetNetworkParams(FixedInfo,&FixedInfoLen) == ERROR_SUCCESS) { ip=&FixedInfo->DnsServerList; for(; ip!=NULL; ip=ip->Next) strListPush(&list,ip->IpAddress.String); } if(FixedInfo!=NULL) free(FixedInfo); } return(list); #else #error "Need a get_nameserver() implementation for this platform" #endif }
static void dot_cfi_sections (int ignored ATTRIBUTE_UNUSED) { int sections = 0; SKIP_WHITESPACE (); if (is_name_beginner (*input_line_pointer)) while (1) { char *name, c; name = input_line_pointer; c = get_symbol_end (); if (strncmp (name, ".eh_frame", sizeof ".eh_frame") == 0 && name[9] != '_') sections |= CFI_EMIT_eh_frame; else if (strncmp (name, ".debug_frame", sizeof ".debug_frame") == 0) sections |= CFI_EMIT_debug_frame; #ifdef tc_cfi_section_name else if (strcmp (name, tc_cfi_section_name) == 0) sections |= CFI_EMIT_target; #endif else { *input_line_pointer = c; input_line_pointer = name; break; } *input_line_pointer = c; SKIP_WHITESPACE (); if (*input_line_pointer == ',') { name = input_line_pointer++; SKIP_WHITESPACE (); if (!is_name_beginner (*input_line_pointer)) { input_line_pointer = name; break; } } else if (is_name_beginner (*input_line_pointer)) break; } demand_empty_rest_of_line (); cfi_sections = sections; }
char * dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED) { offsetT num; char *filename; int filename_len; /* Continue to accept a bare string and pass it off. */ SKIP_WHITESPACE (); if (*input_line_pointer == '"') { s_app_file (0); return NULL; } num = get_absolute_expression (); filename = demand_copy_C_string (&filename_len); demand_empty_rest_of_line (); if (num < 1) { as_bad (_("file number less than one")); return NULL; } if (num < (int) files_in_use && files[num].filename != 0) { as_bad (_("file number %ld already allocated"), (long) num); return NULL; } get_filenum (filename, num); return filename; }
static void s_common() { register char *name; register char c; register char *p; register int temp; register symbolS * symbolP; name = input_line_pointer; c = get_symbol_end(); /* just after name is now '\0' */ p = input_line_pointer; *p = c; SKIP_WHITESPACE(); if ( * input_line_pointer != ',' ) { as_warn("Expected comma after symbol-name"); ignore_rest_of_line(); return; } input_line_pointer ++; /* skip ',' */ if ( (temp = get_absolute_expression ()) < 0 ) { as_warn(".COMMon length (%d.) <0! Ignored.", temp); ignore_rest_of_line(); return; } *p = 0; symbolP = symbol_find_or_make (name); *p = c; if ( (symbolP->sy_type & N_TYPE) != N_UNDF || symbolP->sy_other != 0 || symbolP->sy_desc != 0) { as_warn( "Ignoring attempt to re-define symbol"); ignore_rest_of_line(); return; } if (symbolP->sy_value) { if (symbolP->sy_value != temp) { as_warn( "Length of .comm \"%s\" is already %d. Not changed to %d.", symbolP->sy_name, symbolP->sy_value, temp); } } else { symbolP->sy_value = temp; symbolP->sy_type |= N_EXT; } know(symbolP->sy_frag == &zero_address_frag); if (strncmp(input_line_pointer, ",\"bss\"", 6) != 0) { p=input_line_pointer; while(*p && *p!='\n') p++; c= *p; *p='\0'; as_warn("bad .common segment: `%s'", input_line_pointer); *p=c; return; } input_line_pointer += 6; demand_empty_rest_of_line(); return; }
void s_if (int arg) { expressionS operand; struct conditional_frame cframe; int t; char *stop = NULL; char stopc; if (flag_mri) stop = mri_comment_field (&stopc); /* Leading whitespace is part of operand. */ SKIP_WHITESPACE (); if (current_cframe != NULL && current_cframe->ignoring) { operand.X_add_number = 0; while (! is_end_of_line[(unsigned char) *input_line_pointer]) ++input_line_pointer; } else { expression (&operand); if (operand.X_op != O_constant) as_bad (_("non-constant expression in \".if\" statement")); } switch ((operatorT) arg) { case O_eq: t = operand.X_add_number == 0; break; case O_ne: t = operand.X_add_number != 0; break; case O_lt: t = operand.X_add_number < 0; break; case O_le: t = operand.X_add_number <= 0; break; case O_ge: t = operand.X_add_number >= 0; break; case O_gt: t = operand.X_add_number > 0; break; default: abort (); return; } /* If the above error is signaled, this will dispatch using an undefined result. No big deal. */ initialize_cframe (&cframe); cframe.ignoring = cframe.dead_tree || ! t; current_cframe = ((struct conditional_frame *) obstack_copy (&cond_obstack, &cframe, sizeof (cframe))); if (LISTING_SKIP_COND () && cframe.ignoring && (cframe.previous_cframe == NULL || ! cframe.previous_cframe->ignoring)) listing_list (2); if (flag_mri) mri_comment_end (stop, stopc); demand_empty_rest_of_line (); }
BOOL DLLCALL findstr_in_string(const char* insearchof, char* string) { char* p; char str[256]; char search[81]; int c; int i; BOOL found=FALSE; if(string==NULL || insearchof==NULL) return(FALSE); SAFECOPY(search,insearchof); strupr(search); SAFECOPY(str,string); p=str; SKIP_WHITESPACE(p); if(*p==';') /* comment */ return(FALSE); if(*p=='!') { /* !match */ found=TRUE; p++; } truncsp(p); c=strlen(p); if(c) { c--; strupr(p); if(p[c]=='~') { p[c]=0; if(strstr(search,p)) found=!found; } else if(p[c]=='^' || p[c]=='*') { p[c]=0; if(!strncmp(p,search,c)) found=!found; } else if(p[0]=='*') { i=strlen(search); if(i<c) return(found); if(!strncmp(p+1,search+(i-c),c)) found=!found; } else if(!strcmp(p,search)) found=!found; } return(found); }
char *JSONBase::readUnquotedValue() { char *result = buffer; while ( *buffer && !isspace(*buffer) && *buffer != ':' && *buffer != ',' ) buffer++; if ( isspace(*buffer) ) *buffer++ = 0; SKIP_WHITESPACE(); return result; }
void s_ifdef (int test_defined) { /* Points to name of symbol. */ char *name; /* Points to symbol. */ symbolS *symbolP; struct conditional_frame cframe; char c; /* Leading whitespace is part of operand. */ SKIP_WHITESPACE (); name = input_line_pointer; if (!is_name_beginner (*name)) { as_bad (_("invalid identifier for \".ifdef\"")); obstack_1grow (&cond_obstack, 0); ignore_rest_of_line (); return; } c = get_symbol_end (); symbolP = symbol_find (name); *input_line_pointer = c; initialize_cframe (&cframe); if (cframe.dead_tree) cframe.ignoring = 1; else { int is_defined; /* Use the same definition of 'defined' as .equiv so that a symbol which has been referenced but not yet given a value/address is considered to be undefined. */ is_defined = symbolP != NULL && S_IS_DEFINED (symbolP) && S_GET_SEGMENT (symbolP) != reg_section; cframe.ignoring = ! (test_defined ^ is_defined); } current_cframe = ((struct conditional_frame *) obstack_copy (&cond_obstack, &cframe, sizeof (cframe))); if (LISTING_SKIP_COND () && cframe.ignoring && (cframe.previous_cframe == NULL || ! cframe.previous_cframe->ignoring)) listing_list (2); demand_empty_rest_of_line (); }
static void cfi_parse_separator (void) { SKIP_WHITESPACE (); if (*input_line_pointer == ',') input_line_pointer++; else as_bad (_("missing separator")); }
static void obj_coff_loc (int ignore ATTRIBUTE_UNUSED) { int lineno; /* FIXME: Why do we need this check? We need it for ECOFF, but why do we need it for COFF? */ if (now_seg != text_section) { as_warn (_(".loc outside of .text")); demand_empty_rest_of_line (); return; } if (def_symbol_in_progress != NULL) { as_warn (_(".loc pseudo-op inside .def/.endef: ignored.")); demand_empty_rest_of_line (); return; } /* Skip the file number. */ SKIP_WHITESPACE (); get_absolute_expression (); SKIP_WHITESPACE (); lineno = get_absolute_expression (); #ifndef NO_LISTING { extern int listing; if (listing) { lineno += coff_line_base - 1; listing_source_line (lineno); } } #endif demand_empty_rest_of_line (); add_lineno (frag_now, frag_now_fix (), lineno); }
/****************************************************************************** * * * Function: json_parse_value * * * * Purpose: Parses JSON object value * * * * Parameters: start - [IN] the JSON data * * error - [OUT] the parsing error message (can be NULL) * * * * Return value: The number of characters parsed. On error 0 is returned and * * error parameter (if not NULL) contains allocated error * * message. * * * * Author: Andris Zeila * * * ******************************************************************************/ int json_parse_value(const char *start, char **error) { const char *ptr = start; int len; SKIP_WHITESPACE(ptr); switch (*ptr) { case '\0': return json_error("unexpected end of object value", NULL, error); case '"': if (0 == (len = json_parse_string(ptr, error))) return 0; break; case '{': if (0 == (len = json_parse_object(ptr, error))) return 0; break; case '[': if (0 == (len = json_parse_array(ptr, error))) return 0; break; case 't': if (0 == (len = json_parse_literal(ptr, "true", error))) return 0; break; case 'f': if (0 == (len = json_parse_literal(ptr, "false", error))) return 0; break; case 'n': if (0 == (len = json_parse_literal(ptr, "null", error))) return 0; break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '-': if (0 == (len = json_parse_number(ptr, error))) return 0; break; default: return json_error("invalid JSON object value starting character", ptr, error); } return ptr - start + len; }
bool JSONObject::readValue() { // Read string chunk terminated by ending quote. SKIP_WHITESPACE(); if ( *buffer == '}' ) return false; char *key = nullptr; JSONBase *value = nullptr; if ( *buffer == '"' || *buffer == '\'' ) { if ( !(key = readQuotedValue()) ) throw sfx::bad_json(); } else if ( *buffer != ',' && *buffer != ':' ) { if ( !(key = readUnquotedValue()) ) throw sfx::bad_json(); } else { throw sfx::bad_json(); } SKIP_WHITESPACE(); ERROR_IF_NOT(':'); *buffer++ = 0; SKIP_WHITESPACE(); if ( *buffer == '"' ) { value = new JSONString(readQuotedValue()); } else if ( *buffer == '[' ) { value = new JSONArray(buffer); buffer = value->buffer; } else if ( *buffer == '{' ) { value = new JSONObject(buffer); buffer = value->buffer; } else if ( *buffer != ',' ) { value = new JSONString(readUnquotedValue()); } else { throw sfx::bad_json(); } values[key]=value; SKIP_WHITESPACE(); if ( *buffer == ',' ) { *buffer++=0; return true; } return false; }
JSONArray::JSONArray(char* _buffer): JSONBase(_buffer) { if ( !buffer ) return; try { SKIP_WHITESPACE(); ERROR_IF_NOT('['); buffer++; while ( readValue() ) {} SKIP_WHITESPACE(); ERROR_IF_NOT(']'); *buffer++ = 0; } catch(...) { for ( auto &m : values ) { if ( m ) { delete m; } } values.clear(); throw; } }
char *JSONBase::readQuotedValue() { char endChar = *buffer++; char *result = buffer; while ( *buffer && *buffer != endChar ) { if ( *buffer == '\\' && *(++buffer) == 0) break; buffer++; } if ( *buffer ) *buffer++ = 0; SKIP_WHITESPACE(); return result; }
/* * sdp_debug_msg_filter * * DESCRIPTION * Check the passed message buffer for sensitive data that should * not be output (such as SRTP Master Key/Salt). Sensitive data * will be replaced with the '*' character(s). * * PARAMETERS * buffer: pointer to the message buffer to filter. * * length_bytes: size of message buffer in bytes. * * RETURN VALUE * The buffer modified. */ char * sdp_debug_msg_filter (char *buffer, ulong length_bytes) { char *current; char *last = buffer + length_bytes; int result; SDP_PRINT("\n%s:%d: Eliding sensitive data from debug output", __FILE__, __LINE__); /* * For SRTP Master Key/Salt has the form: * X-crypto:<crypto_suite_name> inline:<master_key_salt>|| * Where <master_key_salt> is the data to elide (filter). */ for (current=buffer; current<=last-MIN_CRYPTO_STRING_SIZE_BYTES; current++) { if ((*current == 'x') || (*current == 'X')) { result = cpr_strncasecmp(current, crypto_string, crypto_strlen); if (!result) { current += crypto_strlen; if (current > last) break; /* Skip over crypto suite name */ FIND_WHITESPACE(current, last); /* Skip over whitespace */ SKIP_WHITESPACE(current, last); /* identify inline keyword */ result = cpr_strncasecmp(current, inline_string, inline_strlen); if (!result) { current += inline_strlen; if (current > last) break; /* Hide sensitive key/salt data */ while (current<=last) { if (*current == '|' || *current == '\n') { /* Done */ break; } else { *current = '*'; current++; } } } } } } return buffer; }
/* * sort of like s_lcomm * */ static void s_reserve() { char *name; char c; char *p; int temp; symbolS *symbolP; name = input_line_pointer; c = get_symbol_end(); p = input_line_pointer; *p = c; SKIP_WHITESPACE(); if ( * input_line_pointer != ',' ) { as_warn("Expected comma after name"); ignore_rest_of_line(); return; } input_line_pointer ++; if ((temp = get_absolute_expression()) < 0) { as_warn("BSS length (%d.) <0! Ignored.", temp); ignore_rest_of_line(); return; } *p = 0; symbolP = symbol_find_or_make(name); *p = c; if (strncmp(input_line_pointer, ",\"bss\"", 6) != 0) { as_warn("bad .reserve segment: `%s'", input_line_pointer); return; } input_line_pointer += 6; if (symbolP->sy_other == 0 && symbolP->sy_desc == 0 && ((symbolP->sy_type == N_BSS && symbolP->sy_value == local_bss_counter) || ((symbolP->sy_type & N_TYPE) == N_UNDF && symbolP->sy_value == 0))) { symbolP->sy_value = local_bss_counter; symbolP->sy_type = N_BSS; symbolP->sy_frag = & bss_address_frag; local_bss_counter += temp; } else { as_warn( "Ignoring attempt to re-define symbol from %d. to %d.", symbolP->sy_value, local_bss_counter ); } demand_empty_rest_of_line(); return; }
static char * get_mri_string (int terminator, int *len) { char *ret; char *s; SKIP_WHITESPACE (); s = ret = input_line_pointer; if (*input_line_pointer == '\'') { ++s; ++input_line_pointer; while (! is_end_of_line[(unsigned char) *input_line_pointer]) { *s++ = *input_line_pointer++; if (s[-1] == '\'') { if (*input_line_pointer != '\'') break; ++input_line_pointer; } } SKIP_WHITESPACE (); } else { while (*input_line_pointer != terminator && ! is_end_of_line[(unsigned char) *input_line_pointer]) ++input_line_pointer; s = input_line_pointer; while (s > ret && (s[-1] == ' ' || s[-1] == '\t')) --s; } *len = s - ret; return ret; }
/****************************************************************************** * * * Function: zbx_json_validate * * * * Purpose: Validates JSON object * * * * Parameters: start - [IN] the string to validate * * error - [OUT] the parse error message. If the error value is * * set it must be freed by caller after it has * * been used (can be NULL). * * * * Return value: The number of characters parsed. On error 0 is returned and * * error parameter (if not NULL) contains allocated error * * message. * * * * Author: Andris Zeila * * * ******************************************************************************/ int zbx_json_validate(const char *start, char **error) { int len; if (0 == (len = json_parse_object(start, error))) return 0; start += len; SKIP_WHITESPACE(start); if ('\0' != *start) return json_error("invalid character following JSON object", start, error); return len; }
static void obj_coff_weak (int ignore ATTRIBUTE_UNUSED) { char *name; int c; symbolS *symbolP; do { name = input_line_pointer; c = get_symbol_end (); if (*name == 0) { as_warn (_("badly formed .weak directive ignored")); ignore_rest_of_line (); return; } c = 0; symbolP = symbol_find_or_make (name); *input_line_pointer = c; SKIP_WHITESPACE (); S_SET_WEAK (symbolP); if (c == ',') { input_line_pointer++; SKIP_WHITESPACE (); if (*input_line_pointer == '\n') c = '\n'; } } while (c == ','); demand_empty_rest_of_line (); }
BOOL DLLCALL findstr_in_list(const char* insearchof, str_list_t list) { size_t index; BOOL found=FALSE; char* p; if(list==NULL || insearchof==NULL) return(FALSE); for(index=0; list[index]!=NULL; index++) { p=list[index]; SKIP_WHITESPACE(p); found=findstr_in_string(insearchof,p); if(found!=(*p=='!')) break; } return(found); }
static unsigned cfi_parse_reg (void) { int regno; expressionS exp; #ifdef tc_regname_to_dw2regnum SKIP_WHITESPACE (); if (is_name_beginner (*input_line_pointer) || (*input_line_pointer == '%' && is_name_beginner (*++input_line_pointer))) { char *name, c; name = input_line_pointer; c = get_symbol_end (); if ((regno = tc_regname_to_dw2regnum (name)) < 0) { as_bad (_("bad register expression")); regno = 0; } *input_line_pointer = c; return regno; } #endif expression_and_evaluate (&exp); switch (exp.X_op) { case O_register: case O_constant: regno = exp.X_add_number; break; default: as_bad (_("bad register expression")); regno = 0; break; } return regno; }
/* Returns NULL on failure */ hash_t** SMBCALL smb_msghashes(smbmsg_t* msg, const uchar* body, long source_mask) { size_t h=0; uchar flags=SMB_HASH_CRC16|SMB_HASH_CRC32|SMB_HASH_MD5; hash_t** hashes; /* This is a NULL-terminated list of hashes */ hash_t* hash; time_t t=time(NULL); if((hashes=(hash_t**)malloc(sizeof(hash_t*)*(SMB_HASH_SOURCE_TYPES+1)))==NULL) return(NULL); memset(hashes, 0, sizeof(hash_t*)*(SMB_HASH_SOURCE_TYPES+1)); if(msg->id!=NULL && (source_mask&(1<<SMB_HASH_SOURCE_MSG_ID)) && (hash=smb_hashstr(msg->hdr.number, (uint32_t)t, SMB_HASH_SOURCE_MSG_ID, flags, msg->id))!=NULL) hashes[h++]=hash; if(msg->ftn_msgid!=NULL && (source_mask&(1<<SMB_HASH_SOURCE_FTN_ID)) && (hash=smb_hashstr(msg->hdr.number, (uint32_t)t, SMB_HASH_SOURCE_FTN_ID, flags, msg->ftn_msgid))!=NULL) hashes[h++]=hash; if(body!=NULL && (source_mask&(1<<SMB_HASH_SOURCE_BODY)) && (hash=smb_hashstr(msg->hdr.number, (uint32_t)t, SMB_HASH_SOURCE_BODY, flags|SMB_HASH_STRIP_WSP|SMB_HASH_STRIP_CTRL_A, (const char *)body))!=NULL) hashes[h++]=hash; if(msg->subj!=NULL && (source_mask&(1<<SMB_HASH_SOURCE_SUBJECT))) { char* p=msg->subj; while(*p) { char* tp=strchr(p,':'); char* sp=strchr(p,' '); if(tp!=NULL && (sp==NULL || tp<sp)) { p=tp+1; SKIP_WHITESPACE(p); continue; } break; } if((hash=smb_hashstr(msg->hdr.number, (uint32_t)t, SMB_HASH_SOURCE_SUBJECT, flags, p))!=NULL) hashes[h++]=hash; } return(hashes); }
char * dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED) { offsetT num; char *filename; int filename_len; /* Continue to accept a bare string and pass it off. */ SKIP_WHITESPACE (); if (*input_line_pointer == '"') { s_app_file (0); return NULL; } num = get_absolute_expression (); filename = demand_copy_C_string (&filename_len); if (filename == NULL) return NULL; demand_empty_rest_of_line (); if (num < 1) { as_bad (_("file number less than one")); return NULL; } /* A .file directive implies compiler generated debug information is being supplied. Turn off gas generated debug info. */ debug_type = DEBUG_NONE; if (num < (int) files_in_use && files[num].filename != 0) { as_bad (_("file number %ld already allocated"), (long) num); return NULL; } get_filenum (filename, num); return filename; }
static void dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED) { int simple = 0; if (frchain_now->frch_cfi_data != NULL) { as_bad (_("previous CFI entry not closed (missing .cfi_endproc)")); ignore_rest_of_line (); return; } cfi_new_fde (symbol_temp_new_now ()); SKIP_WHITESPACE (); if (is_name_beginner (*input_line_pointer)) { char *name, c; name = input_line_pointer; c = get_symbol_end (); if (strcmp (name, "simple") == 0) { simple = 1; *input_line_pointer = c; } else input_line_pointer = name; } demand_empty_rest_of_line (); frchain_now->frch_cfi_data->cur_cfa_offset = 0; if (!simple) tc_cfi_frame_initial_instructions (); if ((cfi_sections & CFI_EMIT_target) != 0) tc_cfi_startproc (); }