OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [ch-lang.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Chill language support routines for GDB, the GNU debugger.
2
   Copyright 1992, 1995, 1996, 2000 Free Software Foundation, Inc.
3
 
4
   This file is part of GDB.
5
 
6
   This program is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 2 of the License, or
9
   (at your option) any later version.
10
 
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
 
16
   You should have received a copy of the GNU General Public License
17
   along with this program; if not, write to the Free Software
18
   Foundation, Inc., 59 Temple Place - Suite 330,
19
   Boston, MA 02111-1307, USA.  */
20
 
21
#include "defs.h"
22
#include "symtab.h"
23
#include "gdbtypes.h"
24
#include "value.h"
25
#include "expression.h"
26
#include "parser-defs.h"
27
#include "language.h"
28
#include "ch-lang.h"
29
#include "valprint.h"
30
 
31
extern void _initialize_chill_language PARAMS ((void));
32
 
33
static value_ptr
34
  evaluate_subexp_chill PARAMS ((struct type *, struct expression *, int *, enum noside));
35
 
36
static value_ptr
37
  value_chill_max_min PARAMS ((enum exp_opcode, value_ptr));
38
 
39
static value_ptr
40
  value_chill_card PARAMS ((value_ptr));
41
 
42
static value_ptr
43
  value_chill_length PARAMS ((value_ptr));
44
 
45
static struct type *
46
  chill_create_fundamental_type PARAMS ((struct objfile *, int));
47
 
48
static void chill_printstr (struct ui_file * stream, char *string,
49
                            unsigned int length, int width,
50
                            int force_ellipses);
51
 
52
static void chill_printchar (int, struct ui_file *);
53
 
54
/* For now, Chill uses a simple mangling algorithm whereby you simply
55
   discard everything after the occurance of two successive CPLUS_MARKER
56
   characters to derive the demangled form. */
57
 
58
char *
59
chill_demangle (mangled)
60
     const char *mangled;
61
{
62
  const char *joiner = NULL;
63
  char *demangled;
64
  const char *cp = mangled;
65
 
66
  while (*cp)
67
    {
68
      if (is_cplus_marker (*cp))
69
        {
70
          joiner = cp;
71
          break;
72
        }
73
      cp++;
74
    }
75
  if (joiner != NULL && *(joiner + 1) == *joiner)
76
    {
77
      demangled = savestring (mangled, joiner - mangled);
78
    }
79
  else
80
    {
81
      demangled = NULL;
82
    }
83
  return (demangled);
84
}
85
 
86
static void
87
chill_printchar (c, stream)
88
     register int c;
89
     struct ui_file *stream;
90
{
91
  c &= 0xFF;                    /* Avoid sign bit follies */
92
 
93
  if (PRINT_LITERAL_FORM (c))
94
    {
95
      if (c == '\'' || c == '^')
96
        fprintf_filtered (stream, "'%c%c'", c, c);
97
      else
98
        fprintf_filtered (stream, "'%c'", c);
99
    }
100
  else
101
    {
102
      fprintf_filtered (stream, "'^(%u)'", (unsigned int) c);
103
    }
104
}
105
 
106
/* Print the character string STRING, printing at most LENGTH characters.
107
   Printing stops early if the number hits print_max; repeat counts
108
   are printed as appropriate.  Print ellipses at the end if we
109
   had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
110
   Note that gdb maintains the length of strings without counting the
111
   terminating null byte, while chill strings are typically written with
112
   an explicit null byte.  So we always assume an implied null byte
113
   until gdb is able to maintain non-null terminated strings as well
114
   as null terminated strings (FIXME).
115
 */
116
 
117
static void
118
chill_printstr (stream, string, length, width, force_ellipses)
119
     struct ui_file *stream;
120
     char *string;
121
     unsigned int length;
122
     int width;
123
     int force_ellipses;
124
{
125
  register unsigned int i;
126
  unsigned int things_printed = 0;
127
  int in_literal_form = 0;
128
  int in_control_form = 0;
129
  int need_slashslash = 0;
130
  unsigned int c;
131
 
132
  if (length == 0)
133
    {
134
      fputs_filtered ("\"\"", stream);
135
      return;
136
    }
137
 
138
  for (i = 0; i < length && things_printed < print_max; ++i)
139
    {
140
      /* Position of the character we are examining
141
         to see whether it is repeated.  */
142
      unsigned int rep1;
143
      /* Number of repetitions we have detected so far.  */
144
      unsigned int reps;
145
 
146
      QUIT;
147
 
148
      if (need_slashslash)
149
        {
150
          fputs_filtered ("//", stream);
151
          need_slashslash = 0;
152
        }
153
 
154
      rep1 = i + 1;
155
      reps = 1;
156
      while (rep1 < length && string[rep1] == string[i])
157
        {
158
          ++rep1;
159
          ++reps;
160
        }
161
 
162
      c = string[i];
163
      if (reps > repeat_count_threshold)
164
        {
165
          if (in_control_form || in_literal_form)
166
            {
167
              if (in_control_form)
168
                fputs_filtered (")", stream);
169
              fputs_filtered ("\"//", stream);
170
              in_control_form = in_literal_form = 0;
171
            }
172
          chill_printchar (c, stream);
173
          fprintf_filtered (stream, "<repeats %u times>", reps);
174
          i = rep1 - 1;
175
          things_printed += repeat_count_threshold;
176
          need_slashslash = 1;
177
        }
178
      else
179
        {
180
          if (!in_literal_form && !in_control_form)
181
            fputs_filtered ("\"", stream);
182
          if (PRINT_LITERAL_FORM (c))
183
            {
184
              if (!in_literal_form)
185
                {
186
                  if (in_control_form)
187
                    {
188
                      fputs_filtered (")", stream);
189
                      in_control_form = 0;
190
                    }
191
                  in_literal_form = 1;
192
                }
193
              fprintf_filtered (stream, "%c", c);
194
              if (c == '"' || c == '^')
195
                /* duplicate this one as must be done at input */
196
                fprintf_filtered (stream, "%c", c);
197
            }
198
          else
199
            {
200
              if (!in_control_form)
201
                {
202
                  if (in_literal_form)
203
                    {
204
                      in_literal_form = 0;
205
                    }
206
                  fputs_filtered ("^(", stream);
207
                  in_control_form = 1;
208
                }
209
              else
210
                fprintf_filtered (stream, ",");
211
              c = c & 0xff;
212
              fprintf_filtered (stream, "%u", (unsigned int) c);
213
            }
214
          ++things_printed;
215
        }
216
    }
217
 
218
  /* Terminate the quotes if necessary.  */
219
  if (in_control_form)
220
    {
221
      fputs_filtered (")", stream);
222
    }
223
  if (in_literal_form || in_control_form)
224
    {
225
      fputs_filtered ("\"", stream);
226
    }
227
  if (force_ellipses || (i < length))
228
    {
229
      fputs_filtered ("...", stream);
230
    }
231
}
232
 
233
static struct type *
234
chill_create_fundamental_type (objfile, typeid)
235
     struct objfile *objfile;
236
     int typeid;
237
{
238
  register struct type *type = NULL;
239
 
240
  switch (typeid)
241
    {
242
    default:
243
      /* FIXME:  For now, if we are asked to produce a type not in this
244
         language, create the equivalent of a C integer type with the
245
         name "<?type?>".  When all the dust settles from the type
246
         reconstruction work, this should probably become an error. */
247
      type = init_type (TYPE_CODE_INT, 2, 0, "<?type?>", objfile);
248
      warning ("internal error: no chill fundamental type %d", typeid);
249
      break;
250
    case FT_VOID:
251
      /* FIXME:  Currently the GNU Chill compiler emits some DWARF entries for
252
         typedefs, unrelated to anything directly in the code being compiled,
253
         that have some FT_VOID types.  Just fake it for now. */
254
      type = init_type (TYPE_CODE_VOID, 0, 0, "<?VOID?>", objfile);
255
      break;
256
    case FT_BOOLEAN:
257
      type = init_type (TYPE_CODE_BOOL, 1, TYPE_FLAG_UNSIGNED, "BOOL", objfile);
258
      break;
259
    case FT_CHAR:
260
      type = init_type (TYPE_CODE_CHAR, 1, TYPE_FLAG_UNSIGNED, "CHAR", objfile);
261
      break;
262
    case FT_SIGNED_CHAR:
263
      type = init_type (TYPE_CODE_INT, 1, 0, "BYTE", objfile);
264
      break;
265
    case FT_UNSIGNED_CHAR:
266
      type = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED, "UBYTE", objfile);
267
      break;
268
    case FT_SHORT:              /* Chill ints are 2 bytes */
269
      type = init_type (TYPE_CODE_INT, 2, 0, "INT", objfile);
270
      break;
271
    case FT_UNSIGNED_SHORT:     /* Chill ints are 2 bytes */
272
      type = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED, "UINT", objfile);
273
      break;
274
    case FT_INTEGER:            /* FIXME? */
275
    case FT_SIGNED_INTEGER:     /* FIXME? */
276
    case FT_LONG:               /* Chill longs are 4 bytes */
277
    case FT_SIGNED_LONG:        /* Chill longs are 4 bytes */
278
      type = init_type (TYPE_CODE_INT, 4, 0, "LONG", objfile);
279
      break;
280
    case FT_UNSIGNED_INTEGER:   /* FIXME? */
281
    case FT_UNSIGNED_LONG:      /* Chill longs are 4 bytes */
282
      type = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED, "ULONG", objfile);
