/* C language support routines for GDB, the GNU debugger.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2002, 2003,
- 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
+ 2004, 2005, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
This file is part of GDB.
#include "cp-support.h"
#include "gdb_obstack.h"
#include <ctype.h>
+#include "exceptions.h"
extern void _initialize_c_language (void);
character set name. */
static const char *
-charset_for_string_type (enum c_string_type str_type)
+charset_for_string_type (enum c_string_type str_type,
+ struct gdbarch *gdbarch)
{
switch (str_type & ~C_CHAR)
{
case C_STRING:
- return target_charset ();
+ return target_charset (gdbarch);
case C_WIDE_STRING:
- return target_wide_charset ();
+ return target_wide_charset (gdbarch);
case C_STRING_16:
- /* FIXME: UCS-2 is not always correct. */
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
- return "UCS-2BE";
+ /* FIXME: UTF-16 is not always correct. */
+ if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
+ return "UTF-16BE";
else
- return "UCS-2LE";
+ return "UTF-16LE";
case C_STRING_32:
- /* FIXME: UCS-4 is not always correct. */
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
- return "UCS-4BE";
+ /* FIXME: UTF-32 is not always correct. */
+ if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
+ return "UTF-32BE";
else
- return "UCS-4LE";
+ return "UTF-32LE";
}
- internal_error (__FILE__, __LINE__, "unhandled c_string_type");
+ internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
}
/* Classify ELTTYPE according to what kind of character it is. Return
the enum constant representing the character type. Also set
*ENCODING to the name of the character set to use when converting
- characters of this type to the host character set. */
+ characters of this type in target BYTE_ORDER to the host character
+ set. */
static enum c_string_type
-classify_type (struct type *elttype, const char **encoding)
+classify_type (struct type *elttype, struct gdbarch *gdbarch,
+ const char **encoding)
{
- struct type *saved_type;
enum c_string_type result;
- /* We do one or two passes -- one on ELTTYPE, and then maybe a
- second one on a typedef target. */
- do
+ /* We loop because ELTTYPE may be a typedef, and we want to
+ successively peel each typedef until we reach a type we
+ understand. We don't use CHECK_TYPEDEF because that will strip
+ all typedefs at once -- but in C, wchar_t is itself a typedef, so
+ that would do the wrong thing. */
+ while (elttype)
{
char *name = TYPE_NAME (elttype);
goto done;
}
- saved_type = elttype;
- CHECK_TYPEDEF (elttype);
+ if (TYPE_CODE (elttype) != TYPE_CODE_TYPEDEF)
+ break;
+
+ /* Call for side effects. */
+ check_typedef (elttype);
+
+ if (TYPE_TARGET_TYPE (elttype))
+ elttype = TYPE_TARGET_TYPE (elttype);
+ else
+ {
+ /* Perhaps check_typedef did not update the target type. In
+ this case, force the lookup again and hope it works out.
+ It never will for C, but it might for C++. */
+ CHECK_TYPEDEF (elttype);
+ }
}
- while (elttype != saved_type);
/* Punt. */
result = C_CHAR;
done:
- *encoding = charset_for_string_type (result);
+ if (encoding)
+ *encoding = charset_for_string_type (result, gdbarch);
+
return result;
}
characters and then appends them to OUTPUT. */
static void
-append_string_as_wide (const char *string, struct obstack *output)
+append_string_as_wide (const char *string,
+ struct obstack *output)
{
for (; *string; ++string)
{
escapes across calls. */
static void
-print_wchar (gdb_wint_t w, const gdb_byte *orig, int orig_len,
- int width, struct obstack *output, int quoter,
- int *need_escapep)
+print_wchar (gdb_wint_t w, const gdb_byte *orig,
+ int orig_len, int width,
+ enum bfd_endian byte_order,
+ struct obstack *output,
+ int quoter, int *need_escapep)
{
int need_escape = *need_escapep;
+
*need_escapep = 0;
if (gdb_iswprint (w) && (!need_escape || (!gdb_iswdigit (w)
&& w != LCST ('8')
&& w != LCST ('9'))))
{
+ gdb_wchar_t wchar = w;
+
if (w == gdb_btowc (quoter) || w == LCST ('\\'))
obstack_grow_wstr (output, LCST ("\\"));
- obstack_grow (output, &w, sizeof (gdb_wchar_t));
+ obstack_grow (output, &wchar, sizeof (gdb_wchar_t));
}
else
{
for (i = 0; i + width <= orig_len; i += width)
{
char octal[30];
- ULONGEST value = extract_unsigned_integer (&orig[i], width);
- sprintf (octal, "\\%lo", (long) value);
+ ULONGEST value;
+
+ value = extract_unsigned_integer (&orig[i], width,
+ byte_order);
+ /* If the value fits in 3 octal digits, print it that
+ way. Otherwise, print it as a hex escape. */
+ if (value <= 0777)
+ sprintf (octal, "\\%.3o", (int) (value & 0777));
+ else
+ sprintf (octal, "\\x%lx", (long) value);
append_string_as_wide (octal, output);
}
/* If we somehow have extra bytes, print them now. */
while (i < orig_len)
{
char octal[5];
+
sprintf (octal, "\\%.3o", orig[i] & 0xff);
append_string_as_wide (octal, output);
++i;
}
}
-/* Print the character C on STREAM as part of the contents of a literal
- string whose delimiter is QUOTER. Note that that format for printing
- characters and strings is language specific. */
+/* Print the character C on STREAM as part of the contents of a
+ literal string whose delimiter is QUOTER. Note that that format
+ for printing characters and strings is language specific. */
-static void
-c_emit_char (int c, struct type *type, struct ui_file *stream, int quoter)
+void
+c_emit_char (int c, struct type *type,
+ struct ui_file *stream, int quoter)
{
+ enum bfd_endian byte_order
+ = gdbarch_byte_order (get_type_arch (type));
struct obstack wchar_buf, output;
struct cleanup *cleanups;
const char *encoding;
struct wchar_iterator *iter;
int need_escape = 0;
- classify_type (type, &encoding);
+ classify_type (type, get_type_arch (type), &encoding);
buf = alloca (TYPE_LENGTH (type));
pack_long (buf, type, c);
- iter = make_wchar_iterator (buf, TYPE_LENGTH (type), encoding,
- TYPE_LENGTH (type));
+ iter = make_wchar_iterator (buf, TYPE_LENGTH (type),
+ encoding, TYPE_LENGTH (type));
cleanups = make_cleanup_wchar_iterator (iter);
/* This holds the printable form of the wchar_t data. */
if (!print_escape)
{
for (i = 0; i < num_chars; ++i)
- print_wchar (chars[i], buf, buflen, TYPE_LENGTH (type),
+ print_wchar (chars[i], buf, buflen,
+ TYPE_LENGTH (type), byte_order,
&wchar_buf, quoter, &need_escape);
}
}
/* This handles the NUM_CHARS == 0 case as well. */
if (print_escape)
- print_wchar (gdb_WEOF, buf, buflen, TYPE_LENGTH (type), &wchar_buf,
- quoter, &need_escape);
+ print_wchar (gdb_WEOF, buf, buflen, TYPE_LENGTH (type),
+ byte_order, &wchar_buf, quoter, &need_escape);
}
/* The output in the host encoding. */
c_printchar (int c, struct type *type, struct ui_file *stream)
{
enum c_string_type str_type;
- const char *encoding;
- str_type = classify_type (type, &encoding);
+ str_type = classify_type (type, get_type_arch (type), NULL);
switch (str_type)
{
case C_CHAR:
fputc_filtered ('\'', stream);
}
-/* Print the character string STRING, printing at most LENGTH characters.
- LENGTH is -1 if the string is nul terminated. Each character is WIDTH bytes
- long. Printing stops early if the number hits print_max; repeat counts are
- printed as appropriate. Print ellipses at the end if we had to stop before
- printing LENGTH characters, or if FORCE_ELLIPSES. */
+/* Print the character string STRING, printing at most LENGTH
+ characters. LENGTH is -1 if the string is nul terminated. Each
+ character is WIDTH bytes long. Printing stops early if the number
+ hits print_max; repeat counts are printed as appropriate. Print
+ ellipses at the end if we had to stop before printing LENGTH
+ characters, or if FORCE_ELLIPSES. */
void
-c_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string,
- unsigned int length, int force_ellipses,
+c_printstr (struct ui_file *stream, struct type *type,
+ const gdb_byte *string, unsigned int length,
+ const char *user_encoding, int force_ellipses,
const struct value_print_options *options)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
unsigned int i;
unsigned int things_printed = 0;
int in_quotes = 0;
struct obstack wchar_buf, output;
struct cleanup *cleanup;
enum c_string_type str_type;
+ const char *type_encoding;
const char *encoding;
struct wchar_iterator *iter;
int finished = 0;
int need_escape = 0;
+ if (length == -1)
+ {
+ unsigned long current_char = 1;
+
+ for (i = 0; current_char; ++i)
+ {
+ QUIT;
+ current_char = extract_unsigned_integer (string + i * width,
+ width, byte_order);
+ }
+ length = i;
+ }
+
/* If the string was not truncated due to `set print elements', and
- the last byte of it is a null, we don't print that, in traditional C
- style. */
+ the last byte of it is a null, we don't print that, in
+ traditional C style. */
if (!force_ellipses
&& length > 0
- && (extract_unsigned_integer (string + (length - 1) * width, width) == 0))
+ && (extract_unsigned_integer (string + (length - 1) * width,
+ width, byte_order) == 0))
length--;
- str_type = classify_type (type, &encoding) & ~C_CHAR;
+ str_type = (classify_type (type, get_type_arch (type), &type_encoding)
+ & ~C_CHAR);
switch (str_type)
{
case C_STRING:
break;
}
+ encoding = (user_encoding && *user_encoding)
+ ? user_encoding : type_encoding;
+
if (length == 0)
{
fputs_filtered ("\"\"", stream);
return;
}
- if (length == -1)
- {
- unsigned long current_char = 1;
- for (i = 0; current_char; ++i)
- {
- QUIT;
- current_char = extract_unsigned_integer (string + i * width, width);
- }
- length = i;
- }
-
/* Arrange to iterate over the characters, in wchar_t form. */
iter = make_wchar_iterator (string, length * width, encoding, width);
cleanup = make_cleanup_wchar_iterator (iter);
single character in isolation. This makes the code simpler
and probably does the sensible thing in the majority of
cases. */
- while (num_chars == 1)
+ while (num_chars == 1 && things_printed < options->print_max)
{
/* Count the number of repetitions. */
unsigned int reps = 0;
while (num_chars == 1 && current_char == chars[0])
{
- num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
+ num_chars = wchar_iterate (iter, &result, &chars,
+ &buf, &buflen);
++reps;
}
obstack_grow_wstr (&wchar_buf, LCST ("'"));
need_escape = 0;
print_wchar (current_char, orig_buf, orig_len, width,
- &wchar_buf, '\'', &need_escape);
+ byte_order, &wchar_buf, '\'', &need_escape);
obstack_grow_wstr (&wchar_buf, LCST ("'"));
{
/* Painful gyrations. */
int j;
char *s = xstrprintf (_(" <repeats %u times>"), reps);
+
for (j = 0; s[j]; ++j)
{
gdb_wchar_t w = gdb_btowc (s[j]);
while (reps-- > 0)
{
- print_wchar (current_char, orig_buf, orig_len, width,
- &wchar_buf, '"', &need_escape);
+ print_wchar (current_char, orig_buf,
+ orig_len, width,
+ byte_order, &wchar_buf,
+ '"', &need_escape);
++things_printed;
}
}
in_quotes = 1;
}
need_escape = 0;
- print_wchar (gdb_WEOF, buf, buflen, width, &wchar_buf,
- '"', &need_escape);
+ print_wchar (gdb_WEOF, buf, buflen, width, byte_order,
+ &wchar_buf, '"', &need_escape);
break;
case wchar_iterate_incomplete:
obstack_grow_wstr (&wchar_buf, LCST ("\","));
in_quotes = 0;
}
- obstack_grow_wstr (&wchar_buf, LCST (" <incomplete sequence "));
- print_wchar (gdb_WEOF, buf, buflen, width, &wchar_buf,
+ obstack_grow_wstr (&wchar_buf,
+ LCST (" <incomplete sequence "));
+ print_wchar (gdb_WEOF, buf, buflen, width,
+ byte_order, &wchar_buf,
0, &need_escape);
obstack_grow_wstr (&wchar_buf, LCST (">"));
finished = 1;
}
/* Obtain a C string from the inferior storing it in a newly allocated
- buffer in BUFFER, which should be freed by the caller. The string is
- read until a null character is found. If VALUE is an array with known
- length, the function will not read past the end of the array. LENGTH
- will contain the size of the string in bytes (not counting the null
- character).
-
- Assumes strings are terminated by a null character. The size of a character
- is determined by the length of the target type of the pointer or array.
- This means that a null byte present in a multi-byte character will not
- terminate the string unless the whole character is null.
-
- CHARSET is always set to the target charset. */
+ buffer in BUFFER, which should be freed by the caller. If the in-
+ and out-parameter *LENGTH is specified at -1, the string is read
+ until a null character of the appropriate width is found, otherwise
+ the string is read to the length of characters specified. The size
+ of a character is determined by the length of the target type of
+ the pointer or array. If VALUE is an array with a known length,
+ the function will not read past the end of the array. On
+ completion, *LENGTH will be set to the size of the string read in
+ characters. (If a length of -1 is specified, the length returned
+ will not include the null character). CHARSET is always set to the
+ target charset. */
void
-c_get_string (struct value *value, gdb_byte **buffer, int *length,
+c_get_string (struct value *value, gdb_byte **buffer,
+ int *length, struct type **char_type,
const char **charset)
{
int err, width;
unsigned int fetchlimit;
struct type *type = check_typedef (value_type (value));
struct type *element_type = TYPE_TARGET_TYPE (type);
+ int req_length = *length;
+ enum bfd_endian byte_order
+ = gdbarch_byte_order (get_type_arch (type));
+ enum c_string_type kind;
if (element_type == NULL)
goto error;
if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
{
- /* If we know the size of the array, we can use it as a limit on the
- number of characters to be fetched. */
+ /* If we know the size of the array, we can use it as a limit on
+ the number of characters to be fetched. */
if (TYPE_NFIELDS (type) == 1
&& TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
{
/* We work only with arrays and pointers. */
goto error;
- element_type = check_typedef (element_type);
- if (TYPE_CODE (element_type) != TYPE_CODE_INT
- && TYPE_CODE (element_type) != TYPE_CODE_CHAR)
- /* If the elements are not integers or characters, we don't consider it
- a string. */
+ if (! c_textual_element_type (element_type, 0))
goto error;
-
+ kind = classify_type (element_type,
+ get_type_arch (element_type),
+ charset);
width = TYPE_LENGTH (element_type);
- /* If the string lives in GDB's memory intead of the inferior's, then we
- just need to copy it to BUFFER. Also, since such strings are arrays
- with known size, FETCHLIMIT will hold the size of the array. */
+ /* If the string lives in GDB's memory instead of the inferior's,
+ then we just need to copy it to BUFFER. Also, since such strings
+ are arrays with known size, FETCHLIMIT will hold the size of the
+ array. */
if ((VALUE_LVAL (value) == not_lval
|| VALUE_LVAL (value) == lval_internalvar)
&& fetchlimit != UINT_MAX)
int i;
const gdb_byte *contents = value_contents (value);
- /* Look for a null character. */
- for (i = 0; i < fetchlimit; i++)
- if (extract_unsigned_integer (contents + i * width, width) == 0)
- break;
-
- /* I is now either the number of non-null characters, or FETCHLIMIT. */
+ /* If a length is specified, use that. */
+ if (*length >= 0)
+ i = *length;
+ else
+ /* Otherwise, look for a null character. */
+ for (i = 0; i < fetchlimit; i++)
+ if (extract_unsigned_integer (contents + i * width,
+ width, byte_order) == 0)
+ break;
+
+ /* I is now either a user-defined length, the number of non-null
+ characters, or FETCHLIMIT. */
*length = i * width;
*buffer = xmalloc (*length);
memcpy (*buffer, contents, *length);
}
else
{
- err = read_string (value_as_address (value), -1, width, fetchlimit,
- buffer, length);
+ CORE_ADDR addr = value_as_address (value);
+
+ err = read_string (addr, *length, width, fetchlimit,
+ byte_order, buffer, length);
if (err)
{
xfree (*buffer);
- error (_("Error reading string from inferior: %s"),
- safe_strerror (err));
+ if (err == EIO)
+ throw_error (MEMORY_ERROR, "Address %s out of bounds",
+ paddress (get_type_arch (type), addr));
+ else
+ error (_("Error reading string from inferior: %s"),
+ safe_strerror (err));
}
}
- /* If the last character is null, subtract it from LENGTH. */
- if (*length > 0
- && extract_unsigned_integer (*buffer + *length - width, width) == 0)
- *length -= width;
-
- *charset = target_charset ();
+ /* If the LENGTH is specified at -1, we want to return the string
+ length up to the terminating null character. If an actual length
+ was specified, we want to return the length of exactly what was
+ read. */
+ if (req_length == -1)
+ /* If the last character is null, subtract it from LENGTH. */
+ if (*length > 0
+ && extract_unsigned_integer (*buffer + *length - width,
+ width, byte_order) == 0)
+ *length -= width;
+
+ /* The read_string function will return the number of bytes read.
+ If length returned from read_string was > 0, return the number of
+ characters read by dividing the number of bytes by width. */
+ if (*length != 0)
+ *length = *length / width;
+
+ *char_type = element_type;
return;
result >>= 8;
}
- convert_between_encodings ("UCS-4BE", dest_charset, data, 4, 4, output,
- translit_none);
+ convert_between_encodings ("UTF-32BE", dest_charset, data,
+ 4, 4, output, translit_none);
return p;
}
pointer to just after the final digit of the escape sequence. */
static char *
-convert_octal (struct type *type, char *p, char *limit, struct obstack *output)
+convert_octal (struct type *type, char *p,
+ char *limit, struct obstack *output)
{
+ int i;
unsigned long value = 0;
- while (p < limit && isdigit (*p) && *p != '8' && *p != '9')
+ for (i = 0;
+ i < 3 && p < limit && isdigit (*p) && *p != '8' && *p != '9';
+ ++i)
{
value = 8 * value + host_hex_value (*p);
++p;
just after the final digit of the escape sequence. */
static char *
-convert_hex (struct type *type, char *p, char *limit, struct obstack *output)
+convert_hex (struct type *type, char *p,
+ char *limit, struct obstack *output)
{
unsigned long value = 0;
case 'U':
{
int length = *p == 'u' ? 4 : 8;
+
ADVANCE;
if (!isxdigit (*p))
error (_("\\u used with no following hex digits"));
while (data < limit)
{
char *p = data;
+
/* Look for next escape, or the end of the input. */
while (p < limit && *p != '\\')
++p;
/* If we saw a run of characters, convert them all. */
if (p > data)
convert_between_encodings (host_charset (), dest_charset,
- data, p - data, 1, output, translit_none);
+ data, p - data, 1,
+ output, translit_none);
/* If we saw an escape, convert it. */
if (p < limit)
p = convert_escape (type, dest_charset, p, limit, output);
are delegated to evaluate_subexp_standard; see that function for a
description of the arguments. */
-static struct value *
+struct value *
evaluate_subexp_c (struct type *expect_type, struct expression *exp,
int *pos, enum noside noside)
{
switch (dest_type & ~C_CHAR)
{
case C_STRING:
- type = language_string_char_type (current_language,
- current_gdbarch);
+ type = language_string_char_type (exp->language_defn,
+ exp->gdbarch);
break;
case C_WIDE_STRING:
- type = lookup_typename ("wchar_t", NULL, 0);
+ type = lookup_typename (exp->language_defn, exp->gdbarch,
+ "wchar_t", NULL, 0);
break;
case C_STRING_16:
- type = lookup_typename ("char16_t", NULL, 0);
+ type = lookup_typename (exp->language_defn, exp->gdbarch,
+ "char16_t", NULL, 0);
break;
case C_STRING_32:
- type = lookup_typename ("char32_t", NULL, 0);
+ type = lookup_typename (exp->language_defn, exp->gdbarch,
+ "char32_t", NULL, 0);
break;
default:
- internal_error (__FILE__, __LINE__, "unhandled c_string_type");
+ internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
}
/* Ensure TYPE_LENGTH is valid for TYPE. */
check_typedef (type);
- dest_charset = charset_for_string_type (dest_type);
+ dest_charset = charset_for_string_type (dest_type, exp->gdbarch);
++*pos;
while (*pos < limit)
if ((dest_type & C_CHAR) != 0)
result = allocate_value (type);
else
- result = value_typed_string ("", 0, type);
+ result = value_cstring ("", 0, type);
do_cleanups (cleanup);
return result;
}
LONGEST value;
if (obstack_object_size (&output) != TYPE_LENGTH (type))
- error (_("Could not convert character constant to target character set"));
+ error (_("Could not convert character "
+ "constant to target character set"));
value = unpack_long (type, obstack_base (&output));
result = value_from_longest (type, value);
}
else
{
int i;
+
/* Write the terminating character. */
for (i = 0; i < TYPE_LENGTH (type); ++i)
obstack_1grow (&output, 0);
- result = value_typed_string (obstack_base (&output),
- obstack_object_size (&output),
- type);
+ result = value_cstring (obstack_base (&output),
+ obstack_object_size (&output),
+ type);
}
do_cleanups (cleanup);
return result;
struct language_arch_info *lai)
{
const struct builtin_type *builtin = builtin_type (gdbarch);
+
lai->string_char_type = builtin->builtin_char;
lai->primitive_type_vector
= GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
lai->bool_type_default = builtin->builtin_int;
}
-static const struct exp_descriptor exp_descriptor_c =
+const struct exp_descriptor exp_descriptor_c =
{
print_subexp_standard,
operator_length_standard,
+ operator_check_standard,
op_name_standard,
dump_subexp_body_standard,
evaluate_subexp_c
basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
basic_lookup_transparent_type,/* lookup_transparent_type */
NULL, /* Language specific symbol demangler */
- NULL, /* Language specific class_name_from_physname */
+ NULL, /* Language specific
+ class_name_from_physname */
c_op_print_tab, /* expression operators for printing */
1, /* c-style arrays */
0, /* String lower bound */
struct language_arch_info *lai)
{
const struct builtin_type *builtin = builtin_type (gdbarch);
+
lai->string_char_type = builtin->builtin_char;
lai->primitive_type_vector
= GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
cp_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
cp_lookup_transparent_type, /* lookup_transparent_type */
cplus_demangle, /* Language specific symbol demangler */
- cp_class_name_from_physname, /* Language specific class_name_from_physname */
+ cp_class_name_from_physname, /* Language specific
+ class_name_from_physname */
c_op_print_tab, /* expression operators for printing */
1, /* c-style arrays */
0, /* String lower bound */
basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
basic_lookup_transparent_type,/* lookup_transparent_type */
NULL, /* Language specific symbol demangler */
- NULL, /* Language specific class_name_from_physname */
+ NULL, /* Language specific
+ class_name_from_physname */
c_op_print_tab, /* expression operators for printing */
1, /* c-style arrays */
0, /* String lower bound */
default_word_break_characters,
default_make_symbol_completion_list,
- c_language_arch_info, /* FIXME: la_language_arch_info. */
+ c_language_arch_info, /* FIXME: la_language_arch_info. */
default_print_array_index,
default_pass_by_reference,
c_get_string,
basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
basic_lookup_transparent_type,/* lookup_transparent_type */
NULL, /* Language specific symbol demangler */
- NULL, /* Language specific class_name_from_physname */
+ NULL, /* Language specific
+ class_name_from_physname */
c_op_print_tab, /* expression operators for printing */
1, /* c-style arrays */
0, /* String lower bound */