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