283
      break;
284
    case FT_FLOAT:
285
      type = init_type (TYPE_CODE_FLT, 4, 0, "REAL", objfile);
286
      break;
287
    case FT_DBL_PREC_FLOAT:
288
      type = init_type (TYPE_CODE_FLT, 8, 0, "LONG_REAL", objfile);
289
      break;
290
    }
291
  return (type);
292
}
293
 
294
 
295
/* Table of operators and their precedences for printing expressions.  */
296
 
297
static const struct op_print chill_op_print_tab[] =
298
{
299
  {"AND", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
300
  {"OR", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
301
  {"NOT", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
302
  {"MOD", BINOP_MOD, PREC_MUL, 0},
303
  {"REM", BINOP_REM, PREC_MUL, 0},
304
  {"SIZE", UNOP_SIZEOF, PREC_BUILTIN_FUNCTION, 0},
305
  {"LOWER", UNOP_LOWER, PREC_BUILTIN_FUNCTION, 0},
306
  {"UPPER", UNOP_UPPER, PREC_BUILTIN_FUNCTION, 0},
307
  {"CARD", UNOP_CARD, PREC_BUILTIN_FUNCTION, 0},
308
  {"MAX", UNOP_CHMAX, PREC_BUILTIN_FUNCTION, 0},
309
  {"MIN", UNOP_CHMIN, PREC_BUILTIN_FUNCTION, 0},
310
  {":=", BINOP_ASSIGN, PREC_ASSIGN, 1},
311
  {"=", BINOP_EQUAL, PREC_EQUAL, 0},
312
  {"/=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
313
  {"<=", BINOP_LEQ, PREC_ORDER, 0},
314
  {">=", BINOP_GEQ, PREC_ORDER, 0},
315
  {">", BINOP_GTR, PREC_ORDER, 0},
316
  {"<", BINOP_LESS, PREC_ORDER, 0},
317
  {"+", BINOP_ADD, PREC_ADD, 0},
318
  {"-", BINOP_SUB, PREC_ADD, 0},
319
  {"*", BINOP_MUL, PREC_MUL, 0},
320
  {"/", BINOP_DIV, PREC_MUL, 0},
321
  {"//", BINOP_CONCAT, PREC_PREFIX, 0},          /* FIXME: precedence? */
322
  {"-", UNOP_NEG, PREC_PREFIX, 0},
323
  {"->", UNOP_IND, PREC_SUFFIX, 1},
324
  {"->", UNOP_ADDR, PREC_PREFIX, 0},
325
  {":", BINOP_RANGE, PREC_ASSIGN, 0},
326
  {NULL, 0, 0, 0}
327
};
328
 
329
/* The built-in types of Chill.  */
330
 
331
struct type *builtin_type_chill_bool;
332
struct type *builtin_type_chill_char;
333
struct type *builtin_type_chill_long;
334
struct type *builtin_type_chill_ulong;
335
struct type *builtin_type_chill_real;
336
 
337
struct type **CONST_PTR (chill_builtin_types[]) =
338
{
339
  &builtin_type_chill_bool,
340
    &builtin_type_chill_char,
341
    &builtin_type_chill_long,
342
    &builtin_type_chill_ulong,
343
    &builtin_type_chill_real,
344
 
345
};
346
 
347
/* Calculate LOWER or UPPER of TYPE.
348
   Returns the result as an integer.
349
   *RESULT_TYPE is the appropriate type for the result. */
350
 
351
LONGEST
352
type_lower_upper (op, type, result_type)
353
     enum exp_opcode op;        /* Either UNOP_LOWER or UNOP_UPPER */
354
     struct type *type;
355
     struct type **result_type;
356
{
357
  LONGEST low, high;
358
  *result_type = type;
359
  CHECK_TYPEDEF (type);
360
  switch (TYPE_CODE (type))
361
    {
362
    case TYPE_CODE_STRUCT:
363
      *result_type = builtin_type_int;
364
      if (chill_varying_type (type))
365
        return type_lower_upper (op, TYPE_FIELD_TYPE (type, 1), result_type);
366
      break;
367
    case TYPE_CODE_ARRAY:
368
    case TYPE_CODE_BITSTRING:
369
    case TYPE_CODE_STRING:
370
      type = TYPE_FIELD_TYPE (type, 0);          /* Get index type */
371
 
372
      /* ... fall through ... */
373
    case TYPE_CODE_RANGE:
374
      *result_type = TYPE_TARGET_TYPE (type);
375
      return op == UNOP_LOWER ? TYPE_LOW_BOUND (type) : TYPE_HIGH_BOUND (type);
376
 
377
    case TYPE_CODE_ENUM:
378
    case TYPE_CODE_BOOL:
379
    case TYPE_CODE_INT:
380
    case TYPE_CODE_CHAR:
381
      if (get_discrete_bounds (type, &low, &high) >= 0)
382
        {
383
          *result_type = type;
384
          return op == UNOP_LOWER ? low : high;
385
        }
386
      break;
387
    case TYPE_CODE_UNDEF:
388
    case TYPE_CODE_PTR:
389
    case TYPE_CODE_UNION:
390
    case TYPE_CODE_FUNC:
391
    case TYPE_CODE_FLT:
392
    case TYPE_CODE_VOID:
393
    case TYPE_CODE_SET:
394
    case TYPE_CODE_ERROR:
395
    case TYPE_CODE_MEMBER:
396
    case TYPE_CODE_METHOD:
397
    case TYPE_CODE_REF:
398
    case TYPE_CODE_COMPLEX:
399
    default:
400
      break;
401
    }
402
  error ("unknown mode for LOWER/UPPER builtin");
403
}
404
 
405
static value_ptr
406
value_chill_length (val)
407
     value_ptr val;
408
{
409
  LONGEST tmp;
410
  struct type *type = VALUE_TYPE (val);
411
  struct type *ttype;
412
  CHECK_TYPEDEF (type);
413
  switch (TYPE_CODE (type))
414
    {
415
    case TYPE_CODE_ARRAY:
416
    case TYPE_CODE_BITSTRING:
417
    case TYPE_CODE_STRING:
418
      tmp = type_lower_upper (UNOP_UPPER, type, &ttype)
419
        - type_lower_upper (UNOP_LOWER, type, &ttype) + 1;
420
      break;
421
    case TYPE_CODE_STRUCT:
422
      if (chill_varying_type (type))
423
        {
424
          tmp = unpack_long (TYPE_FIELD_TYPE (type, 0), VALUE_CONTENTS (val));
425
          break;
426
        }
427
      /* ... else fall through ... */
428
    default:
429
      error ("bad argument to LENGTH builtin");
430
    }
431
  return value_from_longest (builtin_type_int, tmp);
432
}
433
 
434
static value_ptr
435
value_chill_card (val)
436
     value_ptr val;
437
{
438
  LONGEST tmp = 0;
439
  struct type *type = VALUE_TYPE (val);
440
  CHECK_TYPEDEF (type);
441
 
442
  if (TYPE_CODE (type) == TYPE_CODE_SET)
443
    {
444
      struct type *range_type = TYPE_INDEX_TYPE (type);
445
      LONGEST lower_bound, upper_bound;
446
      int i;
447
 
448
      get_discrete_bounds (range_type, &lower_bound, &upper_bound);
449
      for (i = lower_bound; i <= upper_bound; i++)
450
        if (value_bit_index (type, VALUE_CONTENTS (val), i) > 0)
451
          tmp++;
452
    }
453
  else
454
    error ("bad argument to CARD builtin");
455
 
456
  return value_from_longest (builtin_type_int, tmp);
457
}
458
 
459
static value_ptr
460
value_chill_max_min (op, val)
461
     enum exp_opcode op;
462
     value_ptr val;
463
{
464
  LONGEST tmp = 0;
465
  struct type *type = VALUE_TYPE (val);
466
  struct type *elttype;
467
  CHECK_TYPEDEF (type);
468
 
469
  if (TYPE_CODE (type) == TYPE_CODE_SET)
470
    {
471
      LONGEST lower_bound, upper_bound;
472
      int i, empty = 1;
473
 
474
      elttype = TYPE_INDEX_TYPE (type);
475
      CHECK_TYPEDEF (elttype);
476
      get_discrete_bounds (elttype, &lower_bound, &upper_bound);
477
 
478
      if (op == UNOP_CHMAX)
479
        {
480
          for (i = upper_bound; i >= lower_bound; i--)
481
            {
482
              if (value_bit_index (type, VALUE_CONTENTS (val), i) > 0)
483
                {
484
                  tmp = i;
485
                  empty = 0;
486
                  break;
487
                }
488
            }
489
        }
490
      else
491
        {
492
          for (i = lower_bound; i <= upper_bound; i++)
493
            {
494
              if (value_bit_index (type, VALUE_CONTENTS (val), i) > 0)
495
                {
496
                  tmp = i;
497
                  empty = 0;
498
                  break;
499
                }
500
            }
501
        }
502
      if (empty)
503
        error ("%s for empty powerset", op == UNOP_CHMAX ? "MAX" : "MIN");
504
    }
505
  else
506
    error ("bad argument to %s builtin", op == UNOP_CHMAX ? "MAX" : "MIN");
507
 
508
  return value_from_longest (TYPE_CODE (elttype) == TYPE_CODE_RANGE
509
                             ? TYPE_TARGET_TYPE (elttype)
510
                             : elttype,
511
                             tmp);
512
}
513
 
514
static value_ptr
515
evaluate_subexp_chill (expect_type, exp, pos, noside)
516
     struct type *expect_type;
517
     register struct expression *exp;
518
     register int *pos;
519
     enum noside noside;
520
{
521
  int pc = *pos;
522
  struct type *type;
523
  int tem, nargs;
524
  value_ptr arg1;
525
  value_ptr *argvec;
526
  enum exp_opcode op = exp->elts[*pos].opcode;
527
  switch (op)
528
    {
529
    case MULTI_SUBSCRIPT:
530
      if (noside == EVAL_SKIP)
531
        break;
532
      (*pos) += 3;
533
      nargs = longest_to_int (exp->elts[pc + 1].longconst);
534
      arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
535
      type = check_typedef (VALUE_TYPE (arg1));
536
 
537
      if (nargs == 1 && TYPE_CODE (type) == TYPE_CODE_INT)
538
        {
539
          /* Looks like string repetition. */
540
          value_ptr string = evaluate_subexp_with_coercion (exp, pos, noside);
541
          return value_concat (arg1, string);
542
        }
543
 
544
      switch (TYPE_CODE (type))
545
        {
546
        case TYPE_CODE_PTR:
547
          type = check_typedef (TYPE_TARGET_TYPE (type));
548
          if (!type || TYPE_CODE (type) != TYPE_CODE_FUNC)
549
            error ("reference value used as function");
550
          /* ... fall through ... */
551
        case TYPE_CODE_FUNC:
552
          /* It's a function call. */
553
          if (noside == EVAL_AVOID_SIDE_EFFECTS)
554
            break;
555
 
556
          /* Allocate arg vector, including space for the function to be
557
             called in argvec[0] and a terminating NULL */
558
          argvec = (value_ptr *) alloca (sizeof (value_ptr) * (nargs + 2));
559
          argvec[0] = arg1;
560
          tem = 1;
561
          for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
562
            {
563
              argvec[tem]
564
                = evaluate_subexp_chill (TYPE_FIELD_TYPE (type, tem - 1),
565
                                         exp, pos, noside);
566
            }
567
          for (; tem <= nargs; tem++)
568
            argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
569
          argvec[tem] = 0;       /* signal end of arglist */
570
 
571
          return call_function_by_hand (argvec[0], nargs, argvec + 1);
572
        default:
573
          break;
574
        }
575
 
576
      while (nargs-- > 0)
577
        {
578
          value_ptr index = evaluate_subexp_with_coercion (exp, pos, noside);
579
          arg1 = value_subscript (arg1, index);
580
        }
581
      return (arg1);
582
 
583
    case UNOP_LOWER:
584
    case UNOP_UPPER:
585
      (*pos)++;
586
      if (noside == EVAL_SKIP)
587
        {
588
          (*exp->language_defn->evaluate_exp) (NULL_TYPE, exp, pos, EVAL_SKIP);
589
          goto nosideret;
590
        }
591
      arg1 = (*exp->language_defn->evaluate_exp) (NULL_TYPE, exp, pos,
592
                                                  EVAL_AVOID_SIDE_EFFECTS);
593
      tem = type_lower_upper (op, VALUE_TYPE (arg1), &type);
594
      return value_from_longest (type, tem);
595
 
596
    case UNOP_LENGTH:
597
      (*pos)++;
598
      arg1 = (*exp->language_defn->evaluate_exp) (NULL_TYPE, exp, pos, noside);
599
      return value_chill_length (arg1);
600
 
601
    case UNOP_CARD:
602
      (*pos)++;
603
      arg1 = (*exp->language_defn->evaluate_exp) (NULL_TYPE, exp, pos, noside);
604
      return value_chill_card (arg1);
605
 
606
    case UNOP_CHMAX:
607
    case UNOP_CHMIN:
608
      (*pos)++;
609
      arg1 = (*exp->language_defn->evaluate_exp) (NULL_TYPE, exp, pos, noside);
610
      return value_chill_max_min (op, arg1);
611
 
612
    case BINOP_COMMA:
613
      error ("',' operator used in invalid context");
614
 
615
    default:
616
      break;
617
    }
618
 
619
  return evaluate_subexp_standard (expect_type, exp, pos, noside);
620
nosideret:
621
  return value_from_longest (builtin_type_long, (LONGEST) 1);
622
}
623
 
624
const struct language_defn chill_language_defn =
625
{
626
  "chill",
627
  language_chill,
628
  chill_builtin_types,
629
  range_check_on,
630
  type_check_on,
631
  chill_parse,                  /* parser */
632
  chill_error,                  /* parser error function */
633
  evaluate_subexp_chill,
634
  chill_printchar,              /* print a character constant */
635
  chill_printstr,               /* function to print a string constant */
636
  NULL,                         /* Function to print a single char */
637
  chill_create_fundamental_type,        /* Create fundamental type in this language */
638
  chill_print_type,             /* Print a type using appropriate syntax */
639
  chill_val_print,              /* Print a value using appropriate syntax */
640
  chill_value_print,            /* Print a top-levl value */
641
  {"", "B'", "", ""},           /* Binary format info */
642
  {"O'%lo", "O'", "o", ""},     /* Octal format info */
643
  {"D'%ld", "D'", "d", ""},     /* Decimal format info */
644
  {"H'%lx", "H'", "x", ""},     /* Hex format info */
645
  chill_op_print_tab,           /* expression operators for printing */
646
  0,                             /* arrays are first-class (not c-style) */
647
  0,                             /* String lower bound */
648
  &builtin_type_chill_char,     /* Type of string elements */
649
  LANG_MAGIC
650
};
651
 
652
/* Initialization for Chill */
653
 
654
void
655
_initialize_chill_language ()
656
{
657
  builtin_type_chill_bool =
658
    init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
659
               TYPE_FLAG_UNSIGNED,
660
               "BOOL", (struct objfile *) NULL);
661
  builtin_type_chill_char =
662
    init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
663
               TYPE_FLAG_UNSIGNED,
664
               "CHAR", (struct objfile *) NULL);
665
  builtin_type_chill_long =
666
    init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
667
               0,
668
               "LONG", (struct objfile *) NULL);
669
  builtin_type_chill_ulong =
670
    init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
671
               TYPE_FLAG_UNSIGNED,
672
               "ULONG", (struct objfile *) NULL);
673
  builtin_type_chill_real =
674
    init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
675
               0,
676
               "LONG_REAL", (struct objfile *) NULL);
677
 
678
  add_language (&chill_language_defn);
679
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.