[gentoo-commits] gentoo commit in src/patchsets/gdb/6.7.1: 10_all_gdb-6.6-duel.patch 11_all_gdb-6.6-duel-integrate.patch README.history

[Mike Frysinger (vapier)]

vapier      07/12/29 21:06:07

  Modified:             README.history
  Added:                10_all_gdb-6.6-duel.patch
                        11_all_gdb-6.6-duel-integrate.patch
  Log:
  add DUEL support #199987 by Sergei Golubchik

Revision  Changes    Path
1.2                  src/patchsets/gdb/6.7.1/README.history

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/gdb/6.7.1/README.history?rev=1.2&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/gdb/6.7.1/README.history?rev=1.2&content-type=text/plain
diff : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/gdb/6.7.1/README.history?r1=1.1&r2=1.2

Index: README.history
===================================================================
RCS file: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/README.history,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- README.history	29 Oct 2007 20:40:43 -0000	1.1
+++ README.history	29 Dec 2007 21:06:06 -0000	1.2
@@ -1,3 +1,7 @@
+1.1		[29.12.2007]
+	+ 10_all_gdb-6.6-duel.patch
+	+ 11_all_gdb-6.6-duel-integrate.patch
+
 1.0		[29.10.2007]
 	+ 35_all_gdb-6.3-security-errata-20050610.patch
 	+ 45_all_gdb-hppa-offsets.patch



1.1                  src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch?rev=1.1&content-type=text/plain

Index: 10_all_gdb-6.6-duel.patch
===================================================================
ftp://ftp.cs.princeton.edu/pub/duel/

--- gdb/duel/MANUAL
+++ gdb/duel/MANUAL
@@ -0,0 +1,501 @@
+
+
+
+     DDDDuuuueeeellll((((1111))))                 VVVVeeeerrrrssssiiiioooonnnn 1111....11110000 ((((MMMMaaaarrrr 99993333))))                  DDDDuuuueeeellll((((1111))))
+
+
+
+     NNNNAAAAMMMMEEEE
+     duel - A high level C debugging language extension to gdb
+
+     SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS
+     dddduuuueeeellll [gdb options] [_p_r_o_g[_c_o_r_e|_p_r_o_c_I_D]]
+
+     DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
+     Duel  is  a  special  purpose  language  designed  for  concise  state
+     exploration  of  debugged  C programs, currently implemented under the
+     GNU debugger _g_d_b(1).  Duel is invoked by entering  the  shell  command
+     _d_u_e_l instead of _g_d_b. It is identical to gdb except for comments, which
+     begin with `##' instead of `#',  and  the  new  _d_l  command  for  Duel
+     expressions:
+
+     _g_d_b> dl x[1..10] >? 5
+     x[3] = 14
+     x[8] = 6
+
+     prints the array elements x[1] to x[10] that are greater than  5.  The
+     output  includes  the  values  14  and  6,  as  well as their symbolic
+     representation "x[3]" and "x[8]".
+
+     IIIIFFFF YYYYOOOOUUUU NNNNEEEEVVVVEEEERRRR UUUUSSSSEEEEDDDD GGGGDDDDBBBB
+     The improved functionality added by Duel merits a fresh look  even  by
+     debugger  shunners.   Gdb is a powerful debugger with many commands, a
+     thick manual and various interfaces including _e_m_a_c_s(1)  and  _x_x_g_d_b(1).
+     These gdb commands should help you get started:
+
+     _b _l_i_n_e   set a breakpoint at the line (b func to break at a function)
+     _d _n      delete breakpoint number n (gdb prints n when bp occurs)
+     _l _l_i_n_e   list the source beginning at line (l file.c:line for module)
+     _r _p_a_r_m   run/restart the program with the given parameters
+     _s        single-step to the next statement (steps into function calls)
+     _n        single-step to the next line, skipping over function calls
+     _c        continue execution
+     _b_t       show a stack trace
+     _p _e_x_p    evaluate a symbolic expression
+     _d_l _e_x_p   evaluate a Duel expression
+     _d_l _g_d_b   give a gdb command summary
+
+     The most common use is `b func' followed by `r'  followed  by  several
+     `n' and `s', evaluating expressions in between.
+
+     DDDDUUUUEEEELLLL QQQQUUUUIIIICCCCKKKK SSSSTTTTAAAARRRRTTTT
+     Duel is implemented by adding the _d_l command to gdb. All gdb  commands
+     work  as before. The dl command, however, is interpreted by duel.  Gdb
+     concepts (such as the value history) do not work in  the  dl  command,
+     and duel concepts are not understood by other gdb command.
+
+     Duel is based on expressions which return multiple values.   The  x..y
+     operator  returns the integers from x to y; the x,y operator returns x
+     and then y, e.g.
+
+     _g_d_b> dl (1,9,12..15,22)
+
+     prints 1, 9, 12, 13, 14, 15 and  22.  Such  expressions  can  be  used
+     wherever a single value is used, e.g.
+
+     _g_d_b> dl x[0..99]=0 ;
+
+     assigns zero to the first 100 elements of array x.  The  semantics  of
+     x[i]  are  the  same  as in C. They are applied for each of the values
+     returned by 0..99, which can be thought  of  as  an  implied  external
+     loop.   The  trailing  semicolon indicates evaluation for side-effects
+     only,  with  no  output.  Duel  incorporates  C  operators,  casts   C
+     statements as expressions, and supports limited  variable declaration:
+
+     _g_d_b> dl int i;for(i=0;i<100;i++)
+                      if(x[i]<0) printf("x[%d]=%d\n",i,x[i]);
+     x[7] = -4
+
+     The semicolon  prevents  Duel  output;  only  output  from  printf  is
+     printed.   Aliases are defined with x:=y and provide an alternative to
+     variable declaration. We could  also  return  x[i]  instead  of  using
+     printf:
+
+     _g_d_b> dl if(x[i:=0..99]<0) x[i]
+     x[i] = -4
+
+     The symbolic output "x[i]" can be fixed by surrounding i with {}, i.e.
+
+     _g_d_b> dl if(x[i:=0..99]<0) x[{i}]
+     x[7] = -4
+
+     The {} are like (), but force  the  symbolic  evaluation  to  use  i's
+     value,  instead  of  "i".  You  can usually avoid this altogether with
+     direct Duel operators:
+
+     _g_d_b> dl x[..100] <? 0
+     x[7] = -4
+
+     The ..n operator is a shorthand for 0..n-1, i.e. ..100 is the same  as
+     0..99.   The  x<?y,  x==?y,  x>=?y, etc., operators compare their left
+     side operand to their right side operand as in C, but return the  left
+     side  value if the comparison result is true. Otherwise, they look for
+     the next values to compare, without returning anything.
+
+     Duel's x.y and x->y allow an expression y, evaluated under x's scope:
+
+     _g_d_b> dl emp[..100].(if(code>400) (code,name))
+     emp[46].code = 682
+     emp[46].name = "Ela"
+
+     The if() expression is evaluated under the scope of  each  element  of
+     emp[], an array of structures. In C terms, we had to write:
+
+     _g_d_b> dl int i; for(i=0; i<100 ; i++)
+           if(emp[i].code>400) emp[{i}].code,emp[{i}].name
+
+     A useful alternative to loops is the x=>y operator. It returns  y  for
+     each value of x, setting `_' to reference x's value, e.g.
+
+     _g_d_b> ..100 => if(emp[_].code>400) emp[_].code,emp[_].name
+
+     Using `_' instead of `i' also avoids the need for  {i}.  Finally,  the
+     x-->y operator expands lists and other data structures. If head points
+     to a linked list threaded through the next field, then:
+
+     _g_d_b> dl head-->next->data
+     head->data = 12
+     head->next->data = 14
+     head-->next[[2]]->data = 20
+     head-->next[[3]]->data = 26
+
+     produce the data field for each node in the list. x-->y returns x,  x-
+     >y,  x->y->y,  x->y->y->y,  ...  until  a  NULL is found. The symbolic
+     output "x-->y[[n]]" indicates that ->y was applied n times. x[[y]]  is
+     also the selection operator:
+
+     _g_d_b> dl head-->next[[50..60]]->data
+
+     return the 50th through  the  60th  elements  in  the  list.  The  #/x
+     operator counts the number of values, so
+
+     _g_d_b> dl #/( head-->next->data >? 50 )
+
+     counts the number of data elements over 50 on the list.  Several other
+     operators,  including  x@y,  x#y  and  active  call  stack  access are
+     described in the operators section.
+
+     OOOOPPPPEEEERRRRAAAATTTTOOOORRRRSSSS SSSSUUUUMMMMMMMMAAAARRRRYYYY
+     Assoc   Operators                   Details
+     left    {} () [] -> . f() -->       x-->y expands x->y x->y->y ...
+             x[[y]] x#y x@y              generate x; select, index or stop-at y
+     right   #/ - * & ! ~ ++ -- (cast)   #/x number of x values
+             frame(n) sizeof(x)          reference to call stack level n
+     left    x/y x*y x%y                 multiply, divide, reminder
+     left    x-y x+y                     add, subtract
+     left    x<<y x>>y                   shift left/right
+     none    x..y ..y x..                ..y = 0..y-1. x..y return x, x+1...y
+     left    < > <= >= <? >? <=? >=?     x>?y return x if x>y
+     left    == != ==? !=?               x==?y return x if x==y
+     left    x&y                         bit-and
+     left    x^y                         bit-xor
+     left    x|y                         bit-or
+     left    x&&y &&/x                   &&/x are all x values non-zero?
+     left    x||y ||/x                   ||/x is any x value non-zero?
+     right   x? y:z                      foreach x, if(x) y else z
+     right   x:=y x=y x+=y ...           x:=y set x as an alias to y
+     left    x,y                         return x, then y
+     right   x=>y                        foreach x, evaluate y with x value `_'
+     right   if() else  while()  for()   C statements cast as operators
+     left    x;y                         evaluate and ignore x, return y
+
+
+     EEEEXXXXAAAAMMMMPPPPLLLLEEEESSSS
+     dl (0xff-0x12)*3                    compute simple expression
+     dl (1..10)*(1..10)                  display multiplication table
+     dl x[10..20,22,24,40..60]           display x[i] for the selected indexes
+     dl x[9..0]                          display x[i] backwards
+     dl x[..100] >? 5                    display x[i] that are greater than 5
+     dl x[..100] >? 5 <? 10              display x[i] if 5<x[i]<10
+     dl x[..100] ==? (6..9)              same
+     dl x[0..99]=>if(_>5 && _<10) _      same
+     dl y[x[..100] !=? 0]                display y[x[i]] for each non-zero x[i]
+     dl emp[..50].code                   display emp[i].code for i=0 to 49
+     dl emp[..50].(code,name)            display emp[i].code & emp[i].name
+     dl val[..50].(is_dbl? x:y)          display val[i].x or val[i].y depending
+                                         on val[i].is_dbl.
+     dl val[..50].if(is_dbl) x else y    same as above
+     dl x[..100]=0 ;                     assign 0 to x[i]
+     dl x[i:=..100]=y[i] ;               assign y[i] to x[i]
+     dl x[..100]=y[..100] *ERR*          assign y[99] to each x[j]
+     dl x[i:=..3]=(4,5,9)[[i]]           assign x[0]=4 x[1]=5 x[2]=9
+     dl x[..3]=(4,5,9)    *ERR*          assign 9 to each element
+     dl if(x[i:=..100]<0) x[i]=0 ;       assign 0 to negative x[i]
+     dl (hash[..1024]!=?0)->scope        hash[i].scope for non-null hash[i]
+     dl x[i:=..100] >? x[i+1]            check if x[i] is not sorted
+     dl x[i:=..100] ==? x[j:=..100]=>    checks if x has non-unique elements
+        if(i<j) x[{i,j}]
+     dl if(x[i:=..99] ==                 same
+        x[j:=i+1..99]) x[{i,j}]
+     dl (x[..100] >? 0)[[0]]             the 1st (0th element) positive x[i]
+     dl (x[..100] >? 0)[[2]]             return the 3rd positive x[i]
+     dl (x[..100] >? 0)[[..5]]           return the first 5 positive x[i]
+     dl (x[0..] >? 6)[[0]]               return the first x[i]>6, no limit on i
+     dl argv[0..]@0                      argv[0] argv[1] .. until first null
+     dl x[0..]@-1 >? 9                   x[0..n]>9 where n is first x[n]== -1
+     dl emp[0..]@(code==0)               emp[0]..emp[n-1] where emp[n].code==0
+
+     dl head-->next->val                 val of each element in a linked list
+     dl head-->next[[20]]                the 21st element of a linked list
+     dl *head-->next[[20]]               display above as a struct
+     dl strcmp(head-->next->msg,         search linked list for a string
+          "testing") ==? 0
+     dl #/head-->next                    count elements on a linked list
+     dl x-->y[[#/x-->y - 1]]             last element of a linked list
+     dl x-->y[[#/x-->y - 10..1]]         last 10 elements of a linked list
+     dl head-->next->                    check if the list is sorted by val
+        if(next) val >? next->val
+
+     dl head-->(next!=?head)             expand cyclic linked list (tail->head)
+     dl head-->(next!=?_)                handle termination with p->next==p
+     dl root-->(left,right)->key         expand binary tree, show keys
+     dl root-->(left,right)->(           check bin tree sorted by key
+        (left!=?0)->key>=?key, (right    !=?0 )->key<=?key)
+
+     dl (1000..=>if(&&/(2,3.._-1=>__%_   find first 10 primes over 1000
+                ) _)[[..10]]
+     dl (T mytype) x                     convert x to user defined type mytype
+     dl (struct s*) x                    convert x to struct s pointer
+     dl if(x) y; else z *ERR*            ';' must be followed by an expression
+     dl {x} y *ERR*                      '}' requires ';' if followed by exp
+
+     SSSSEEEEMMMMAAAANNNNTTTTIIIICCCCSSSS
+     Duel's semantics are modeled after the Icon programming language.  The
+     input  consists  of  expressions  which  return sequences of values. C
+     statements are cast as expressions, too. Expressions are  parsed  into
+     abstract  syntax  trees,  which  are  traversed during evaluation. The
+     evaluation of most nodes (operators) recursively  evaluates  the  next
+     value  for  each operand, and then applies the operator to produce the
+     next result. Only one value is produced each  time,  and  Duel's  eval
+     function  keeps  a  `state'  for each node (backtracking, co-routines,
+     consumer-producer or threads are good  metaphors  for  the  evaluation
+     mechanism.)
+
+     For example, in (5,3)+6..8, the evaluation of `+' first retrieves  the
+     operands  5  and  6, to compute and return 5+6. Then 7, the next right
+     operand is retrieved and 5+7 is  returned,  followed  by  5+8.   Since
+     there  are  no  other right operand value, the next left operand, 3 is
+     fetched. The right operand's computation is restarted returning 6, and
+     3+6 is returned. The final return values are 3+7 and 3+8.
+
+     The computation for operators like x>?y is similar, but when x<=y, the
+     next  values  are  fetched  instead  of returning a value, forming the
+     basis for an implicit search. Operators like `..' return a sequence of
+     values  for  each  pair of operands. For a better understanding of the
+     evaluation mechanism, see the USENIX Winter/93 conference paper  "DUEL
+     - A Very High Level Debugging Language".
+
+     Duel values follow the C semantics. A value is either an "lvalue" (can
+     be  used  as  the  left  hand  side  of  assignment),  or an "rvalue".
+     Therefor,  objects  like  arrays  can  not  be  directly   manipulated
+     (However, operators like x..y can accomplish such tasks.)
+
+     Duel  types  also  follow  the  C  semantics,  with   some   important
+     differences.  C  types are checked  statically; Duel types are checked
+     when operators are applied, e.g., (1,1.0)/2 returns 0  (int)  and  0.5
+     (double); (x,y).z returns x.z and y.z even if x and y are of different
+     types, as long as they both have a field z.
+
+     Values and types of symbols are looked up  at  run-time  (using  gdb's
+     lookup  rules),  allowing  dynamic  scoping  and  types, but causing a
+     parsing problem: (x)(y) can be parsed as either a function  call  x(y)
+     or  a cast (x)y; x*y can be parsed as a declaration of y as (x*) or as
+     multiplication.
+
+     To avoid this ambiguity, the keyword T must  precede  a  user  defined
+     type.  For  example,  if  value  is  a typedef, C's (value (*)()) x is
+     written in Duel as:  (T value  (*)())  x.  Types  that  begin  with  a
+     reserved  keyword don't need T, e.g. (struct value*) x and (long *[5])
+     y are accepted.  As special cases, (type)x and (type*)x  are  accepted
+     but  discouraged  (it  causes  (printf)("hi"), which is valid in C, to
+     fail).  A side effect is that "sizeof x" must be written as sizeof(x).
+
+     OOOOPPPPEEEERRRRAAAATTTTOOOORRRRSSSS
+     _x+_y  _x-_y  _x*_y  _x/_y  _x%_y  _x^_y  _x|_y  _x&_y  _x<<_y  _x>>_y
+     _x>_y  _x<_y  _x>=_y  _x<=_y  _x==_y  _x!=_y  _x=_y  _x[_y]
+
+     These binary operators follow their C semantics. For each value of  x,
+     they  are  evaluated for every value of y, .e.g. (5,2)>(4,1) evaluates
+     as 5>4, 5>1, 2>4, 2>1 returning  1, 1, 0, 1.  The  y  values  are  re-
+     evaluated  for  each  new value of x, e.g. i=4; (4,5)>i++ evaluates as
+     4>4 and  5>5.   Beware  of  multiple  y  values  in  assignment,  e.g.
+     x[..3]=(4,6,9) does not set x[0]=4, x[1]=6 and x[2]=9. It assigns 4, 6
+     and 9 to each  element,  having  the  same  effect  as  x[..3]=9.  Use
+     x[i:=..3]=(4,6,9)[[i]] to achieve the desired effect.
+
+     -_x  ~_x  &_x  *_x  !_x  ++_x  --_x  _x++  _x--  _s_i_z_e_o_f(_x)  (_t_y_p_e)_x
+
+     These unary operators follow their C semantics. They  are  applied  to
+     each  value  of  x.  The  increment and decrement operators require an
+     lvalue, so i:=0 ; i++ produces an error because i is an alias to 0, an
+     rvalue.  Parenthesis  must  be  used with sizeof(x), "sizeof x" is not
+     allowed. Cast to user defined  type  requires  generally  requires  T,
+     e.g.,
+      (T val(*)())x, but (val)x and (val*)x are accepted as special cases.
+
+     _x&&_y   _x||_y
+
+     These logical operators also follow their C semantics, but  have  non-
+     intuitive  results  for  multi-valued  x  and y, e.g. (1,0,0) || (1,0)
+     returns 1,1,0,1,0 -- the right hand-side (1,0) is  returned  for  each
+     left-hand  side  0.  It  is best to use these operators only in single
+     value expressions.
+
+     _x? _y:_z   _i_f(_x)_y   _i_f(_x)_y _e_l_s_e _z
+
+     These expressions return the values  of  y  for  each  non-zero  value
+     returned  by x, and the values of z for each zero value returned by x,
+     e.g. if(x[..100]==0) y returns y for every x[i]==0, not  if  all  x[i]
+     are zero (if(&&/(x[..100]==0)) y  does that).  Also, "if(x) y; else z"
+     is illegal.  Duel's  semicolon  is  an  expression  separator,  not  a
+     terminator.
+
+     _w_h_i_l_e(_x)_y   _f_o_r(_w;_x;_y)_z
+
+     The while(x)y expression returns y as long as  all  values  of  x  are
+     non-zero.   The for() expression is similar and both have the expected
+     C semantics. For example, "for(i=0 ; i<100 ; i++) x[i]" is the same as
+     x[..100].  Unlike  the if() expression, while(x[..100]==0) continue to
+     execute only if all elements of x are  zero,  i.e.  the  condition  is
+     evaluated into a single value using an implicit &&/x.
+
+     VVVVaaaarrrriiiiaaaabbbblllleeee ddddeeeeccccllllaaaarrrraaaattttiiiioooonnnn::::  _t_y_p_e _n_a_m_e [,_n_a_m_e ...] ; ...
+
+     Expressions  can   begin   with   variables   declaration   (but   not
+     initialization).   Internally,  a  declaration  sets an alias to space
+     allocated in the target by calling malloc(), e.g. `int x' is the  same
+     as  "x:= *(int *) malloc(sizeof(int))". This is oblivious to the user.
+     The allocated memory is not claimed when  a  variable  is  redeclared.
+     Declared  variables  addresses  can be passed to functions and used in
+     other data structures. The keyword `T' must precede user defined types
+     (typedef),  e.g.  if  val  is  a  user  defined  type, The C code "val
+     *p=(val*) x" becomes "T val *p; p=(T val *) x" in Duel.
+
+     FFFFuuuunnnnccccttttiiiioooonnnn ccccaaaallllllllssss::::  _f_u_n_c(_p_a_r_m,...)
+
+     Function calls to the debugged program can  be  intermixed  with  Duel
+     code.  Multi-valued  parameters  are handled as with binary operators.
+     The call value can have multiple values, e.g. (x,y)()  calls  x()  and
+     y().  Currently,  struct/union  parameters  and  return values are not
+     supported.
+
+     _x,_y   _x.._y   .._x    _x..
+
+     These operators produce multiple values for single value operands. x,y
+     returns x, then y. x..y returns the integers from x to y. When x>y the
+     sequence is returned in descending order, i.e. 5..3 returns 5,  4,  3.
+     The  operator ..x is a shorthand for 0..x-1, e.g. ..3 returns 0, 1, 2.
+     The x.. operator is a shorthand for x..maxint. It  returns  increasing
+     integer  values  starting  at x indefinitely, and should be bounded by
+     [[n]] or @n operators.  `,' retains its precedence  level  in  C.  The
+     precedence  of  `..'   is above `<' and below arithmetic operators, so
+     0..n-1 and x==1..9 work as expected.
+
+     _x<?_y  _x>?_y  _x>=?_y  _x<=?_y  _x!=?_y  _x==?_y
+
+     These operators work like their C counterparts but  return  x  if  the
+     comparison  is  true. If the comparison is false, the next (x,y) value
+     is tried, forming the basis of an implicit search.
+
+     (_x)  {_x}  _x;_y  _x=>_y
+
+     Both () and {} act as C parenthesis. The curly braces set the returned
+     symbolic  value as the actual value, e.g. if i=5 and x[5]=3, then x[i]
+     produces the output "x[i] = 3", x[{i}] produces "x[5] = 3" and  {x[i]}
+     produces  just  "3".  The  semicolon  is an operator. x;y evaluates x,
+     ignoring the results, then evaluate and return y, e.g. (i:=1..3 ; i+5)
+     sets  i to 3 and return 8. The x=>y operator evaluate and return y for
+     each value of x, e.g. (i:=1..3 => i+5) returns 6, 7 and 8.  The  value
+     returned by x is also stored implicitly in `_' which can be used in y,
+     e.g. 1..5 => z[_][_] will output z[1][1], z[2][2]  etc.  The  symbolic
+     value for _ is that of the left side value, hence {_} is not needed.
+     Semicolon has the lowest precedence, so it must be used inside  ()  or
+     {} for compound expressions. The precedence of `=>' is just below `,'.
+     Beware that "if(a) x; else {y;} z" is  illegal;  a  semicolon  is  not
+     allowed before '}' or 'else' and must be inserted before z.
+
+     _x->_y   _x._y
+
+     These expression work as in C for a symbol y. If y is  an  expression,
+     it  is  evaluated  under  the  scope of x. e.g. x.(a+b) is the same as
+     x.a+x.b, if a and b are field of x (if they are not, they  are  looked
+     up  as  local  or  global  variables). x may return multiple values of
+     different types, e.g. (u,v).a returns u.a and v.a, even if u and v are
+     different structures.  Also, the value of x is available as `_' inside
+     y, e.g. x[..100].(if(a) _) produces x[i] for  each  x[i].a!=0.  Nested
+     x.y are allowed, e.g.  u.(v.(a+b)) would lookup a and b first under v,
+     then under u.
+
+     AAAAlllliiiiaaaasssseeeessss::::  _x:=_y
+
+     Aliases store a reference to y in  x.  Any  reference  to  x  is  then
+     replaced  by y. If y is a constant or an rvalue, its value is replaced
+     for x. If y is an lvalue (e.g. a variable), a reference to same lvalue
+     is  returned.  for  example,  x:=emp[5]  ;  x=9  assigns  9 to emp[5].
+     Aliases retain their values across invocation of the "dl" command.  An
+     alias  to  a  local  variable  will reference a stray address when the
+     variable goes out of scope.  The special command "dl clear" delete all
+     the  aliases,  and  "dl  alias"  show all current aliases. Symbols are
+     looked up as aliases first, so an alias x will hide a local x.
+
+     _x-->_y
+
+     The expansion operator x-->y expands a data structure x following  the
+     y  links.  It returns x, x->y, x->y->y, until a null is found. If x is
+     null, no values are produced. If y returns multiple values,  they  are
+     stacked  and  each  is  further  expanded in a depth-first notion. For
+     example, if r is the root  of  a  tree  with  children  u->childs[..u-
+     >nchilds],  then  u-->(childs[..nchilds]) expands the whole tree. y is
+     an arbitrary expression, evaluated exactly like  x->y  (this  includes
+     `_'.)
+
+     _x@_y
+
+     The expression x@y produces the values of x  until  x.y  is  non-zero,
+     e.g.   for(i=0 ; x[i].code!= -1 && i<100 ; i++) x[i] can be written as
+     x[..100]@(code==-1). The evaluation of x  is  stopped  as  soon  as  y
+     evaluates to true. x->y or x=>y are used to evaluate y when x is not a
+     struct or a union. If y is a constant,(_==y) is  used.  e.g.  s[0..]@0
+     produces  the  characters  in  string  s  up  to but not including the
+     terminating null.
+
+     #/_x   &&/_x   ||/_x
+
+     These operator return a single "summary"  value  for  all  the  values
+     returned  by  x.  #/x returns the number of values returned by x, e.g.
+     #/(x[..100]>?0) counts the number of positive x[i]. &&/x returns 1  if
+     all  the  values produced by x are non-zero, and ||/x returns 1 if any
+     of x's values are non-zero. Like in C, the evaluation stops as soon as
+     possible.  For example, ||/(x[..100]==0) and &&/(x[..100]==0) check if
+     one or all of x[i] are zero, respectively.
+
+     _x#_y  _x[[_y]]
+
+     The operator x#y produces the values of x and arranges for y to be  an
+     alias for the index of each value in x. It is commonly used with x-->y
+     to produce the element's  index,  e.g.  head-->next->val#i=i   assigns
+     each val field its element number in the list.
+     The selection operator x[[y]] produces the  yth  result  of  x.  If  y
+     returns   multiple   value,   each   select   a   value   of  x,  e.g.
+     (5,7,11,13)[3,0,2] returns 13, 5 and 11 (13 is the 3rd element,  5  is
+     the  0th  element).  Don't use side effects in x, since its evaluation
+     can be restarted depending on y,  e.g.  after  (x[0..i++])[[3,5]]  the
+     value of i is unpredictable.
+
+     _f_r_a_m_e(_n)   _f_r_a_m_e_s__n_o   _f_u_n_c._x
+
+     frame(n) for an integer n returns a reference to the nth frame on  the
+     stack (0 is the inner most function and frame(frames_no-1) is main()).
+     Frame  values   can   be   compared   to   function   pointers,   e.g.
+     frame(3)==myfunc  is true if the 4th frame is a call to myfunc, and in
+     scope resolution, e.g. frame(3).x return the local variable x  of  the
+     4th  frame.   frames_no  is  the number of active frames on the stack,
+     e.g. (frames(..frames_no) ==? myfunc).x  displays  x  for  all  active
+     invocations      of      myfunc.      As      a      special     case,
+     (frames(..frames_no)==?f)[[0]].x can be written as f.x (x  can  be  an
+     expression).
+
+
+     BBBBUUUUGGGGSSSS
+     Both  `{}'  and  `;'  are  operators,  not  statements  or  expression
+     separators; "if(x) y; else {z;} u" is illegal; use "if(x) y else {z} ;
+     u". Ambiguities require preceding user-defined  types  (typedef)  with
+     the keyword T, e.g., if value is a user type, C's "sizeof(value*)"  is
+     written "sizeof(T value*)", except for the casts "(t)x"  and  "(t*)x";
+     sizeof(x) requires parenthesis for variable x.
+
+     Unimplemented C idiom  include:  modified-assignment  (x+=y),  switch,
+     break, continue, do, goto, scopes, function declarations, initializing
+     declared variables, assignment to bit-fields and  register  variables,
+     and  calling  functions with a struct/union parameter or return value.
+     gdb does not store function prototypes, so parameters are not checked.
+
+     Gdb itself is buggy, which shows up, especially in symbol  tables  and
+     calling target functions. Before you report bug, try to do the closest
+     thing under gdb's "print". Send bug to: mg@××××××××××××.edu.
+
+     FFFFIIIILLLLEEEESSSS
+     duel.out tracks duel  commands  usage.  Help  analyze  duel's  use  by
+     mailing a copy to mg@××××××××××××.edu.
+     Duel is available by anonymous ftp at ftp.cs.princeton.edu:/duel.
+
+     AAAAUUUUTTTTHHHHOOOORRRR
+     Duel is public domain code -- no copy left or right. See the internals
+     documentation  for  details  on porting Duel and using its code.  Duel
+     was designed and written by Michael Golan as part of a PhD  thesis  in
+     the Computer Science Department of Princeton University.  I would like
+     to thank my advisor, Dave Hanson, who helped in  all  phases  of  this
+     project and to Matt Blaze for his support and useful insight.
+
+     Duel stands for Debugging U (might)  Even  Like,  or  Don't  Use  this
+     Exotic Language. Judge for yourself!
--- gdb/duel/Makefile
+++ gdb/duel/Makefile
@@ -0,0 +1,44 @@
+#
+# generic makefile for Duel 1.10
+# nothing fancy is required: yacc/bison of parse.y, compile all other modules,
+# and put all of the OBJ= modules into duel.a library.
+# gdb is compiled with its own makefile (you add duel.a and duelgdb.c)
+# selfduel, for testing, is compiled and linked with duel.a
+
+# NOTE:
+# for sunOS4.x you must use gcc or another ANSI compiler. cc doesnt
+# support prototypes! 
+# Also for sunOS4.x, yacc inserts a declaration of malloc() at the first line
+# of y.tab.c, which is WRONG (return char*). just delete it.
+
+CFLAGS= -g
+CC= cc 			# won't work on sunOS. need ANSI C prototypes support.
+#CC= gcc 
+YACC=yacc
+RANLIB=ranlib		# for BSD-derived systems
+
+#CC = gcc -U__GNUC__	#ONLY if you get __eprintf undefined (assert.h problem)
+#RANLIB=echo		# for System V, there is no 'ranlib' 
+
+OBJ= duel.o types.o eval.o misc.o y.tab.o error.o evalops.o print.o
+
+all:	duel.a duelself
+
+duelself: duel.a duelself.o output.o
+	$(CC) duelself.o duel.a output.o -o duelself
+
+duel.a:  $(OBJ)
+	ar ru duel.a $(OBJ)
+	$(RANLIB) duel.a
+
+y.tab.c: parse.y
+	$(YACC) parse.y
+clean:
+	rm -f $(OBJ) y.tab.c duelself.o duelself duel.a
+
+install:
+
+test:	duelself
+	duelself <tsuite.self >self.out
+	@echo NOTE: diffs of the @xxxx values are ok
+	diff tsuite.self.out self.out
--- gdb/duel/README
+++ gdb/duel/README
@@ -0,0 +1,57 @@
+-------------------------------------------------------------------------------
+README for DUEL 1.10 distribution   mg@××××××××××××.edu (M. Golan) Mar 93
+-------------------------------------------------------------------------------
+see WHATNEW for what's new in version 1.10. 
+
+DUEL -  A high level language for debugging C programs.
+
+  Duel is a special purpose language designed for concise state 
+  exploration of debugged C programs under existing debuggers.
+  It allows you to explore your program's state better than either 
+  the debugger's commands, a C interpreter, or print statements
+  added to your programs. The debugger is extended with the new 
+  'dl' command for Duel expressions, e.g.,
+
+     gdb> dl x[0..10].level >? 5
+     x[3].level = 14
+     x[8].level = 6
+
+  prints the "level" fields of array elements x[0] to x[10] that are greater 
+  than 5.  The output includes the values 14 and 6, as well as their 
+  symbolic representation "x[3].level" and "x[8].level". Linked list and
+  other complex data structures are just as easy. Most of C (e.g. for, if)
+  is also supported, e.g., int i; for(i=0; i<11; i++) if(x[i].level>5) x[i].
+
+Even if you don't normally use debuggers, but you are programming in C, give
+Duel a try! The man page & help even include a summary of useful gdb commands.
+The man page (duel.1) contains an introduction & many examples.
+
+Duel is debugger-independent, but the current distribution interface only
+with gdb. You will need the source for gdb-4.6, 4.7 or 4.8. Duel is public 
+domain code. Do whatever you like with it - add it to commercial debuggers, 
+to dbx/sdb or even make it part of the GNU project. 
+
+NO PART OF THIS DISTRIBUTION CONTAINS ANY COPYRIGHT OR DERIVED CODE,
+(i.e. no GPL code, either). Free and public domain code need no disclaimer, 
+which is obvious to anyone in the software business.
+
+Duel is available for anonymous ftp from ftp.cs.princeton.edu, in 
+/duel/duel.tar.Z. "tar.Z" format means you should use the command
+ "zcat duel.tar.Z | tar xf -" to unpack the files.
+
+The Usenix Jan/93 paper about Duel is also available as tech report 399,
+in /reports/1992/399.ps.Z on ftp.cs.princeton.edu, or, in it Usenix
+formatting, as /duel/usenix.paper.ps.Z. The software & man page are more
+up-to-date though.
+
+See MANIFEST for a list of files in the distribution. The file INSTALL
+explains how to install duel. MANUAL is a formatted version of the manual 
+duel.1.
+
+If you are using duel and find it useful, or have any comments or suggestion,
+please drop me a line! duel.out is automatically produced to contain
+the dl commands you have used, I would appreciate it if you email it to
+me so that I could collect usage information. Thanks!
+
+Michael Golan
+mg@××××××××××××.edu
--- gdb/duel/WHATNEW
+++ gdb/duel/WHATNEW
@@ -0,0 +1,38 @@
+-------------------------------------------------------------------------------
+WHATNEW for DUEL 1.10 distribution   mg@××××××××××××.edu (M. Golan) Mar 93
+-------------------------------------------------------------------------------
+patch 1.10.4 fix use of system("date") to support OS/2 
+patch 1.10.3 bug fix left->left bad symbolic, long symbolics caused crash
+patch 1.10.2 bug fix (type*) casting was wrong
+patch 1.10.1 bug fix frame(0).bad_name crashed duel. enum size zero,
+	     sometimes possible in symbol tables, now allowed.
+
+What's New in version 1.10 
+--------------------------
+Previously, all typedefs had to be preceded with 'T', e.g. (T uint) x.
+The parsing is now hacked, so that the most common cases don't require T:
+(type)x and (type*)x, e.g., (uint)x, *(value *)p. T is still required in 
+complex casts like (T value (*)())p, in variable declaration "T uint x ;" 
+and with sizeof(T uint). Side effects of this change:  (printf)("hi\n") 
+won't work, since (printf) is recognized as a cast. This shouldn't be a 
+problem - you can use {x} for (x). Also, "sizeof x" is no longer supported, 
+you must use sizeof(x) instead.
+
+An experimental output control through a pipe has been added. To try it,
+you should change duel/src/Makefile to compile output2.o instead of output.o
+(delete duel.a to make sure it won't have both output.o and output2.o).
+When output2.o is linked into duelself and/or gdb, duel fork and execute
+the command duel.pipe in the current directory. All the output from expression
+evaluation is sent to this program and its output is displayed. An example 
+duel.pipe, a Perl script, is provided. A lot that can be done with duel.pipe 
+to process the results symbolically, e.g., display integers in decimal, 
+place values on the same line, fork and execute xgraph, check
+for unique values, etc. I would appreciate any comments on its use.
+
+A few minor bugs have been fixed. duel.man now contains a nicely formatted
+version of duel.1. Portability was improved. #/(x) provide a better symbolic
+expression.
+
+What's new in version 1.02
+--------------------------
+a few bug fixed, improved portability, gdb4.8 support.
--- gdb/duel/duel.1
+++ gdb/duel/duel.1
@@ -0,0 +1,547 @@
+'\" t
+.\" This document and the Duel source code are in the public domain.
+.\" Note that the duel executable contains GNU code and is not public domain.
+.TH Duel 1 "Mar 93" "Version 1.10" 
+.SH NAME
+duel \- A high level C debugging language extension to gdb
+.SH SYNOPSIS
+.B duel 
+[gdb options] 
+.RB "[\|" \c
+.I prog\c
+.RB "[\|" \c
+.IR core \||\| procID\c
+\&\|]\&\|]
+.ad b
+.SH DESCRIPTION
+Duel is a special purpose language designed for concise state exploration 
+of debugged C programs, currently implemented under the GNU debugger
+.IR gdb (1).
+Duel is invoked by entering the shell command 
+.I duel 
+instead of 
+.I gdb.
+It is identical to gdb except for 
+comments, which begin with `##' instead of `#', and the new
+.I dl
+command for Duel expressions:
+.nf
+
+\f2gdb>\f1 dl x[1..10] >? 5
+x[3] = 14
+x[8] = 6
+
+.fi
+prints the array elements x[1] to x[10] that are greater than 5. 
+The output includes the values 14 and 6, as well as their
+symbolic representation "x[3]" and "x[8]".
+.SH IF YOU NEVER USED GDB
+The improved functionality added by Duel merits a fresh look
+even by debugger shunners.
+Gdb is a powerful debugger with many commands, a thick manual and 
+various interfaces including 
+.IR emacs (1) 
+and 
+.IR xxgdb (1). 
+These gdb commands should help you get started:
+
+.TS
+l l.
+\f2b line\f1	set a breakpoint at the line (b func to break at a function)
+\f2d n\f1	delete breakpoint number n (gdb prints n when bp occurs)
+\f2l line\f1	list the source beginning at line (l file.c:line for module)
+\f2r parm\f1	run/restart the program with the given parameters
+\f2s\f1	single-step to the next statement (steps into function calls)
+\f2n\f1	single-step to the next line, skipping over function calls
+\f2c\f1	continue execution 
+\f2bt\f1	show a stack trace
+\f2p exp\f1	evaluate a symbolic expression
+\f2dl exp\f1	evaluate a Duel expression
+\f2dl gdb\f1	give a gdb command summary
+.TE
+
+The most common use is `b func' followed by `r' followed by several 
+`n' and `s', evaluating expressions in between. 
+.SH DUEL QUICK START
+Duel is implemented by adding the 
+.I dl 
+command to gdb. All gdb commands
+work as before. The dl command, however, is interpreted by duel.
+Gdb concepts (such as the value history) do not work in the dl command,
+and duel concepts are not understood by other gdb command.
+
+Duel is based on expressions which return multiple values.
+The x..y operator returns
+the integers from x to y; the x,y operator returns x and then y, e.g.
+.sp
+\f2gdb>\f1 dl (1,9,12..15,22)
+.sp
+prints 1, 9, 12, 13, 14, 15 and 22. Such expressions can
+be used wherever a single value is used, e.g.
+.sp
+\f2gdb>\f1 dl x[0..99]=0 ;
+.sp
+assigns zero to the first 100 elements of array x. The semantics of x[i]
+are the same as in C. They are applied for each of the values
+returned by 0..99, which can be thought of as an implied external loop.
+The trailing semicolon indicates evaluation for side-effects only, with no 
+output. 
+Duel incorporates C operators, casts C statements as
+expressions, and supports limited  variable declaration:
+.sp
+.br
+\f2gdb>\f1 dl int i;for(i=0;i<100;i++) 
+.br
+                 if(x[i]<0) printf("x[%d]=%d\\n",i,x[i]); 
+.br
+x[7] = -4
+.sp
+The semicolon prevents Duel output;
+only output from printf is printed.
+Aliases are defined with x:=y and provide an alternative to variable 
+declaration. We could also return x[i] instead of using printf:
+.sp
+\f2gdb>\f1 dl if(x[i:=0..99]<0) x[i]
+.br
+x[i] = -4
+.sp
+The symbolic output "x[i]" can be fixed by surrounding i with {}, i.e.
+.sp
+\f2gdb>\f1 dl if(x[i:=0..99]<0) x[{i}]
+.br
+x[7] = -4
+.sp
+The {} are like (), but force the symbolic evaluation to use i's value, 
+instead of "i". You can usually avoid this altogether
+with direct Duel operators:
+.sp
+\f2gdb>\f1 dl x[..100] <? 0
+.br
+x[7] = -4
+.sp
+The ..n operator is a shorthand for 0..n-1, i.e. ..100 is the same as 0..99.
+The x<?y, x==?y, x>=?y, etc., operators compare their left side operand to
+their right side operand as in C, but return the left side value if
+the comparison result is true. Otherwise, they look for the next
+values to compare, without returning anything.
+
+Duel's x.y and x->y allow an expression y, evaluated under x's scope:
+.sp
+\f2gdb>\f1 dl emp[..100].(if(code>400) (code,name))
+.br
+emp[46].code = 682
+.br
+emp[46].name = "Ela"
+.sp
+The if() expression is evaluated under the scope of each element 
+of emp[], an array of structures. In C terms, we had to write:
+.sp
+\f2gdb>\f1 dl int i; for(i=0; i<100 ; i++) 
+.br
+	if(emp[i].code>400) emp[{i}].code,emp[{i}].name
+.sp
+A useful alternative to loops is the x=>y operator. It returns y for each
+value of x, setting `_' to reference x's value, e.g.
+.sp
+\f2gdb>\f1 ..100 => if(emp[_].code>400) emp[_].code,emp[_].name
+.sp
+Using `_' instead of `i' also avoids the need for {i}. Finally,
+the x\-\->y operator expands lists and other data structures. If head points
+to a linked list threaded through the next field, then:
+.sp
+\f2gdb>\f1 dl head-->next->data
+.br
+head->data = 12
+.br
+head->next->data = 14
+.br
+head-->next[[2]]->data = 20
+.br
+head-->next[[3]]->data = 26
+.sp
+produce the data field for each node in the list. x\-\->y
+returns x, x->y, x->y->y, x->y->y->y, ... until a NULL is found. 
+The symbolic output "x\-\->y[[n]]"
+indicates that ->y was applied n times. x[[y]] is also the selection
+operator:
+.sp
+\f2gdb>\f1 dl head-->next[[50..60]]->data
+.sp
+return the 50th through the 60th elements in the list. The #/x operator
+counts the number of values, so
+.sp
+\f2gdb>\f1 dl #/( head-->next->data >? 50 )
+.sp
+counts the number of data elements over 50 on the list.
+Several other operators, including x@y, x#y and 
+active call stack access are described in the operators section.
+.SH OPERATORS SUMMARY
+.\"All the C operators have the same precedence and associativity as in C. C
+.\"statements have precedence just below `,' and `;' has the lowest precedence. 
+.\"Most Duel operators have the same precedence as their C counterparts. The
+.\"following table is in decreasing precedence:
+.TS
+l l l.
+Assoc	Operators	Details
+left	{} () [] -> . f() -->	x-->y expands x->y x->y->y ...
+	x[[y]] x#y x@y	generate x; select, index or stop-at y
+right	#/ - * & ! ~ ++ -- (cast)	#/x number of x values
+	frame(n) sizeof(x)	reference to call stack level n
+left	x/y x*y x%y	multiply, divide, reminder
+left	x-y x+y	add, subtract
+left	x<<y x>>y	shift left/right
+none	x..y ..y x..	..y = 0..y-1. x..y return x, x+1...y
+left	< > <= >= <? >? <=? >=?	x>?y return x if x>y
+left	== != ==? !=?	x==?y return x if x==y
+left	x&y	bit-and
+left	x^y	bit-xor
+left	x|y	bit-or
+left	x&&y &&/x	&&/x are all x values non-zero?
+left	x||y ||/x	||/x is any x value non-zero?
+right	x? y:z	foreach x, if(x) y else z
+right	x:=y x=y x+=y ...	x:=y set x as an alias to y
+left	x,y	return x, then y
+right	x=>y	foreach x, evaluate y with x value `_'
+right	if() else  while()  for()	C statements cast as operators
+left	x;y	evaluate and ignore x, return y
+.TE
+
+.SH EXAMPLES
+.TS
+l l.
+dl (0xff-0x12)*3	compute simple expression
+dl (1..10)*(1..10)	display multiplication table
+dl x[10..20,22,24,40..60]	display x[i] for the selected indexes
+dl x[9..0]	display x[i] backwards
+dl x[..100] >? 5	display x[i] that are greater than 5
+dl x[..100] >? 5 <? 10	display x[i] if 5<x[i]<10
+dl x[..100] ==? (6..9)	same
+dl x[0..99]=>if(_>5 && _<10) _	same
+dl y[x[..100] !=? 0]	display y[x[i]] for each non-zero x[i]
+dl emp[..50].code	display emp[i].code for i=0 to 49
+dl emp[..50].(code,name)	display emp[i].code & emp[i].name
+dl val[..50].(is_dbl? x:y)	display val[i].x or val[i].y depending 
+ 	on val[i].is_dbl. 
+dl val[..50].if(is_dbl) x else y	same as above
+dl x[..100]=0 ;	assign 0 to x[i]
+dl x[i:=..100]=y[i] ;	assign y[i] to x[i]
+dl x[..100]=y[..100] *ERR*	assign y[99] to each x[j]
+dl x[i:=..3]=(4,5,9)[[i]]	assign x[0]=4 x[1]=5 x[2]=9
+dl x[..3]=(4,5,9)    *ERR*	assign 9 to each element
+dl if(x[i:=..100]<0) x[i]=0 ;	assign 0 to negative x[i]
+dl (hash[..1024]!=?0)->scope	hash[i].scope for non-null hash[i]
+dl x[i:=..100] >? x[i+1]	check if x[i] is not sorted
+dl x[i:=..100] ==? x[j:=..100]=>	checks if x has non-unique elements
+   if(i<j) x[{i,j}]	
+dl if(x[i:=..99] == 	same
+   x[j:=i+1..99]) x[{i,j}]
+dl (x[..100] >? 0)[[0]]	the 1st (0th element) positive x[i] 
+dl (x[..100] >? 0)[[2]]	return the 3rd positive x[i] 
+dl (x[..100] >? 0)[[..5]]	return the first 5 positive x[i]
+dl (x[0..] >? 6)[[0]]	return the first x[i]>6, no limit on i
+dl argv[0..]@0	argv[0] argv[1] .. until first null
+dl x[0..]@-1 >? 9	x[0..n]>9 where n is first x[n]== -1
+dl emp[0..]@(code==0)	emp[0]..emp[n-1] where emp[n].code==0
+
+dl head-->next->val	val of each element in a linked list
+dl head-->next[[20]]	the 21st element of a linked list
+dl *head-->next[[20]]	display above as a struct
+dl strcmp(head-->next->msg,	search linked list for a string
+     "testing") ==? 0
+dl #/head-->next	count elements on a linked list
+dl x-->y[[#/x-->y - 1]]	last element of a linked list
+dl x-->y[[#/x-->y - 10..1]]	last 10 elements of a linked list
+dl head-->next->	check if the list is sorted by val
+   if(next) val >? next->val
+
+dl head-->(next!=?head)	expand cyclic linked list (tail->head)
+dl head-->(next!=?_)	handle termination with p->next==p 
+dl root-->(left,right)->key	expand binary tree, show keys
+dl root-->(left,right)->( 	check bin tree sorted by key
+   (left!=?0)->key>=?key, (right	!=?0 )->key<=?key)
+
+dl (1000..=>if(&&/(2,3.._-1=>__%_	find first 10 primes over 1000
+           ) _)[[..10]]
+dl (T mytype) x	convert x to user defined type mytype
+dl (struct s*) x	convert x to struct s pointer
+dl if(x) y; else z *ERR*	';' must be followed by an expression
+dl {x} y *ERR*	'}' requires ';' if followed by exp
+.TE
+.SH SEMANTICS
+Duel's semantics are modeled after the Icon programming language.
+The input consists of expressions which return sequences of values. 
+C statements are cast as expressions, too. 
+Expressions are parsed into abstract syntax trees, which are
+traversed during evaluation. The evaluation of most nodes (operators)
+recursively evaluates the next value for each operand, and then applies the
+operator to produce the next result. Only one value is produced each time,
+and Duel's eval function keeps a `state' for each node 
+(backtracking, co-routines, consumer-producer or threads are good metaphors 
+for the evaluation mechanism.)
+
+For example, in (5,3)+6..8, the 
+evaluation of `+' first retrieves the operands 5 and 6, to compute and
+return 5+6. Then 7, the next right operand is retrieved
+and 5+7 is returned, followed by 5+8.
+Since there are no other right operand value, the next left operand, 3
+is fetched. The right operand's computation is restarted returning
+6, and 3+6 is returned. The final return values are 3+7 and 3+8.
+
+The computation for operators like x>?y is similar, but when x<=y,
+the next values are fetched instead of returning a value,
+forming the basis for an implicit search. Operators like `..' return a 
+sequence of values for each pair of operands. For a better understanding
+of the evaluation mechanism, see the USENIX Winter/93 conference paper
+"DUEL - A Very High Level Debugging Language".
+
+Duel values follow the C semantics. A value is either an
+"lvalue" (can be used as the left hand side of assignment), or an "rvalue".
+Therefor, objects like arrays can not be directly manipulated (However,
+operators like x..y can accomplish such tasks.)
+
+Duel types also follow the C semantics, with some important
+differences. C types are checked  statically; Duel types are checked 
+when operators are applied, e.g., (1,1.0)/2 returns 0 (int) and 
+0.5 (double); (x,y).z returns x.z and y.z even if 
+x and y are of different types, as long as they both have a field z.
+
+Values and types of symbols are looked up at run-time (using gdb's lookup
+rules), allowing dynamic scoping and types, but causing a parsing
+problem: (x)(y) can be parsed as either a function call x(y) or a 
+cast (x)y; x*y can be parsed as a declaration of y as (x*) or as 
+multiplication. 
+
+To avoid this ambiguity, the
+keyword T must precede a user defined type. For example,
+if value is a typedef, C's (value (*)()) x is written in Duel as:
+(T value (*)()) x. Types that begin with a reserved keyword don't
+need T, e.g. (struct value*) x and (long *[5]) y are accepted.
+As special cases, (type)x and (type*)x are accepted but 
+discouraged (it causes (printf)("hi"), which is valid in C, to fail).
+A side effect is that "sizeof x" must be written as sizeof(x).
+.SH OPERATORS
+.sp
+.I "x+y  x-y  x*y  x/y  x%y  x^y  x|y  x&y  x<<y  x>>y "
+.br
+.I "x>y  x<y  x>=y  x<=y  x==y  x!=y  x=y  x[y]"
+.sp
+These binary operators follow their C semantics. For each value of x,
+they are evaluated for every value of y, .e.g. (5,2)>(4,1)
+evaluates as 5>4, 5>1, 2>4, 2>1 returning  1, 1, 0, 1.
+The y values are re-evaluated for each new value of x, e.g. 
+i=4; (4,5)>i++ evaluates as 4>4 and 5>5.
+Beware of multiple y values in assignment, e.g. x[..3]=(4,6,9) does not
+set x[0]=4, x[1]=6 and x[2]=9. It assigns 4, 6 and 9 to each element, having
+the same effect as x[..3]=9. Use x[i:=..3]=(4,6,9)[[i]] to achieve the
+desired effect.
+.sp
+.I "-x  ~x  &x  *x  !x  ++x  --x  x++  x--  sizeof(x)  (type)x"
+.sp
+These unary operators follow their C semantics. They are applied
+to each value of x. The increment and decrement operators require an
+lvalue, so i:=0 ; i++ produces an error because i is an alias to 0, 
+an rvalue. Parenthesis must be used with sizeof(x), "sizeof x" is not 
+allowed. Cast to user defined type requires generally requires T, e.g.,
+ (T val(*)())x, but (val)x and (val*)x are accepted as special cases.
+.sp
+.I "x&&y   x||y"
+.sp
+These logical operators also follow their C semantics, but have non-intuitive
+results for multi-valued x and y, e.g. (1,0,0) || (1,0) returns 1,1,0,1,0 --
+the right hand-side (1,0) is returned for each left-hand side 0. It is best
+to use these operators only in single value expressions.
+.sp
+.I "x? y:z   if(x)y   if(x)y else z"
+.sp
+These expressions return the values of y for each non-zero value
+returned by x, and the values of z for each zero value returned by x, e.g. 
+if(x[..100]==0) y returns y for every x[i]==0, not if all x[i] are zero 
+(if(&&/(x[..100]==0)) y  does that).
+Also, "if(x) y; else z" is illegal. Duel's semicolon is
+an expression separator, not a terminator.
+.sp
+.I "while(x)y   for(w;x;y)z"
+.sp
+The while(x)y expression returns y as long as all values of x are non-zero.
+The for() expression is similar and both have the expected C semantics. For
+example, "for(i=0 ; i<100 ; i++) x[i]" is the same as x[..100]. Unlike
+the if() expression, while(x[..100]==0) continue to execute only if all 
+elements of x are zero, i.e. the condition is evaluated into a single value
+using an implicit &&/x.
+.sp
+.BI "Variable declaration:  "  "type name [,name ...] ; ..."
+.sp
+Expressions can begin with variables declaration (but not initialization).
+Internally, a declaration sets an alias to space allocated 
+in the target by calling malloc(), e.g. `int x' is the same as
+"x:= *(int *) malloc(sizeof(int))". This is oblivious to the user.
+The allocated memory is not claimed when a variable is redeclared. 
+Declared variables addresses can be passed to functions and used in other 
+data structures. The keyword `T' must precede user defined types (typedef),
+e.g. if val is a user defined type, The C code "val *p=(val*) x" becomes 
+"T val *p; p=(T val *) x" in Duel.
+.sp
+.BI "Function calls:  "  "func(parm,...)"
+.sp
+Function calls to the debugged program can be intermixed with Duel 
+code. Multi-valued parameters are handled as with binary operators.
+The call value can have multiple values, e.g. (x,y)() calls x()
+and y(). Currently, struct/union parameters and return values are not
+supported.
+.sp
+.I "x,y   x..y   ..x    x.."
+.sp
+These operators produce multiple values for single value operands. 
+x,y returns x, then y. x..y returns the integers from x to y. 
+When x>y the sequence is returned in descending order, i.e. 5..3 
+returns 5, 4, 3. 
+The operator ..x is a shorthand for 0..x-1, e.g. ..3 returns 0, 1, 2. 
+The x.. operator is a shorthand for x..maxint. It returns increasing 
+integer values starting at x indefinitely, and should be bounded 
+by [[n]] or @n operators.
+`,' retains its precedence level in C. The precedence of `..'
+is above `<' and below arithmetic operators, so 0..n-1 and x==1..9 work
+as expected.
+.sp
+.I  "x<?y  x>?y  x>=?y  x<=?y  x!=?y  x==?y"
+.sp
+These operators work like their C counterparts but return x if the comparison
+is true. If the comparison is false, the next (x,y) value is tried, forming
+the basis of an implicit search.
+.sp
+.I  "(x)  {x}  x;y  x=>y"
+.sp
+Both () and {} act as C parenthesis. 
+The curly braces set the returned symbolic value 
+as the actual value, e.g. if i=5 and x[5]=3, then
+x[i] produces the output "x[i] = 3", x[{i}] produces
+"x[5] = 3" and {x[i]} produces just "3". 
+The semicolon is an operator. x;y evaluates x, ignoring the results, 
+then evaluate and return y, e.g. (i:=1..3 ; i+5) sets i to 3 and return 8. 
+The x=>y operator evaluate and return y for each value of x, 
+e.g. (i:=1..3 => i+5) returns 6, 7 and 8. The value returned by x is
+also stored implicitly in `_' which can be used in y, e.g. 1..5 => z[_][_]
+will output z[1][1], z[2][2] etc. The symbolic value for _ is that of the
+left side value, hence {_} is not needed.
+.br
+Semicolon has the lowest precedence, so it must be used inside () or {}
+for compound expressions. The precedence of `=>' is just below `,'.
+Beware that "if(a) x; else {y;} z" is illegal; a semicolon is not allowed
+before '}' or 'else' and must be inserted before z.
+.sp
+.IB "x->y   x.y"
+.sp
+These expression work as in C for a symbol y. If y is an expression, it
+is evaluated under the scope of x. e.g. x.(a+b) is the same as x.a+x.b,
+if a and b are field of x (if they are not, they are looked up as local
+or global variables). x may return multiple values of different types,
+e.g. (u,v).a returns u.a and v.a, even if u and v are different structures.
+Also, the value of x is available as `_' inside y, e.g. x[..100].(if(a) _) 
+produces x[i] for each x[i].a!=0. Nested x.y are allowed, e.g.
+u.(v.(a+b)) would lookup a and b first under v, then under u.
+.sp
+.BI Aliases: "  x:=y"
+.sp
+Aliases store a reference to y in x. Any reference to x is 
+then replaced by y. If y is a constant or an rvalue, its
+value is replaced for x. If y is an lvalue (e.g. a variable), a reference
+to same lvalue is returned. for example, x:=emp[5] ; x=9 assigns 9 to
+emp[5].
+Aliases retain their values across invocation of the "dl" command. An alias
+to a local variable will reference a stray address when the variable
+goes out of scope.
+The special command "dl clear" delete all the aliases, and "dl alias"
+show all current aliases. Symbols are looked up
+as aliases first, so an alias x will hide a local x.
+.sp
+.I x-->y
+.sp
+The expansion operator x-->y expands a data structure x following the y links.
+It returns x, x->y, x->y->y, until a null is found. If x is null, no values 
+are produced. If y returns multiple values, they are stacked and each is 
+further expanded in a depth-first notion. For example, if r is the root of 
+a tree with children u->childs[..u->nchilds], then
+u-->(childs[..nchilds]) expands the whole tree. y is an arbitrary
+expression, evaluated exactly like x->y (this includes `_'.)
+.sp
+.I x@y
+.sp
+The expression x@y produces the values of x until x.y is non-zero, e.g.
+for(i=0 ; x[i].code!= -1 && i<100 ; i++) x[i] can be written as 
+x[..100]@(code==-1). 
+The evaluation of x is stopped as soon as y evaluates to true. 
+x->y or x=>y are used to evaluate y when x is not a struct or a union. If
+y is a constant,(_==y) is used. e.g. s[0..]@0 produces the characters in 
+string s up to but not including the terminating null.
+.sp
+.IB "#/x   &&/x   ||/x"
+.sp
+These operator return a single "summary" value for all the values returned by
+x. #/x returns the number of values returned by x, e.g. 
+#/(x[..100]>?0) counts the number of positive x[i]. &&/x returns 1 if all 
+the values produced by x are non-zero, and ||/x returns 1 if any of x's values
+are non-zero. Like in C, the evaluation stops as soon as possible.
+For example, ||/(x[..100]==0) and &&/(x[..100]==0) check if one or all of
+x[i] are zero, respectively.
+.sp
+.IB "x#y  x[[y]]"
+.sp
+The operator x#y produces the values of x and arranges for y to be an alias 
+for the index of each value in x. It is commonly used with x-->y to produce
+the element's index, e.g. head-->next->val#i=i  assigns each val field
+its element number in the list.
+.br
+The selection operator x[[y]] produces the yth result of x. If y returns
+multiple value, each select a value of x, e.g. (5,7,11,13)[3,0,2]
+returns 13, 5 and 11 (13 is the 3rd element, 5 is the 0th element).
+Don't use side effects in x, since its evaluation can be restarted depending 
+on y, e.g. after (x[0..i++])[[3,5]] the value of i is unpredictable.
+.sp
+.IB "frame(n)   frames_no   func.x"
+.sp
+frame(n) for an integer n returns a reference to the nth frame
+on the stack (0 is the inner most function and frame(frames_no-1) is main()). 
+Frame values can be compared to function pointers, 
+e.g. frame(3)==myfunc is true if the 4th frame is a call to myfunc, and in 
+scope resolution, e.g. frame(3).x return the local variable x of the 4th frame.
+frames_no is the number of active frames on the stack, e.g. 
+(frames(..frames_no) ==? myfunc).x displays x for all active 
+invocations of myfunc. As a special case, (frames(..frames_no)==?f)[[0]].x 
+can be written as f.x (x can be an expression).
+.sp
+.SH BUGS
+Both `{}' and `;' are operators, not statements or expression separators;
+"if(x) y; else {z;} u" is illegal; use "if(x) y else {z} ; u". Ambiguities
+require preceding
+user-defined types (typedef) with the keyword T, e.g., if
+value is a user type, C's "sizeof(value*)"  is written 
+"sizeof(T value*)", except for the casts "(t)x" and "(t*)x"; sizeof(x) 
+requires parenthesis for variable x. 
+
+Unimplemented C idiom include: modified-assignment
+(x+=y), switch, break, continue, do, goto, scopes, function declarations, 
+initializing declared variables,
+assignment to bit-fields and register variables, and
+calling functions with a struct/union parameter or return value.
+gdb does not store function prototypes, so parameters are not checked.
+
+Gdb itself is buggy, which shows up, especially in symbol tables and 
+calling target functions. Before you report bug, try to do the closest 
+thing under gdb's "print". Send bug to: mg@××××××××××××.edu.
+.SH FILES
+duel.out tracks duel commands usage. Help analyze duel's use by mailing a
+copy to mg@××××××××××××.edu.
+.br
+Duel is available by anonymous ftp at ftp.cs.princeton.edu:/duel.
+.SH AUTHOR
+Duel is public domain code -- no copy left or right. See the internals
+documentation for details on porting Duel and using its code.
+Duel was designed and written by Michael Golan as part of a PhD thesis
+in the Computer Science Department of Princeton University.
+I would like to thank my advisor, Dave Hanson, who helped in all phases
+of this project and to Matt Blaze for his support and useful insight.
+.sp
+Duel stands for Debugging U (might) Even Like, or Don't Use this Exotic 
+Language. Judge for yourself!
+
+
--- gdb/duel/duel.c
+++ gdb/duel/duel.c
@@ -0,0 +1,692 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code                            */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* this module contains the entery point to duel - duel_eval_and_pasre.
+ */
+
+/*
+ * $Log: 10_all_gdb-6.6-duel.patch,v $
+ * Revision 1.1  2007/12/29 21:06:06  vapier
+ * add DUEL support #199987 by Sergei Golubchik
+ *
+ * Revision 1.11  93/03/13  04:03:07  mg
+ * moved VERSION to patchlevel.h
+ * 
+ * Revision 1.10  93/03/12  05:41:54  mg
+ * Version 1.10 - support (x)y cast, piped output.
+ * 
+ * Revision 1.9  93/02/23  19:09:35  mg
+ * new version 1.02 release (support gdb4.8)
+ * 
+ * Revision 1.8  93/02/03  21:56:33  mg
+ * version 1.01
+ * 
+ * Revision 1.7  93/01/12  21:28:44  mg
+ * cleanup and set for release
+ * 
+ * Revision 1.6  93/01/06  23:57:10  mg
+ * added alias, clear commands, new memory alloc/release
+ * 
+ * Revision 1.5  93/01/03  07:26:47  mg
+ * new printing setup
+ * 
+ * Revision 1.4  92/12/24  23:32:38  mg
+ * better struct support, misc changes
+ * 
+ * Revision 1.3  92/10/19  15:02:04  mg
+ * lcc happy, size zero arrays
+ * 
+ * Revision 1.2  92/10/14  02:03:15  mg
+ * misc
+ * 
+ */
+
+#include <setjmp.h>     
+#define DEF             /* define global variables */
+#include "duel.h"
+#include "patchlevel.h"
+
+static jmp_buf duel_abort_jmp ; /* abort current execution */
+static tnode *root ;            /* root of current eval node */
+
+
+/* abort evaluation of current expression */
+
+PROC duel_abort(void)
+{
+    longjmp(duel_abort_jmp,1);
+}
+
+PROC duel_cleanup(void *unused) /* cleanup malloc, etc, when duel eval ends*/
+{
+    duel_redirectable_output_abort();
+    duel_free_nodes(root);
+    root=NULL ;
+}
+
+LPROC longhelp(void)
+{
+        duel_printf(
+"Duel(1)                                                                Duel(1)\n\
+\n\
+NAME\n\
+       duel - A high level C debugging language extension to gdb\n\
+\n\
+DESCRIPTION\n\
+       Duel  is  a  special purpose language designed for concise state explo-\n\
+       ration of debugged C programs,  currently  implemented  under  the  GNU\n\
+       debugger  gdb(1).   Duel  is invoked by entering the shell command duel\n\
+       instead of gdb.  It is identical to  gdb  except  for  comments,  which\n\
+       begin with `##' instead of `#', and the new dl command for Duel expres-\n\
+       sions:\n\
+\n\
+       gdb> dl x[1..10] >? 5\n\
+       x[3] = 14\n\
+       x[8] = 6\n\
+\n\
+       prints the array elements x[1] to x[10] that are greater than  5.   The\n\
+       output  includes  the values 14 and 6, as well as their symbolic repre-\n\
+       sentation \"x[3]\" and \"x[8]\".\n\
+\n\
+DUEL QUICK START\n\
+       Duel is implemented by adding the dl command to gdb. All  gdb  commands\n\
+       work  as  before. The dl command, however, is interpreted by duel.  Gdb\n\
+       concepts (such as the value history) do not work in the dl command, and\n\
+       duel concepts are not understood by other gdb command.\n\
+\n\
+       Duel  is  based  on expressions which return multiple values.  The x..y\n\
+       operator returns the integers from x to y; the x,y operator  returns  x\n\
+       and then y, e.g.\n\
+\n\
+       gdb> dl (1,9,12..15,22)\n\
+\n\
+       prints  1, 9, 12, 13, 14, 15 and 22. Such expressions can be used wher-\n\
+       ever a single value is used, e.g.\n\
+\n\
+       gdb> dl x[0..99]=0 ;\n\
+\n\
+       assigns zero to the first 100 elements of array  x.  The  semantics  of\n\
+       x[i]  are  the  same  as  in C. They are applied for each of the values\n\
+       returned by 0..99, which can be thought of as an implied external loop.\n\
+       The trailing semicolon indicates evaluation for side-effects only, with\n\
+       no output.  Duel  incorporates  C  operators,  casts  C  statements  as\n\
+       expressions, and supports limited  variable declaration:\n\
+\n\
+       gdb> dl int i;for(i=0;i<100;i++)\n\
+                        if(x[i]<0) printf(\"x[%%d]=%%d\\n\",i,x[i]);\n\
+       x[7] = -4\n\
+\n\
+       The semicolon prevents Duel output; only output from printf is printed.\n\
+       Aliases are defined with x:=y and provide an  alternative  to  variable\n\
+       declaration. We could also return x[i] instead of using printf:\n\
+\n\
+       gdb> dl if(x[i:=0..99]<0) x[i]\n\
+       x[i] = -4\n\
+\n\
+       The  symbolic output \"x[i]\" can be fixed by surrounding i with {}, i.e.\n\
+\n\
+       gdb> dl if(x[i:=0..99]<0) x[{i}]\n\
+       x[7] = -4\n\
+\n\
+       The {} are like (), but force the symbolic evaluation to use i's value,\n\
+       instead  of \"i\". You can usually avoid this altogether with direct Duel\n\
+       operators:\n\
+\n\
+       gdb> dl x[..100] <? 0\n\
+       x[7] = -4\n\
+\n\
+       The ..n operator is a shorthand for 0..n-1, i.e. ..100 is the  same  as\n\
+       0..99.  The x<?y, x==?y, x>=?y, etc., operators compare their left side\n\
+       operand to their right side operand as in C, but return the  left  side\n\
+       value  if  the  comparison result is true. Otherwise, they look for the\n\
+       next values to compare, without returning anything.\n\
+\n\
+       Duel's x.y and x->y allow an expression y, evaluated under x's scope:\n\
+\n\
+       gdb> dl emp[..100].(if(code>400) (code,name))\n\
+       emp[46].code = 682\n\
+       emp[46].name = \"Ela\"\n\
+\n\
+       The if() expression is evaluated under the scope  of  each  element  of\n\
+       emp[], an array of structures. In C terms, we had to write:\n\
+\n\
+       gdb> dl int i; for(i=0; i<100 ; i++)\n\
+             if(emp[i].code>400) emp[{i}].code,emp[{i}].name\n\
+\n\
+       A  useful  alternative  to loops is the x=>y operator. It returns y for\n\
+       each value of x, setting `_' to reference x's value, e.g.\n\
+\n\
+       gdb> ..100 => if(emp[_].code>400) emp[_].code,emp[_].name\n\
+\n\
+       Using `_' instead of `i' also avoids the need  for  {i}.  Finally,  the\n\
+       x-->y  operator expands lists and other data structures. If head points\n\
+       to a linked list threaded through the next field, then:\n\
+\n\
+       gdb> dl head-->next->data\n\
+       head->data = 12\n\
+       head->next->data = 14\n\
+       head-->next[[2]]->data = 20\n\
+       head-->next[[3]]->data = 26\n\
+\n\
+       produce the data field for each node in  the  list.  x-->y  returns  x,\n\
+       x->y,  x->y->y,  x->y->y->y,  ...  until a NULL is found.  The symbolic\n\
+       output \"x-->y[[n]]\" indicates that ->y was applied n times.  x[[y]]  is\n\
+       also the selection operator:\n\
+\n\
+       gdb> dl head-->next[[50..60]]->data\n\
+\n\
+       return the 50th through the 60th elements in the list. The #/x operator\n\
+       counts the number of values, so\n\
+\n\
+       gdb> dl #/( head-->next->data >? 50 )\n\
+\n\
+       counts the number of data elements over 50 on the list.  Several  other\n\
+       operators,  including  x@y,  x#y  and  active  call  stack  access  are\n\
+       described in the operators section.\n\
+\n\
+OPERATORS SUMMARY\n\
+       Assoc   Operators                   Details\n\
+       left    {} () [] -> . f() -->       x-->y expands x->y x->y->y ...\n\
+               x[[y]] x#y x@y              generate x; select, index or stop-at y\n\
+       right   #/ - * & ! ~ ++ -- (cast)   #/x number of x values\n\
+               frame(n) sizeof(x)          reference to call stack level n\n\
+       left    x/y x*y x%%y                 multiply, divide, reminder\n\
+       left    x-y x+y                     add, subtract\n\
+       left    x<<y x>>y                   shift left/right\n\
+       none    x..y ..y x..                ..y = 0..y-1. x..y return x, x+1...y\n\
+       left    < > <= >= <? >? <=? >=?     x>?y return x if x>y\n\
+       left    == != ==? !=?               x==?y return x if x==y\n\
+       left    x&y                         bit-and\n\
+       left    x^y                         bit-xor\n\
+       left    x|y                         bit-or\n\
+       left    x&&y &&/x                   &&/x are all x values non-zero?\n\
+       left    x||y ||/x                   ||/x is any x value non-zero?\n\
+       right   x? y:z                      foreach x, if(x) y else z\n\
+       right   x:=y x=y x+=y ...           x:=y set x as an alias to y\n\
+       left    x,y                         return x, then y\n\
+       right   x=>y                        foreach x, evaluate y with x value `_'\n\
+       right   if() else  while()  for()   C statements cast as operators\n\
+       left    x;y                         evaluate and ignore x, return y\n\
+\n\
+\n\
+EXAMPLES\n\
+       dl (0xff-0x12)*3                    compute simple expression\n\
+       dl (1..10)*(1..10)                  display multiplication table\n\
+       dl x[10..20,22,24,40..60]           display x[i] for the selected indexes\n\
+       dl x[9..0]                          display x[i] backwards\n\
+       dl x[..100] >? 5                    display x[i] that are greater than 5\n\
+       dl x[..100] >? 5 <? 10              display x[i] if 5<x[i]<10\n\
+       dl x[..100] ==? (6..9)              same\n\
+       dl x[0..99]=>if(_>5 && _<10) _      same\n\
+       dl y[x[..100] !=? 0]                display y[x[i]] for each non-zero x[i]\n\
+       dl emp[..50].code                   display emp[i].code for i=0 to 49\n\
+       dl emp[..50].(code,name)            display emp[i].code & emp[i].name\n\
+       dl val[..50].(is_dbl? x:y)          display val[i].x or val[i].y depending\n\
+                                           on val[i].is_dbl.\n\
+       dl val[..50].if(is_dbl) x else y    same as above\n\
+       dl x[..100]=0 ;                     assign 0 to x[i]\n\
+       dl x[i:=..100]=y[i] ;               assign y[i] to x[i]\n\
+       dl x[..100]=y[..100] *ERR*          assign y[99] to each x[j]\n\
+       dl x[i:=..3]=(4,5,9)[[i]]           assign x[0]=4 x[1]=5 x[2]=9\n\
+       dl x[..3]=(4,5,9)    *ERR*          assign 9 to each element\n\
+       dl if(x[i:=..100]<0) x[i]=0 ;       assign 0 to negative x[i]\n\
+       dl (hash[..1024]!=?0)->scope        hash[i].scope for non-null hash[i]\n\
+       dl x[i:=..100] >? x[i+1]            check if x[i] is not sorted\n\
+       dl x[i:=..100] ==? x[j:=..100]=>    checks if x has non-unique elements\n\
+          if(i<j) x[{i,j}]\n\
+       dl if(x[i:=..99] ==                 same\n\
+          x[j:=i+1..99]) x[{i,j}]\n\
+       dl (x[..100] >? 0)[[0]]             the 1st (0th element) positive x[i]\n\
+\n\
+       dl (x[..100] >? 0)[[2]]             return the 3rd positive x[i]\n\
+       dl (x[..100] >? 0)[[..5]]           return the first 5 positive x[i]\n\
+       dl (x[0..] >? 6)[[0]]               return the first x[i]>6, no limit on i\n\
+       dl argv[0..]@0                      argv[0] argv[1] .. until first null\n\
+       dl x[0..]@-1 >? 9                   x[0..n]>9 where n is first x[n]== -1\n\
+       dl emp[0..]@(code==0)               emp[0]..emp[n-1] where emp[n].code==0\n\
+\n\
+       dl head-->next->val                 val of each element in a linked list\n\
+       dl head-->next[[20]]                the 21st element of a linked list\n\
+       dl *head-->next[[20]]               display above as a struct\n\
+       dl strcmp(head-->next->msg,         search linked list for a string\n\
+            \"testing\") ==? 0\n\
+       dl #/head-->next                    count elements on a linked list\n\
+       dl x-->y[[#/x-->y - 1]]             last element of a linked list\n\
+       dl x-->y[[#/x-->y - 10..1]]         last 10 elements of a linked list\n\
+       dl head-->next->                    check if the list is sorted by val\n\
+          if(next) val >? next->val\n\
+\n\
+       dl head-->(next!=?head)             expand cyclic linked list (tail->head)\n\
+       dl head-->(next!=?_)                handle termination with p->next==p\n\
+       dl root-->(left,right)->key         expand binary tree, show keys\n\
+       dl root-->(left,right)->(           check bin tree sorted by key\n\
+          (left!=?0)->key>=?key, (right    !=?0 )->key<=?key)\n\
+\n\
+       dl (1000..=>if(&&/(2,3.._-1=>__%%_   find first 10 primes over 1000\n\
+                  ) _)[[..10]]\n\
+       dl (T mytype) x                     convert x to user defined type mytype\n\
+       dl (struct s*) x                    convert x to struct s pointer\n\
+       dl if(x) y; else z *ERR*            ';' must be followed by an expression\n\
+       dl {x} y *ERR*                      '}' requires ';' if followed by exp\n\
+\n\
+SEMANTICS\n\
+       Duel's semantics are modeled after the Icon programming language.   The\n\
+       input  consists  of  expressions  which  return sequences of values.  C\n\
+       statements are cast as expressions, too.  Expressions are  parsed  into\n\
+       abstract syntax trees, which are traversed during evaluation. The eval-\n\
+       uation of most nodes (operators) recursively evaluates the  next  value\n\
+       for  each  operand,  and  then applies the operator to produce the next\n\
+       result. Only one value is produced each time, and Duel's eval  function\n\
+       keeps a `state' for each node (backtracking, co-routines, consumer-pro-\n\
+       ducer or threads are good metaphors for the evaluation mechanism.)\n\
+\n\
+       For example, in (5,3)+6..8, the evaluation of `+' first  retrieves  the\n\
+       operands 5 and 6, to compute and return 5+6. Then 7, the next right op-\n\
+       erand is retrieved and 5+7 is returned, followed by 5+8.   Since  there\n\
+       are  no other right operand value, the next left operand, 3 is fetched.\n\
+       The right operand's computation is restarted returning 6,  and  3+6  is\n\
+       returned. The final return values are 3+7 and 3+8.\n\
+\n\
+       The  computation for operators like x>?y is similar, but when x<=y, the\n\
+       next values are fetched instead of returning a value, forming the basis\n\
+       for an implicit search. Operators like `..' return a sequence of values\n\
+       for each pair of operands. For a better understanding of the evaluation\n\
+       mechanism,  see  the  USENIX  Winter/93 conference paper \"DUEL - A Very\n\
+       High Level Debugging Language\".\n\
+\n\
+       Duel values follow the C semantics. A value is either an \"lvalue\"  (can\n\
+       be  used  as the left hand side of assignment), or an \"rvalue\".  There-\n\
+       for, objects like arrays can  not  be  directly  manipulated  (However,\n\
+       operators like x..y can accomplish such tasks.)\n\
+\n\
+       Duel  types  also  follow  the C semantics, with some important differ-\n\
+       ences. C types are checked  statically; Duel  types  are  checked  when\n\
+       operators  are  applied,  e.g., (1,1.0)/2 returns 0 (int) and 0.5 (dou-\n\
+       ble); (x,y).z returns x.z and y.z even if x  and  y  are  of  different\n\
+       types, as long as they both have a field z.\n\
+\n\
+       Values  and  types  of  symbols  are looked up at run-time (using gdb's\n\
+       lookup rules), allowing dynamic scoping and types, but causing a  pars-\n\
+       ing  problem:  (x)(y) can be parsed as either a function call x(y) or a\n\
+       cast (x)y; x*y can be parsed as a declaration of y as (x*) or as multi-\n\
+       plication.\n\
+\n\
+       To  avoid  this  ambiguity,  the  keyword T must precede a user defined\n\
+       type. For example, if value is a typedef, C's (value (*)()) x is  writ-\n\
+       ten  in  Duel  as:  (T value (*)()) x. Types that begin with a reserved\n\
+       keyword don't need T, e.g. (struct value*) x  and  (long  *[5])  y  are\n\
+       accepted.  As special cases, (type)x and (type*)x are accepted but dis-\n\
+       couraged (it causes (printf)(\"hi\"), which is valid in C, to  fail).   A\n\
+       side effect is that \"sizeof x\" must be written as sizeof(x).\n\
+\n\
+OPERATORS\n\
+       x+y  x-y  x*y  x/y  x%%y  x^y  x|y  x&y  x<<y  x>>y\n\
+       x>y  x<y  x>=y  x<=y  x==y  x!=y  x=y  x[y]\n\
+\n\
+       These  binary  operators follow their C semantics. For each value of x,\n\
+       they are evaluated for every value of y, .e.g. (5,2)>(4,1) evaluates as\n\
+       5>4,  5>1,  2>4, 2>1 returning  1, 1, 0, 1.  The y values are re-evalu-\n\
+       ated for each new value of x, e.g.  i=4; (4,5)>i++ evaluates as 4>4 and\n\
+       5>5.   Beware  of  multiple y values in assignment, e.g. x[..3]=(4,6,9)\n\
+       does not set x[0]=4, x[1]=6 and x[2]=9. It assigns 4, 6 and 9  to  each\n\
+       element, having the same effect as x[..3]=9. Use x[i:=..3]=(4,6,9)[[i]]\n\
+       to achieve the desired effect.\n\
+\n\
+       -x  ~x  &x  *x  !x  ++x  --x  x++  x--  sizeof(x)  (type)x\n\
+\n\
+       These unary operators follow their C semantics.  They  are  applied  to\n\
+       each  value  of  x.  The  increment  and decrement operators require an\n\
+       lvalue, so i:=0 ; i++ produces an error because i is an alias to 0,  an\n\
+       rvalue.  Parenthesis  must  be  used  with sizeof(x), \"sizeof x\" is not\n\
+       allowed. Cast to user defined type requires generally requires T, e.g.,\n\
+        (T val(*)())x, but (val)x and (val*)x are accepted as special cases.\n\
+\n\
+       x&&y   x||y\n\
+\n\
+       These  logical  operators  also follow their C semantics, but have non-\n\
+       intuitive results for multi-valued x  and  y,  e.g.  (1,0,0)  ||  (1,0)\n\
+       returns  1,1,0,1,0  --  the  right hand-side (1,0) is returned for each\n\
+       left-hand side 0. It is best to use  these  operators  only  in  single\n\
+       value expressions.\n\
+\n\
+       x? y:z   if(x)y   if(x)y else z\n\
+\n\
+       These  expressions  return  the  values  of  y  for each non-zero value\n\
+       returned by x, and the values of z for each zero value returned  by  x,\n\
+       e.g.   if(x[..100]==0)  y  returns y for every x[i]==0, not if all x[i]\n\
+       are zero (if(&&/(x[..100]==0)) y  does that).  Also, \"if(x) y; else  z\"\n\
+       is illegal. Duel's semicolon is an expression separator, not a termina-\n\
+       tor.\n\
+\n\
+       while(x)y   for(w;x;y)z\n\
+\n\
+       The while(x)y expression returns y as long as all values of x are  non-\n\
+       zero.   The  for()  expression  is similar and both have the expected C\n\
+       semantics. For example, \"for(i=0 ; i<100 ; i++) x[i]\" is  the  same  as\n\
+       x[..100].  Unlike  the  if() expression, while(x[..100]==0) continue to\n\
+       execute only if all elements of x are zero, i.e. the condition is eval-\n\
+       uated into a single value using an implicit &&/x.\n\
+\n\
+       Variable declaration:  type name [,name ...] ; ...\n\
+\n\
+       Expressions  can  begin with variables declaration (but not initializa-\n\
+       tion).  Internally, a declaration sets an alias to space  allocated  in\n\
+       the  target by calling malloc(), e.g. `int x' is the same as \"x:= *(int\n\
+       *) malloc(sizeof(int))\". This is oblivious to the user.  The  allocated\n\
+       memory  is  not  claimed when a variable is redeclared.  Declared vari-\n\
+       ables addresses can be passed to  functions  and  used  in  other  data\n\
+       structures.  The keyword `T' must precede user defined types (typedef),\n\
+       e.g. if val is a user defined  type,  The  C  code  \"val  *p=(val*)  x\"\n\
+       becomes \"T val *p; p=(T val *) x\" in Duel.\n\
+\n\
+       Function calls:  func(parm,...)\n\
+\n\
+       Function  calls  to  the  debugged  program can be intermixed with Duel\n\
+       code. Multi-valued parameters are handled  as  with  binary  operators.\n\
+       The  call  value  can  have multiple values, e.g. (x,y)() calls x() and\n\
+       y(). Currently, struct/union parameters and return values are not  sup-\n\
+       ported.\n\
+\n\
+       x,y   x..y   ..x    x..\n\
+\n\
+       These operators produce multiple values for single value operands.  x,y\n\
+       returns x, then y. x..y returns the integers from x to y.  When x>y the\n\
+       sequence  is  returned  in descending order, i.e. 5..3 returns 5, 4, 3.\n\
+       The operator ..x is a shorthand for 0..x-1, e.g. ..3 returns 0,  1,  2.\n\
+       The  x..  operator  is a shorthand for x..maxint. It returns increasing\n\
+       integer values starting at x indefinitely, and  should  be  bounded  by\n\
+       [[n]]  or  @n  operators.   `,'  retains its precedence level in C. The\n\
+       precedence of `..'  is above `<' and  below  arithmetic  operators,  so\n\
+       0..n-1 and x==1..9 work as expected.\n\
+\n\
+       x<?y  x>?y  x>=?y  x<=?y  x!=?y  x==?y\n\
+\n\
+       These operators work like their C counterparts but return x if the com-\n\
+       parison is true. If the comparison is false, the next  (x,y)  value  is\n\
+       tried, forming the basis of an implicit search.\n\
+\n\
+       (x)  {x}  x;y  x=>y\n\
+\n\
+       Both () and {} act as C parenthesis.  The curly braces set the returned\n\
+       symbolic value as the actual value, e.g. if i=5 and x[5]=3,  then  x[i]\n\
+       produces  the  output \"x[i] = 3\", x[{i}] produces \"x[5] = 3\" and {x[i]}\n\
+       produces just \"3\".  The semicolon is  an  operator.  x;y  evaluates  x,\n\
+       ignoring  the results, then evaluate and return y, e.g. (i:=1..3 ; i+5)\n\
+       sets i to 3 and return 8.  The x=>y operator evaluate and return y  for\n\
+       each  value  of  x, e.g. (i:=1..3 => i+5) returns 6, 7 and 8. The value\n\
+       returned by x is also stored implicitly in `_' which can be used in  y,\n\
+       e.g.  1..5  =>  z[_][_]  will output z[1][1], z[2][2] etc. The symbolic\n\
+       value for _ is that of the left side value, hence {_} is not needed.\n\
+       Semicolon has the lowest precedence, so it must be used inside () or {}\n\
+       for  compound  expressions.  The  precedence of `=>' is just below `,'.\n\
+       Beware that \"if(a) x; else {y;} z\"  is  illegal;  a  semicolon  is  not\n\
+       allowed before '}' or 'else' and must be inserted before z.\n\
+\n\
+       x->y   x.y\n\
+\n\
+       These expression work as in C for a symbol y. If y is an expression, it\n\
+       is evaluated under the scope of x. e.g. x.(a+b) is the same as x.a+x.b,\n\
+       if a and b are field of x (if they are not, they are looked up as local\n\
+       or global variables). x may return multiple values of different  types,\n\
+       e.g.  (u,v).a returns u.a and v.a, even if u and v are different struc-\n\
+       tures.  Also, the value of  x  is  available  as  `_'  inside  y,  e.g.\n\
+       x[..100].(if(a)  _)  produces  x[i]  for each x[i].a!=0. Nested x.y are\n\
+       allowed, e.g.  u.(v.(a+b)) would lookup a and b  first  under  v,  then\n\
+       under u.\n\
+\n\
+       Aliases:  x:=y\n\
+\n\
+       Aliases  store  a  reference  to  y  in  x.  Any reference to x is then\n\
+       replaced by y. If y is a constant or an rvalue, its value  is  replaced\n\
+       for  x. If y is an lvalue (e.g. a variable), a reference to same lvalue\n\
+       is returned. for example, x:=emp[5] ; x=9 assigns 9 to emp[5].  Aliases\n\
+       retain  their values across invocation of the \"dl\" command. An alias to\n\
+       a local variable will reference a stray address when the variable  goes\n\
+       out  of  scope.  The special command \"dl clear\" delete all the aliases,\n\
+       and \"dl alias\" show all current  aliases.  Symbols  are  looked  up  as\n\
+       aliases first, so an alias x will hide a local x.\n\
+\n\
+       x-->y\n\
+\n\
+       The expansion operator x-->y expands a data structure x following the y\n\
+       links.  It returns x, x->y, x->y->y, until a null is  found.  If  x  is\n\
+       null,  no  values  are produced. If y returns multiple values, they are\n\
+       stacked and each is further expanded in a depth-first notion. For exam-\n\
+       ple,  if r is the root of a tree with children u->childs[..u->nchilds],\n\
+       then u-->(childs[..nchilds]) expands the whole tree. y is an  arbitrary\n\
+       expression, evaluated exactly like x->y (this includes `_'.)\n\
+\n\
+       x@y\n\
+\n\
+       The expression x@y produces the values of x until x.y is non-zero, e.g.\n\
+       for(i=0 ; x[i].code!= -1 &&  i<100  ;  i++)  x[i]  can  be  written  as\n\
+       x[..100]@(code==-1).  The evaluation of x is stopped as soon as y eval-\n\
+       uates to true.  x->y or x=>y are used to evaluate y when  x  is  not  a\n\
+       struct  or  a  union.  If y is a constant,(_==y) is used. e.g. s[0..]@0\n\
+       produces the characters in string s up to but not including the  termi-\n\
+       nating null.\n\
+\n\
+       #/x   &&/x   ||/x\n\
+\n\
+       These  operator  return  a  single  \"summary\"  value for all the values\n\
+       returned by x. #/x returns the number of values  returned  by  x,  e.g.\n\
+       #/(x[..100]>?0)  counts  the number of positive x[i]. &&/x returns 1 if\n\
+       all the values produced by x are non-zero, and ||/x returns 1 if any of\n\
+       x's  values  are  non-zero.  Like in C, the evaluation stops as soon as\n\
+       possible.  For example, ||/(x[..100]==0) and &&/(x[..100]==0) check  if\n\
+       one or all of x[i] are zero, respectively.\n\
+\n\
+       x#y  x[[y]]\n\
+\n\
+       The  operator  x#y produces the values of x and arranges for y to be an\n\
+       alias for the index of each value in x. It is commonly used with  x-->y\n\
+       to produce the element's index, e.g. head-->next->val#i=i  assigns each\n\
+       val field its element number in the list.\n\
+       The selection operator x[[y]] produces  the  yth  result  of  x.  If  y\n\
+       returns   multiple   value,   each   select   a   value   of   x,  e.g.\n\
+       (5,7,11,13)[3,0,2] returns 13, 5 and 11 (13 is the 3rd  element,  5  is\n\
+       the  0th  element).   Don't use side effects in x, since its evaluation\n\
+       can be restarted depending on  y,  e.g.  after  (x[0..i++])[[3,5]]  the\n\
+       value of i is unpredictable.\n\
+\n\
+       frame(n)   frames_no   func.x\n\
+\n\
+       frame(n)  for  an integer n returns a reference to the nth frame on the\n\
+       stack (0 is the inner most function and frame(frames_no-1) is  main()).\n\
+       Frame   values   can   be   compared   to   function   pointers,   e.g.\n\
+       frame(3)==myfunc is true if the 4th frame is a call to myfunc,  and  in\n\
+       scope  resolution,  e.g.  frame(3).x return the local variable x of the\n\
+       4th frame.  frames_no is the number of active frames on the stack, e.g.\n\
+       (frames(..frames_no)  ==?  myfunc).x  displays x for all active invoca-\n\
+       tions of myfunc. As a  special  case,  (frames(..frames_no)==?f)[[0]].x\n\
+       can be written as f.x (x can be an expression).\n\
+\n\
+\n\
+BUGS\n\
+       Both  `{}'  and `;' are operators, not statements or expression separa-\n\
+       tors; \"if(x) y; else {z;} u\" is illegal; use \"if(x) y else  {z}  ;  u\".\n\
+       Ambiguities  require  preceding  user-defined  types (typedef) with the\n\
+       keyword T, e.g., if value is a  user  type,  C's  \"sizeof(value*)\"   is\n\
+       written  \"sizeof(T  value*)\",  except for the casts \"(t)x\" and \"(t*)x\";\n\
+       sizeof(x) requires parenthesis for variable x.\n\
+\n\
+       Unimplemented C  idiom  include:  modified-assignment  (x+=y),  switch,\n\
+       break,  continue, do, goto, scopes, function declarations, initializing\n\
+       declared variables, assignment to bit-fields  and  register  variables,\n\
+       and  calling  functions  with a struct/union parameter or return value.\n\
+       gdb does not store function prototypes, so parameters are not  checked.\n\
+\n\
+       Gdb  itself  is  buggy, which shows up, especially in symbol tables and\n\
+       calling target functions. Before you report bug, try to do the  closest\n\
+       thing under gdb's \"print\". Send bug to: mg@××××××××××××.edu.\n\
+\n\
+FILES\n\
+       duel.out tracks duel commands usage. Help analyze duel's use by mailing\n\
+       a copy to mg@××××××××××××.edu.\n\
+       Duel is available by anonymous ftp at ftp.cs.princeton.edu:/duel.\n\
+\n\
+AUTHOR\n\
+       Duel is public domain code -- no copy left or right. See the  internals\n\
+       documentation for details on porting Duel and using its code.  Duel was\n\
+       designed and written by Michael Golan as part of a PhD  thesis  in  the\n\
+       Computer  Science  Department of Princeton University.  I would like to\n\
+       thank my advisor, Dave Hanson, who helped in all phases of this project\n\
+       and to Matt Blaze for his support and useful insight.\n\
+\n\
+       Duel stands for Debugging U (might) Even Like, or Don't Use this Exotic\n\
+       Language. Judge for yourself!\n\
+\n\
+Version 1.10                        Mar 93                             Duel(1)\n\n");
+}
+
+LPROC help(void)
+{
+        duel_printf(
+"Duel - Debugging U (might) Even Like -- A high level debugging language\n\n\
+Duel was designed to overcome problems with traditional debuggers' print\n\
+statement. It supports the C operators, many C constructs, and many new\n\
+operators for easy exploration of the program's space, e.g.\n\
+x[..100] >? 0                 show positive x[i] for i=0 to 99\n\
+y[10..20].code !=? 0          show non-zero y[i].code for i=10 to 20\n\
+h-->next->code                expand linked list h->next, h->next->next ...\n\
+head-->next.if(code>0) name   show name for each element with code>0\n\
+x[i:=..100]=y[i];             array copy. i is an alias to vals 0..99\n\
+head-->next[[10..15]]         the 10th to 15th element of a linked list\n\
+#/(head-->next->val==?4)      count elements with val==4\n\
+head-->next->if(next) val >? next->val    check if list is sorted by val\n\
+\n\
+Duel was written by Michael Golan at Princeton University. Send email to\n\
+mg@××××××××××××.edu. Duel is public domain code. No copy left or right.\n\
+all but 500 lines are independent of gdb. Port it! Make it Commercial!\n\
+\n\
+Try \"dl ops\" for op summary; \"dl\" alone lists all commands\n");
+}
+
+LPROC examples(void)
+{
+    duel_printf("\
+x[10..20,22,24,40..60]    display x[i] for the selected indexes\n\
+x[9..0]                   display x[i] backwards\n\
+x[..100] >? 5 <? 10       display x[i] if 5<x[i]<10\n\
+x[0..99]=>if(_>5 && _<10) _     same\n\
+val[..50].if(is_dx) x else y   \
+val[i].x or val[i].y depending on val[i].is_dx\n\
+emp[..50].if(is_m) _      return emp[i] if emp[i].is_m.\n\
+x[i:=..100]=y[i] ;        assign y[i] to x[i]\n\
+x[i:=..100] >? x[i+1]     check if x[i] is not sorted\n\
+(x[..100] >? 0)[[2]]      return the 3rd positive x[i]\n\
+argv[0..]@0               argv[0] argv[1] .. until first null\n\
+emp[0..]@(code==0)        emp[0]..emp[n-1] where emp[n].code==0\n\
+head-->next->val          val of each element in a linked list\n\
+*head-->next[[20]]        element 20 of list, '*' display struct w/fields\n\
+#/head-->next             count elements on a linked list\n\
+#/(head-->next-val>?5)    count those over 5\n\
+head-->(next!=?head)      expand cyclic linked list (tail->head)\n\
+T mytype x ;              declare var for user defined type (need 'T')\n\
+int i ; for(i=0 ;i<5 ..   declare variable, use C construct.\n");
+}
+
+LPROC operators(void)
+{
+    duel_printf("\
+DUEL operators in decreasing precedence. All C operators are accepted!\n\
+note: precede typedefs by 'T', eg \"sizeof(T uint)\"\n\n\
+{x}     same as (x) but x's value is used for symbol                emp[{i}]\n\
+x-->y   expands data structure from x, using y      root-->(left,right)->key\n\
+x.y     eval y under x's scope, like pascal \"with\". x is accesible as '_'\n\
+x->y    same as (*x).y.                             hash[..50]->if(_!=0) key\n\
+x[[y]]  select the y'th elements of x                     head-->next[[..6]]\n\
+x@y     eval x, stop as soon as y true (_==y if y const).        argv[0..]@0\n\
+x#y     eval x, set alias y as values counter        (x-->next#n)->level==?n");
+    duel_printf("\n\
+#/x     count number of values from x                          #/head-->next\n\
+frame(n) use with '.' to reference stack frames.                frame(3).val\n\
+x..y    x, x+1, x+2 .. y. (if x>y, return them backwards)          x[10..20]\n\
+..y     like 0..y-1                                                x[..1024]\n\
+x..     like x..maxint. Caution: use only with x@y or x[[y]]     name[0..]@0\n\
+x>?y    x if x>y else nothing. also <? <=? >=? ==? and !=?        x[..10]<?0\n\
+&&/x    1 or 0 if x!=0 for all x values. ||/x similar         &&/x[..100]>=0\n\
+x,y     x, then y.				      head-->next->(val,key)\n\
+x=>y    eval y for each x, setting '_' to x's values            x[..50]=>_*_\n\
+if(x) y C statements are operators. Also for(), while(), if() else\n\
+x;y     Evaluate and ignore x's value, then return y\n");
+}
+
+/* entry point into duel. s is the expression to evaluate */
+
+void duel_parse_and_eval(char *s)
+{
+   static first=1 ;
+   if(first)  {                 /* init stuff */
+      duel_init_basic_ctypes(); 
+      duel_printf("%s.%d, public domain debugging language. \"dl\" for help\n",
+               VERSION,PATCHLEVEL);
+      duel_redirectable_output_init();
+      first=0 ; 
+   }
+   if(!s || *s==0) {  /* no input, give some help */
+       duel_printf("\
+Supported DUEL commands:\n\
+duel help      - give basic help (shortcut: dl ?)\n\
+duel longhelp  - give a longer help (dl ?\?)\n\
+duel examples  - show useful usage examples (dl ex)\n\
+duel operators - operators summary (dl ops)\n\
+duel aliases   - show current aliases (dl alias)\n\
+duel clear     - clear all aliases\n\
+duel debug     - toggle duel debug mode\n");
+       return ;
+   }
+   if(strcmp(s,"?")==0 || strcmp(s,"help")==0) {
+       help();
+       return ;
+   }
+   if(strcmp(s,"?\?")==0 || strcmp(s,"longhelp")==0) {
+       longhelp();
+       return ;
+   }
+   if(strcmp(s,"examples")==0 || strcmp(s,"ex")==0 ) {
+       examples();
+       return ;
+   }
+   if(strcmp(s,"operators")==0 || strcmp(s,"ops")==0) {
+       operators();
+       return ;
+   }
+   if(strcmp(s,"debug")==0) {           /* turn debugging of duel itself */
+       duel_debug= !duel_debug ;
+       duel_printf("duel debug mode %d\n",duel_debug);
+       return ;
+   }
+   if(strcmp(s,"clear")==0) {
+       duel_clear_aliases();
+       duel_printf("Aliases table cleared\n");
+       return ;
+   }
+   if(strcmp(s,"alias")==0 || strcmp(s,"aliases")==0) {
+       duel_show_aliases();
+       return ;
+   }
+   if(setjmp(duel_abort_jmp)==0) {              /* set abort point */
+     if((root=duel_parse(s))!=NULL) {
+       tvalue v ; 
+       duel_set_input_string(s);	  /* for src-location err management */
+       duel_reset_eval();
+       duel_redirectable_output_start(s); /* allow eval output to go to pipe */
+       while(duel_eval(root,&v)) {
+           duel_print_value(&v);
+	   duel_flush();
+       }
+       duel_redirectable_output_end();
+     }
+   }
+   duel_cleanup(0);
+}
+
+
+
+
+
+
+
+
+
+
--- gdb/duel/duel.h
+++ gdb/duel/duel.h
@@ -0,0 +1,35 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code			           */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* duel.h - include file to be used with all duel source code.
+ * it defines important global constants & data types, as well as some
+ * global variables. prototypes should go in the duelprot.h file
+ */
+
+
+/* common duel include files. I dunno why people don't like recursive
+ * includes, as long as it is consistent. Note only one level of recursion.
+ * the debugger module itself dont use this file, instead it includes what
+ * it needs directly.
+ * as for including "everything", unless one redefine some standard lib func,
+ * I feel safer including most standard lib files. It seems to prevent errors
+ * even if it garble the name space a bit.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <limits.h>
+#include <math.h>
+/* global data and types */
+
+#include "global.h"
+
+/* prototypes for all global functions follows */
+
+#include "proto.h"
--- gdb/duel/duel.pipe
+++ gdb/duel/duel.pipe
@@ -0,0 +1,107 @@
+#!/usr/local/bin/perl
+# perl script opened as a pipe by duel 
+#
+# duel(gdb), fork this program and feed it as stdin, the output from
+# evaluating expressions. the input is 
+# $$$START: expr	where expr is the expression being evaluted
+# $$$DONE		end of results
+# $$$ABORT		end of results due to error or interrupt
+# $$$SYM: s		symbolic output 's'
+# $$$VAL: v		value for previous symbolic output
+#
+# the output from this program is fed back into duel, which simply display
+# it. After DONE/ABORT, duel wait for a $$$DONE to get back, so it can
+# return to gdb's prompt.
+#
+# Duel expressions terminates after '|>', the text after which should be
+# processed by the pipe (a "pipe command" if you will).
+# There is no limit to what this program can do. Currently all it does
+# is provide all hex/ all decimal display of integers (|>hex and |>dec),
+# and provide "smart" output, on the same line, when the symbolic output
+# is the same as the values.
+# 
+# Some examples of what can be done here:
+# |> sort		-- will sort the output 
+# |> sort?		-- display a message if it was/wasnt sorted
+# |> uniq		-- display only uniq values in output
+# |> uniq?		-- display message if all output was uniq.
+# |> vals		-- only display vals, ignore symbolic
+# |> syms		-- only display symbolics, ignore vals
+# |> matrix		-- Attempt to display in a matrix format
+# |> compress		-- compress into single lines, eg
+#			   x[i].val=1\n x[i].name="me"\n
+#			   becomes: x[i] = { val=1, name="me" }
+# |> vector		-- attempt to display as vector, eg
+#			   x[1]=5\bx[4]=3\nx[9]=2\nx[12]=8\n  becomes:
+#			   i     1  4  9  12
+#			   x[i]  5  3  2   8
+# |> smart		-- try to figure out one of the above formats...
+# |> plotxy		-- plot (sym,val) using xgraph. can convert x[5]
+#			   symbol into '5' for the x-coord, etc.
+# |> stack		-- output of frame(..frames_no).`*`, 
+#			   which hasnt been implemented yet (* is regex),
+#			   to be formatted as a stack trace...
+#
+# the code below is very simple. A better organization will support
+# adding "functions" (commands) and specify for each command if the
+# function is called only after all values have been collected, or
+# for every value, if the command is active until unset, or just for
+# the specific line it was given on, what flags it set/reset, etc.
+
+
+$|=1 ;		# flush output on every write to the pipe
+
+%cmds = ("norm",1,"smart",1,"dec",1,"hex",1) ;
+$smart=0;
+$base=0 ;
+
+while(<>) {
+  chop; study ;
+  if(/^\$\$\$START: /) {
+    if(/\|\>\s*([^"']*)$/) {		# |> pipe-command 
+	$_ = $1 ;
+	s/\s+$// ;			# clean trailing spaces
+	if($cmds{$_}) { 
+		printf "Pipe command '$_'\n" ;
+		$smart=0 if /norm/ ;
+		$smart=1 if /smart/ ;
+		$base=0  if /norm/ ;
+		$base=10 if /dec/ ;
+		$base=16 if /hex/ ;
+	}
+	else {  printf "BAD PIP COMMAND '$_'\n" ; }
+    }
+    $same=0 ;
+  }
+  elsif(/^\$\$\$DONE$/) {
+    print "\n" if $same ;	# go to next line if not on same 
+    print "\$\$\$DONE\n" ;
+  }
+  elsif(/^\$\$\$ABORT$/) {
+    print "\n" if $same ;	# go to next line if not on same 
+    print "\$\$\$DONE\n" ;
+  }
+  elsif(/^\$\$\$SYM: (.*)$/) {
+    $sym = $1 ;
+  }
+  elsif(/^\$\$\$VAL: (.*)$/) {
+    $_ = $val = $1 ;
+    $_ = oct 			if($base==10 && /^0x[0-9a-z]*$/) ;
+    $_ = sprintf("0x%2.2x",$_)  if($base==16 && /^[1-9]\d*$/) ;
+    if($smart && ( $sym eq $_ || $sym eq $val)) { 
+	$sz= 3 + length ;
+	if($same+$sz > 75) { print "\n" ; $same=0 ; }
+        $same+=$sz ;
+	print "$_,  " ;
+    }
+    else {
+	print "\n" if $same ;	# go to next line if not on same 
+	if($sym == $val) { print "$_\n" ; }
+	else { print "$sym  =  $_\n" ; }
+	$same=0 ;
+    }
+  }
+  else {
+    print "bad duel input to duel.pipe ignored: $_\n" ;
+  }
+}
--- gdb/duel/duelself.c
+++ gdb/duel/duelself.c
@@ -0,0 +1,209 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code			           */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* self-debugger module, it contains all of duel's access to
+ * the outside world (like duelgdb.c), but is intended to work when duel
+ * is linked with the debuggee directly (not with the debugger!)
+ * if you link this with duel.a, you get a test suite of duel
+ * for the C program: (tsuite.c)
+ *
+ * int gint ;
+ * typedef unsigned int uint ;
+ * int main() { 
+ *	printf ; malloc ; 	/ * include them in bin * /
+ *	char *s="main string" ; 
+ * }
+ *
+ * You could link this module with your own program and call it at
+ * "appropriate places", then ship the program with this code, and
+ * use duel at client's site when a crash occurs. However, reading in
+ * the symbol table and figuring out the active frames remains a problem.
+ */
+
+/*
+ * $Log: 10_all_gdb-6.6-duel.patch,v $
+ * Revision 1.1  2007/12/29 21:06:06  vapier
+ * add DUEL support #199987 by Sergei Golubchik
+ *
+ * Revision 1.6  93/03/19  16:55:35  mg
+ * allow execution from within make
+ * 
+ * Revision 1.5  93/03/12  05:47:29  mg
+ * *** empty log message ***
+ * 
+ * Revision 1.4  93/02/04  00:05:10  mg
+ * avoid Header problems in self.out
+ * 
+ * Revision 1.3  93/01/13  16:21:40  mg
+ * made sure printf is declared
+ * 
+ * Revision 1.2  93/01/12  21:31:01  mg
+ * brought uptodate with duelgdb.c
+ * cleanup and set for release
+ * 
+ */
+/* include system dependent stuff here */
+
+#include "duel.h"
+
+int main(int argc,char **argv);
+
+FUNC void* duel_malloc(size_t size)
+{
+  void *p=malloc(size);
+  if(p==0) duel_fatal("out of memory.");
+  return p;
+}
+
+PROC duel_free(void *p)
+{
+   free(p);
+}
+/* fetch n bytes from the target at the given memory address.
+ * the address to fetch from is given by (from).
+ * the value is stored at the 'to' location, which points to space for
+ * n bytes in the debugger.
+ * if the address can not be accessed, false is returned (if all ok, ret true)
+ */
+
+FUNC bool duel_get_target_bytes(ttarget_ptr from,void *to,size_t n)
+{
+  duel_bcopy(to,from,n);
+  return TRUE ;
+}
+
+/* store n bytes to the debuggee. reverse parms from above */
+FUNC bool duel_put_target_bytes(ttarget_ptr to,void *from,size_t n)
+{
+   duel_bcopy(to,from,n);
+   return TRUE ;
+}
+
+/* fetch the value of a bitfield of a given structure. */
+
+FUNC bool duel_get_target_bitfield(ttarget_ptr struct_at,int bitpos,
+                                    int bitlen,void *to,tctype_kind tkind)
+{
+    return FALSE ; /* not supported in duelself */
+}
+
+/* make a function call to the target. */
+/* support only passing/returing sizeof(int) upto 5 paramaters */
+PROC duel_target_func_call(tvalue *func, tvalue *parms[],
+                            int parms_no,tvalue *rval)
+{
+    int (*f)();
+    int i ;
+    if(parms_no>5) duel_fatal("too many parms");
+    if(sizeof(func->ctype->u.kid)!=sizeof(int) && 
+       func->ctype->u.kid!=ctype_void ) duel_fatal("unsupported func parm");
+    for(i=0 ; i<parms_no ; i++) {
+	if(parms[i]->val_kind!=VK_RVALUE || parms[i]->ctype->size!=sizeof(int))
+	    duel_fatal("unsupported paramater");
+    }
+    f=(int (*)()) func->u.lvalue ;
+    switch(parms_no) {
+      case 0:
+	rval->u.rval_int= (*f)();
+      break ;
+      case 1:
+	rval->u.rval_int= (*f)(parms[0]->u.rval_int);
+      break ;
+      case 2:
+	rval->u.rval_int= (*f)(parms[0]->u.rval_int,parms[1]->u.rval_int);
+      break ;
+      case 3:
+	rval->u.rval_int= (*f)(parms[0]->u.rval_int,parms[1]->u.rval_int,
+	      parms[2]->u.rval_int);
+      break ;
+      case 4:
+	rval->u.rval_int= (*f)(parms[0]->u.rval_int,parms[1]->u.rval_int,
+	      parms[2]->u.rval_int,parms[3]->u.rval_int);
+      break ;
+      case 5:
+	rval->u.rval_int= (*f)(parms[0]->u.rval_int,parms[1]->u.rval_int,
+	      parms[2]->u.rval_int,parms[3]->u.rval_int,parms[4]->u.rval_int);
+      break ;
+    }
+    rval->val_kind=VK_RVALUE ;
+    rval->ctype=func->ctype->u.kid ;
+}
+
+/* find debuggee variable.
+ * recognize main.s, gint, malloc, printf
+ */
+
+int gint ;	/* global variable recognized */
+char **main_s ;	/* point to main's 's' */
+
+FUNC bool duel_get_target_variable(char *name, int frame_no, tvalue *v)
+{
+   v->val_kind=VK_LVALUE ;
+   if(frame_no<=0 && strcmp(name,"s")==0) {
+       v->ctype=duel_mkctype_ptr(ctype_char);
+       v->u.lvalue = (void*) main_s ;
+       return TRUE ;
+   }
+   if(frame_no != -1) return FALSE ;
+   if(strcmp(name,"main")==0) {
+       v->ctype=duel_mkctype_func(ctype_void);
+       v->u.lvalue = (void*) main ;
+       return TRUE ;
+   }
+   if(strcmp(name,"malloc")==0) {
+       v->ctype=duel_mkctype_func(duel_mkctype_ptr(ctype_void));
+       v->u.lvalue = (void*) malloc ;
+       return TRUE ;
+   }
+   if(strcmp(name,"printf")==0) {
+       if(0) printf("");  /* "declare" print */
+       v->ctype=duel_mkctype_func(ctype_int);
+       v->u.lvalue = (void*) printf ;
+       return TRUE ;
+   }
+   if(strcmp(name,"gint")!=0) return FALSE ;
+   v->ctype= ctype_int ;  /* type of this variable */
+   v->u.lvalue= (void*) &gint ;   /* address of variable   */
+   return TRUE ;
+}
+
+
+FUNC int duel_get_frames_number(void)
+{
+    return 1 ; /* main */
+}
+
+
+FUNC ttarget_ptr duel_get_function_for_frame(int frame_no)
+{
+    if(frame_no==0) return (void*) main ;
+    else duel_fatal("bad frame number - internal err");
+}
+
+FUNC tctype* duel_get_target_typedef(char *name)
+{
+    if(strcmp(name,"uint")==0) return ctype_uint ;
+    return NULL ;
+}
+
+FUNC tctype* duel_get_target_struct_tag(char *name) { return 0 ; }
+FUNC tctype* duel_get_target_union_tag(char *name)  { return 0 ; }
+FUNC tctype* duel_get_target_enum_tag(char *name)   { return 0 ; }
+
+int main(int argc,char **argv)
+{
+   char *s="main string" ;
+   main_s = &s ;		/* put s into the "symbol tbl" */
+
+   while(1) {
+       char in[120] ;
+       gets(in);
+       if(feof(stdin)) break ;
+	/* output & input are RCS'ed. avoid $Header in self.out, which is
+	 * the input header, which RCS fix... which create mis matches */
+       if(strncmp(in,"## $Header",10)==0) continue ;
+       printf("dl> %s\n",in);
+       if(in[0]==0 || in[0]=='#' && in[1]=='#') continue ;  /* comments */
+       duel_parse_and_eval(in);
+   }
+   return 0 ; /* to run in make */
+}
--- gdb/duel/error.c
+++ gdb/duel/error.c
@@ -0,0 +1,114 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code			           */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* display errors in a neat way */
+
+/*
+ * $Log: 10_all_gdb-6.6-duel.patch,v $
+ * Revision 1.1  2007/12/29 21:06:06  vapier
+ * add DUEL support #199987 by Sergei Golubchik
+ *
+ * Revision 1.5  93/03/12  05:48:27  mg
+ * support output redirection
+ * 
+ * Revision 1.4  93/01/12  21:35:31  mg
+ * cleanup and set for release
+ * 
+ */
+
+#include "duel.h"
+
+static tnode *curr_eval_node ;	/* current node being evaluated */
+static  char *curr_inputstr ;   /* current input string being eval */
+
+/* indicate the active node where an operator is now evaluated.
+ * if an error occurs, this marker is used to tell the user where
+ * the error is located.
+ * return previous setup to caller, so it can be restored.
+ */
+
+FUNC tnode* duel_set_eval_loc(tnode *n)
+{
+    tnode *prev=curr_eval_node ;
+    curr_eval_node=n ;
+    return prev ;
+}
+
+/* indicate the current input string which is evaluated 
+ * (intended for future versions with multiple input strings)
+ */
+
+FUNC char* duel_set_input_string(char *s)
+{
+   char *prev=curr_inputstr ;
+   curr_inputstr=s ;
+   return prev ;
+}
+/* display source position for errors, based on current node being eval'ed */
+
+LPROC print_src_pos(void)
+{
+    int src_pos=0 ;
+    int i ;
+    if(curr_eval_node) src_pos=curr_eval_node->src_pos ;
+    duel_printf("Error:   %s\n",curr_inputstr) ;
+    duel_printf("         ") ;
+    for(i=0 ; i<src_pos ; i++) duel_printf("-");
+    duel_printf("^-- ");
+}
+
+/* called for errors that are results of bad user input (syntax/sematics),
+ * e.g. an illegal variable name, etc
+ * the message is printed as a format string for 'op'.
+ * the error location in the source is printed based on the current eval node,
+ * and the value of the given operands are displayed.
+ */
+
+PROC duel_op_error(char *mesg,char *op,tvalue *v1,tvalue *v2)
+{
+    char s[160] ;
+
+    duel_redirectable_output_abort();
+    print_src_pos();
+    duel_printf(mesg,op);
+    duel_printf("\n");
+    if(v1) {
+      duel_printf("operand%s ``%s'' ",(v2!=0)? "1":"",v1->symb_val);
+      duel_printf("\t-- type: ");
+      duel_print_type(v1->ctype,1);
+      duel_sprint_scalar_value(s,v1);
+      duel_printf("\n\t\t-- value: %s\n",s);
+    }
+    if(v2) {
+      duel_printf("operand%s ``%s'' ",(v1!=0)? "2":"",v2->symb_val);
+      duel_printf("\t-- type: ");
+      duel_print_type(v2->ctype,1);
+      duel_sprint_scalar_value(s,v2);
+      duel_printf("\n\t\t-- value: %s\n",s);
+    }
+    
+    duel_abort();
+}
+
+/* handle a genral error, no value (operand) is involved.
+ * location (node) is still displayed
+ */
+
+PROC duel_gen_error(char *mesg,char *arg1)
+{
+    duel_redirectable_output_abort();
+    print_src_pos();
+    duel_printf(mesg,arg1);
+    duel_printf("\n");
+    duel_abort();
+}
+
+/* handle fatal messages */
+
+PROC duel_fatal(char *msg)
+{
+   duel_redirectable_output_abort();
+   duel_printf("Fatal Duel error: %s\n",msg);
+   duel_abort();
+}
+
+
--- gdb/duel/eval.c
+++ gdb/duel/eval.c
@@ -0,0 +1,834 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code                            */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* this module is the most critical code, the recursive evaluation
+ */
+
+/*
+ * $Log: 10_all_gdb-6.6-duel.patch,v $
+ * Revision 1.1  2007/12/29 21:06:06  vapier
+ * add DUEL support #199987 by Sergei Golubchik
+ *
+ * Revision 1.13  93/03/19  15:39:34  mg
+ * fixed bug in left->left symbolic, and long symbolics which caused crashes
+ * 
+ * Revision 1.12  93/03/12  05:48:45  mg
+ * fixed sizeof(type) symbolic
+ * 
+ * Revision 1.11  93/02/26  04:59:51  mg
+ * improved symbolic debugging of #/
+ * 
+ * Revision 1.10  93/02/03  21:47:41  mg
+ * fixed dot stack bug; fixed func-call last parm eval bug
+ * 
+ * Revision 1.9  93/01/12  21:50:26  mg
+ * cleanup and set for release
+ * 
+ * Revision 1.8  93/01/07  00:09:34  mg
+ * scope stack changes a bit.
+ * clear/aliases commands.
+ * func.x support, x.y etc force existance if y field of x., x=>y w/'_'
+ * allow fields in y for x@y, x pointer.
+ * fixed eval_node setup
+ * added &&/ ||/
+ * 
+ * 
+ * Revision 1.7  93/01/03  07:29:23  mg
+ * function calls, error reporting, printing.
+ * 
+ * Revision 1.6  92/12/24  23:33:48  mg
+ * frames support
+ * 
+ * Revision 1.5  92/10/19  15:06:35  mg
+ * *** empty log message ***
+ * 
+ * Revision 1.4  92/10/14  02:04:35  mg
+ * misc
+ * 
+ * Revision 1.3  92/09/16  11:04:16  mg
+ * *** empty log message ***
+ * 
+ * Revision 1.2  92/09/15  05:54:56  mg
+ * cosmetics and new ops: 
+ * generic '.' and '_'  support. x@y. '..x' and 'x..'.  while(), for(), ?:
+ * 
+ */
+
+#include "duel.h"
+
+
+
+#define DOT_STACK_SIZE 100    /* dot stack size, maximum no. of dots in stmt */
+
+/* the scope eval stack. 
+ * used for several purposes: to push _'s values (=>), to push structs
+ * and unions for x.y and x->y, and to push func/frame values fro frame(i).x
+ * and func.x/
+ * realv is the real value for the left side operand. It is used for '_'.
+ * fieldv is the one to be used to fetch actual names. either:
+ * fieldv=realv (for x.y, frame(i).y), fieldv=*realv (for x->y), 
+ * fieldv=func_frame(realv) (for func.x), or fieldv=0  (x=>y).
+ */
+struct { 
+    tvalue *realv ;     /* actual value for x in x.y or x->y etc. used for _ */
+    tvalue *fieldv;     /* value to use for fetching fields, *realv for x->y */
+  } dot_stack[DOT_STACK_SIZE] ;
+int dot_stack_top= -1 ;
+
+PROC duel_reset_eval(void)   /* reset evaluation states from previous eval */
+{
+  dot_stack_top= -1 ;   /* reset stack */
+}
+
+/* try to find the given name on the dot_stack of structures.
+ * if found, return true and value in(v) else return false.
+ * the symbolic value is not set.
+ * if top_only, looks only at the top of the stack.
+ */
+LFUNC bool find_dot_name(char *name,tvalue *v,bool top_only)
+{
+    int i,j ;
+    tctype_field *f ;
+    tctype *t ;
+    tvalue *x;
+
+    for(i=dot_stack_top ; i>=0 ; i--) {           /* look at the stack[i]    */
+        if(top_only && i!=dot_stack_top) break ;  /* consider only top of stk*/
+        x=dot_stack[i].realv ;
+        if(name[0]=='_' && name[1]==0 ||                           /* _ */
+           name[1]=='_' && i==dot_stack_top-1 && name[2]==0 ||     /* __ */
+           name[1]=='0'+dot_stack_top-i && name[2]==0) {           /* _[0-9] */
+            *v = *x ;
+            return TRUE ; 
+        }
+        x=dot_stack[i].fieldv;
+        if(!x) continue ;
+        if(x->val_kind==VK_FVALUE) {
+            if(!duel_get_target_variable(name,x->u.fvalue,v)) continue ;
+            strcpy(v->symb_val,name);
+            return TRUE ;
+        }
+        t=x->ctype ;
+        if(!ctype_kind_struct_like(t)) continue ;
+        duel_assert(x->val_kind==VK_LVALUE);
+        for(j=0 ; j<t->u.f.fields_no ; j++) {  /* look at field[j] of struct*/
+            f= &t->u.f.fields[j] ;
+            if(strcmp(f->name,name)==0) goto found ;
+        }
+    }
+    return FALSE ;
+found:
+    v->ctype=f->ctype ;
+    strcpy(v->symb_val,name);
+    if(f->bitlen==0) {
+       v->u.lvalue=x->u.lvalue+f->bitpos/BITS_PER_BYTE ;
+       v->val_kind=VK_LVALUE ;
+       return TRUE ;
+   }
+   /* special care for a bitfield */
+   if(f->ctype->type_kind!=CTK_INT && f->ctype->type_kind!=CTK_UINT)
+       duel_gen_error("bitfield '%s' must be int or unsigned",name);
+    v->val_kind=VK_BVALUE ;
+    v->u.bvalue.lvalue=x->u.lvalue ;
+    v->u.bvalue.bitpos=f->bitpos ;
+    v->u.bvalue.bitlen=f->bitlen ;
+    return TRUE ;
+}
+
+/* find the value of a given symbolic name and
+ * return in in v
+ * if name is not found, aborts with an error
+ */
+
+LPROC duel_eval_name(char *name,tvalue *v)
+{
+   tvalue *aval=duel_find_alias(name) ; /* find internal alias */
+   if(aval!=NULL) *v= *aval ;
+   else
+   if(find_dot_name(name,v,FALSE)) return ;   /* setup name itself */
+   else
+   if(duel_get_target_variable(name,-1,v));
+   else
+   if(strcmp(name,"frames_no")==0) {            /* check special variables */
+       v->val_kind=VK_RVALUE ;
+       v->ctype=ctype_int ;
+       v->u.rval_int=duel_get_frames_number();
+   }
+   else duel_gen_error("variable '%s' not found",name);
+   strcpy(v->symb_val,name);
+}
+
+
+LPROC push_val(tval_list *l,tvalue *v)
+{
+  tval_lcell *e = duel_malloc(sizeof(tval_lcell));
+  e->val = *v ;
+  e->next=l->head ;
+  l->head=e ;
+  if(l->tail==0) l->tail=e ;
+}
+
+LPROC append_val(tval_list *l,tvalue *v)
+{
+  tval_lcell *e=duel_malloc(sizeof(tval_lcell)) ;
+  e->val = *v ;
+  e->next=0 ;
+  if(l->head==0) l->head=l->tail=e ;
+  else     l->tail=l->tail->next=e ;
+}
+
+/* push a whole val-list(ins) into (l) i.e. insert (ins) at the head of(l)
+ */
+
+LPROC push_val_list(tval_list *l,tval_list *ins)
+{
+  if(ins->head==NULL) return ;              /* inserted list is empty */
+  if(l->head==NULL) { *l= *ins ; return ; }  /* insert-into is empty */
+  ins->tail->next=l->head ;
+  l->head=ins->head ;
+}
+
+
+/* remove first(top) element */
+LFUNC bool pop_val(tval_list *l,tvalue *v)
+{
+  tval_lcell *e=l->head ;
+  if(e==0) return(FALSE);
+  *v=e->val ;
+  l->head=e->next ;
+  return(TRUE);
+}
+/* compute the symbolic value of one iteration of a search (eg -->) operator.
+ * Normally, for (x) and (y) the result x->y  is returned. 
+ * But, if x === a-->next[[n]] and y === next, then we 
+ * return a-->next[[m]] where m=n+1.
+ * Also, instead of returning x->y we return x-->y[[1]]
+ *
+ * note: this was not written for speed! I don't know if it takes
+ * a significant amount of time or not.
+ */
+
+LPROC set_search_symb_val(char *opcode,tvalue *xval,tvalue *yval)
+{
+    char *x = xval->symb_val ; 
+    char *y = yval->symb_val ;
+    int i,opl=strlen(opcode),xl=strlen(x),yl=strlen(y) ;
+    char s[3*VALUE_MAX_SYMBOLIC_SIZE];
+
+    if(yl+2<xl && strcmp(x+xl-yl,y)==0 && x[xl-yl-2]=='-' && x[xl-yl-1]=='>') 
+        sprintf(s,"%-.*s%s%s[[2]]",xl-yl-2,x,opcode,y);
+    else {
+    for(i=xl-1 ; i>0  ; i--)            /* see if we have op in x */
+        if(strncmp(&x[i],opcode,opl)==0) break ;
+    if(i>0 && strncmp(&x[i+opl],y,yl)==0 && 
+       x[i+opl+yl]=='[' && x[i+opl+yl+1]=='[' && x[xl-2]==']' && x[xl-1]==']'){
+        /* x seems to be something like  head-->next[1] */
+        int j,val=0 ;
+        for(j=i+opl+yl+2 ; j<xl-2 ; j++) {
+            if(x[j]<'0' || x[j]>'9') goto simple ;
+            val=10*val+x[j]-'0' ;       /* compute index */
+        }
+        sprintf(s,"%-.*s[[%d]]",i+opl+yl,x,val+1);   /* and re-create it */
+    }
+    else {
+simple:         /* we failed to find a x-->y[z] pattern, make new one */
+        sprintf(s,"%s->%s",x,y);
+    }
+   }
+   s[VALUE_MAX_SYMBOLIC_SIZE-1]=0 ; /* chop as needed */
+    strcpy(y,s);
+}
+
+LPROC push_dot_stack(tvalue *realv,tvalue *fieldv)
+{
+   if(dot_stack_top==DOT_STACK_SIZE) 
+       duel_gen_error("expression too complex ('.' and '->' levels)",0);
+   dot_stack[++dot_stack_top].realv=realv ;
+   dot_stack[dot_stack_top].fieldv=fieldv ;
+}
+
+LPROC pop_dot_stack(void)
+{
+   duel_assert(dot_stack_top>=0);
+   dot_stack_top-- ;
+}
+
+/* a simple fetch of a field. used mainly when printing 
+ * v must be a struct with the given name field. value is returned in ret.
+ * return false if name not found.
+ */
+
+FUNC bool duel_get_dot_name(tvalue *v,char *name,tvalue *ret)
+{
+    bool ok ;
+    push_dot_stack(v,v);
+    ok=find_dot_name(name,ret,TRUE);
+    pop_dot_stack();
+    return ok ;
+}
+
+/* evaluate x.y and similar "with" operators. Special care when y is a 
+ * name and not an expression -- force y to be a direct field of x.
+ * y is the 'y' node. v is value to return. op is opcode for error reports
+ * (rv,fv) are values to push on the dot stack. rv is the real 'x' value,
+ *         fv is the value of x to use for field lookup (fv= *rv for '->')
+ */
+
+LFUNC bool eval_dot(tnode *y,tvalue *v,char *op,tvalue *rv,tvalue *fv)
+{
+   bool ok ;
+   push_dot_stack(rv,fv);
+   if(y->node_kind!=NK_NAME) ok=duel_eval(y,v);  /* "with" style */
+   else {                                        /* x.y y simply name */
+      if(++y->eval.level>1) { y->eval.level=0 ; ok=FALSE ; }
+      else {
+        ok=find_dot_name(y->name,v,TRUE);
+        if(!ok) duel_op_error("field not found in operator '%s'",op,rv,0);
+      }
+   }
+   pop_dot_stack();
+   return ok ;
+}
+
+
+/* evaluate special operators like '-->' '?:' etc */
+
+/* get the next result of an sop val:
+ * DFS:  init by pushing(x)
+ * Iterate: pop x, compute all x->y, push (reversed)
+ * out: x
+
+ * POS: init by pushing(x), unmarked.
+ * Iterate: pop x, if marked return it. else push back, marked.
+ *          compute all x->y, push (reversed)
+ *          repeat until marked x is popped.
+ * out: poped x which is marked.
+
+ * BFS: init by pushing(x)
+ * Iterate: get first(x), 
+ *      compute all x->y and put into queue.
+ *      return x.
+ */
+
+/* fetch the next value in a DFS search on x-->y. y is given as a node
+ * and x is popped of the given list. Value is returned in v.
+ * note: the results from x->y are reversed when pushed on the list,
+ * this is so x-->(left,right) would return the left first (put last on
+ * the stack, even though it is computed first!)
+ * malloc problem: newl is kept locally, so in case of ^C while here, mem 
+ * it points to will be lost. Normally only a few values
+ */
+
+LFUNC bool get_next_dfs_val(tval_list *l, tnode *y,tvalue *v)
+{
+   tvalue child,x ;
+   tval_list newl ;
+   newl.head=0 ;
+   do {
+       if(!pop_val(l,v)) return(FALSE) ;
+       x= *v ;
+       duel_get_struct_ptr_val(&x,"x-->y");
+   } while(x.u.lvalue==0) ;     /* ignore null pointers */
+   while(eval_dot(y,&child,"-->",v,&x)) {
+       set_search_symb_val("-->",&x,&child);  /* makes x-->y[n] neatly */
+       append_val(&newl,&child);                /* append to childs list */
+   }
+   push_val_list(l,&newl);              /* append new childs to stack */
+   return(TRUE);                        /* returns the popped value in v */
+}
+
+
+/* stop the evaluation of the expression at node n. 
+ * useful with operators like first().
+ * each node keeps an internal state allowing it to produce the next value.
+ * this function resets those states. 
+ *
+ * How: the internal state is kept in n->eval.level. we reset level to zero
+ *      for the node and the subnodes. if the level is already zero,
+ *      the node has already gone to the 'initial state', so the subnodes
+ *      are not visited.
+ */
+
+LPROC stop_eval(tnode *n)
+{
+   int i;
+   if(n==NULL || n->eval.level==0) return ; /* done! subnodes are also ok */
+   n->eval.level=0 ; 
+   for(i=0 ; i<NODE_MAX_KIDS ; i++) stop_eval(n->kids[i]);
+}
+
+/* evaluate function paramaters. This recursive function should be called
+ * with the top node for the parms. Parms are parsed as "," operators.
+ * the function leaves the computed values "hanging" on v1 of each "," node.
+ * the last paramater is left at v2 of the function call itself (there isnt
+ * any other reasonable place!). 
+ * 2nd paramater is the function call node, used for the last paramater.
+ */
+
+LFUNC bool eval_func_parms(tnode *n,tnode *fn)
+{
+    tvalue *p= &n->eval.v1 ;
+    if(n->node_kind==NK_OP && n->op_kind==OPK_SBIN && n->op==',') {
+       while(n->eval.level==2 || duel_eval(n->kids[0],p)) {
+          n->eval.level=2 ;  /* left side active parm in p */
+          if(eval_func_parms(n->kids[1],fn)) goto ok;
+          n->eval.level=1 ;   /*re-eval */
+       }
+       return FALSE ;
+   }
+   else if(!duel_eval(n,p = &fn->eval.v2)) return FALSE;  /* last paramater */
+ok:
+   duel_standardize_func_parm(p); 
+   return TRUE ;
+}
+
+LFUNC bool eval_func_call(tnode *n,tvalue *v)
+{
+
+   tvalue *f= &n->eval.v1 ;
+   tvalue *parms[21];
+   int i,parms_no ;
+   tnode *p ;
+
+again:
+   if(n->kids[1]==NULL) {       /* no parms */
+       n->eval.level=1 ;
+       if(!duel_eval(n->kids[0],f)) return FALSE ;
+   }
+   else {
+      while(n->eval.level==2 || duel_eval(n->kids[0],f)) {
+        n->eval.level=2 ;  /* function in f */
+        if(eval_func_parms(n->kids[1],n)) goto ok;
+        n->eval.level=1 ;   /*re-eval func */
+      }
+      return FALSE ;
+    ok: ;
+   }
+
+   if(f->ctype->type_kind!=CTK_FUNC) duel_op_error("bad function call",0,f,0);
+
+   p=n->kids[1] ;                       /* collect paramaters now */
+   parms_no=0 ;
+   while(p && p->node_kind==NK_OP && p->op_kind==OPK_SBIN && p->op==',') {
+     parms[parms_no++]= &p->eval.v1 ;
+     p=p->kids[1] ;
+     if(parms_no>=20) duel_op_error("too many paramaters",0,0,0);
+   }
+   if(p) parms[parms_no++]= &n->eval.v2 ;       /* last paramater */
+
+   duel_target_func_call(f,parms,parms_no,v);
+   if(f->ctype->u.kid->type_kind==CTK_VOID) goto again ; /* no return vals */
+   duel_set_symb_val(v,"%s(",f,0);
+   for(i=0 ; i<parms_no ; i++) 
+      duel_set_symb_val(v,"%s%s,",v,parms[i]);
+   if(parms_no>0) v->symb_val[strlen(v->symb_val)-1]='\0' ; /*chop ',' tail*/
+   strcat(v->symb_val,")");
+   return TRUE ;
+}
+
+
+/* evaluate for special operators: those the produce more than one value,
+ * binary ones. ',' '..' etc
+ */
+
+LFUNC bool duel_eval_sbin(tnode *n,tvalue *v)
+{
+   tval_list *vl = &n->eval.vlist ;
+   tvalue y,*v1= &n->eval.v1, *v2= &n->eval.v2 ;
+   tnode *kid0 = n->kids[0], *kid1 = n->kids[1] ;
+   int vi ;
+   bool ok ;
+#define lev n->eval.level
+
+   duel_assert(n->node_kind==NK_OP && n->op_kind==OPK_SBIN);
+   switch(n->op) {
+   case OP_DECL:
+           duel_assert(kid0->node_kind==NK_NAME && kid1->node_kind==NK_CTYPE);
+           if(kid1->ctype->size<=0) duel_gen_error("illegal type size",0);
+           v->val_kind=VK_LVALUE ;
+           v->ctype=kid1->ctype ;
+           v->u.lvalue=duel_alloc_target_space(kid1->ctype->size);
+           strcpy(v->symb_val,kid0->name);
+           duel_set_alias(kid0->name,v);
+   break ;
+   case OP_DEF:
+           if(kid0->node_kind!=NK_NAME) 
+                duel_gen_error("left side of := must be a simple var",0);
+           if(!duel_eval(kid1,v)) return FALSE ;
+           duel_set_alias(kid0->name,v);
+           return TRUE ;
+   case ',':
+         if(lev==1 && duel_eval(kid0,v)) return TRUE ;
+         lev=2 ;
+         return duel_eval(kid1,v);
+   case ';':  
+         /*note: (x;) is not allowed in syntax, but is allowed here and 
+          *means eval x, return nothing. used by parser, e.g. terminating ';'
+          *produces no side effects 
+          */
+
+         if(lev==1) while(duel_eval(kid0,v)) ; /* eval all left size */
+         lev=2 ;
+         return duel_eval(kid1,v); 
+   break ;
+   case OP_IMP:  /* a=>b  for each _=eval(a) return eval(b) (with _ set) */
+             if(lev>1) goto im2 ;
+             for(;;) {
+                  if(!duel_eval(kid0,v1)) return FALSE ;
+                  lev=2 ;
+             im2: push_dot_stack(v1,0);
+                  ok=duel_eval(kid1,v);
+                  pop_dot_stack();
+                  if(ok) return TRUE ;
+             }
+   case OP_IF:  /* if(a) b  return eval(b) for each eval(a)!=0 */
+             if(lev>1) goto if2 ;
+             for(;;) {
+                  if(!duel_eval(kid0,v)) return FALSE ;
+                  if(!duel_mk_logical(v,"if(x)y")) continue ;
+                  lev=2 ;
+             if2: if(duel_eval(kid1,v)) return TRUE ;
+             }
+   case OP_OR:  /* a||b normal 'C' logical or */
+             if(lev>1) goto or2 ;
+             for(;;) {
+                  if(!duel_eval(kid0,v)) return FALSE ;
+                  if(duel_mk_logical(v,"x||y")) {lev=1 ; return TRUE ;}
+             or2: if(duel_eval(kid1,v)) {
+                    lev=2 ;
+                    duel_mk_logical(v,"y||x");
+                    return TRUE ;
+                  }
+             }
+   case OP_AND:  /* a&&b normal 'C' logical and */
+             if(lev>1) goto an2 ;
+             for(;;) {
+                  if(!duel_eval(kid0,v)) return FALSE ;
+                  if(!duel_mk_logical(v,"x&&y")) {lev=1 ; return TRUE ;}
+             an2: if(duel_eval(kid1,v)) {
+                    lev=2 ;
+                    duel_mk_logical(v,"y&&x");
+                    return TRUE ;
+                  }
+             }
+   case '.':  
+             if(lev>1) goto dt2 ;
+             for(;;) {
+                  if(!duel_eval(kid0,v1)) return FALSE ;
+                  *v2 = * v1 ;  /* copy value for the lookup */
+                  if(ctype_kind_func_ptr_like(v1->ctype))  /* func.x */ 
+                      duel_find_func_frame(v2,"x.y");
+                  else
+                  if(v1->val_kind!=VK_FVALUE)  /* type check frame or struct*/
+                      duel_get_struct_val(v1,"x.y");
+                  lev=2 ;
+             dt2: if(!eval_dot(kid1,v,".",v1,v2)) continue ;
+                  if(v->ctype!=v1->ctype || v->val_kind!=v1->val_kind ||
+		     v->u.lvalue != v1->u.lvalue || 
+                     strcmp(v->symb_val,v1->symb_val)!=0) /* check for x._ */
+                      duel_set_symb_val(v,"%s.%s",v1,v);
+                  return TRUE ;
+             }
+   case OP_ARR:
+             if(lev>1) goto ar2 ;
+             for(;;) {
+                  if(!duel_eval(kid0,v1)) return FALSE ;
+                  *v2 = *v1 ;           /* copy value for dereferencing */
+                  duel_get_struct_ptr_val(v2,"x->y");
+                  lev=2 ;
+             ar2: if(!eval_dot(kid1,v,"->",v1,v2)) continue ;
+                  if(v->ctype!=v1->ctype || v->val_kind!=v1->val_kind ||
+		     v->u.lvalue != v1->u.lvalue || 
+                     strcmp(v->symb_val,v1->symb_val)!=0) /* check for x->_ */
+                      duel_set_symb_val(v,"%s->%s",v1,v);
+                  return TRUE ;
+             }
+   case OP_TO:  /* a..b  Is it legal to have 1..(5,6) sure! */
+         if(lev>1) goto to2 ;
+         do {
+             if(kid0 && !duel_eval(kid0,v1)) break ;
+             do {
+               if(kid1 && !duel_eval(kid1,v2)) break ;
+         to2:  if(duel_do_op_to(kid0? v1:0,kid1? v2:0,++lev-2,v)) return TRUE;
+             } while(kid1);
+         } while(kid0) ;  /* either one (kid0 null) or infinite iterations*/
+   break ;
+   case OP_SEL:          /* x[[y]] */
+           if(lev==1) { lev=2 ; n->eval.counter= -1 ; }
+           if(!duel_eval(kid1,v1)) {
+               stop_eval(kid0);
+               return FALSE ;
+           }
+           vi=duel_get_posint_val(v1,"y[[x]]");
+           if(vi<=n->eval.counter) {
+                   /* v is smaller than previous v value, so reset x and
+                    * start over. Example: \x[1,5,3] after \x[1],
+                    * we continue to get [5]. but to get [3] we reset
+                    * Alternatively, we could have kept a list of old
+                    * generated values.
+                    */
+               stop_eval(kid0) ;
+               n->eval.counter= -1 ;
+           }
+           for( ; n->eval.counter<vi ; n->eval.counter++) 
+               if(!duel_eval(kid0,v)) 
+                   duel_op_error("operator x of y[[x]] too large",0,v1,0);
+           return TRUE ; /* value is the last (v) computed */
+   break ;
+   case '@':             /* x@y - generate x stops when y true */
+           if(!duel_eval(kid0,v)) return FALSE ;
+           if(kid1->node_kind==NK_CONST) {      /* special case y constant */
+               *v2=kid1->cnst ;
+               *v1= *v ;        /* because 'apply_bin_op' destroy its args */
+               duel_apply_bin_op(OP_EQ,v1,v2,&y);
+               if(y.u.rval_int) { stop_eval(kid0); return FALSE ; }
+               return TRUE ;
+           }
+           *v1 = *v ;           /* allow fields in y of x@y for x struct ptr */
+           if(ctype_kind_ptr_like(v->ctype) && 
+              ctype_kind_struct_like(v->ctype->u.kid))
+               duel_get_struct_ptr_val(v1,"x@y");
+
+           while(eval_dot(kid1,v2,"@",v,v1)) /* check &&/y */
+               if(!duel_mk_logical(v2,"y@x")) {  /* y==0, so dont stop x */
+                   stop_eval(kid1);
+                   return TRUE ;
+               }
+           stop_eval(kid0); 
+    break ;
+    case '#':            /* x#i define variable i as counter for gen. x*/
+       if(kid1->node_kind!=NK_NAME) 
+               duel_gen_error("x#y 2rd operand must be a name",0);
+       if(!duel_eval(kid0,v)) return FALSE ;
+       if(lev==1) { lev=2 ; n->eval.counter= -1 ; } /* first time */
+       y.val_kind=VK_RVALUE ;
+       y.ctype=ctype_int ;
+       y.u.rval_int= ++n->eval.counter ;
+       sprintf(y.symb_val,"%d",n->eval.counter);
+       duel_set_alias(kid1->name,&y);
+       return TRUE ;
+   break ;
+   case OP_DFS:          /* x-->y */
+       if(lev>1) goto df2 ;
+       for(;;) {
+            if(!duel_eval(kid0,v)) return FALSE ;
+            duel_free_val_list(vl);
+            push_val(vl,v);
+            lev=2 ;
+       df2: if(get_next_dfs_val(vl,kid1,v)) return TRUE ;
+       }
+   break ;
+   case OP_WHILE:       /* while(a) b  */
+             if(lev==2) goto wh2 ;
+             for(;;) {
+                  while(duel_eval(kid0,v)) /* check &&/a */
+                    if(!duel_mk_logical(v,"while(x)y")) {
+                       stop_eval(kid0);
+                       return FALSE ;
+                    }
+                  lev=2 ;
+             wh2: if(duel_eval(kid1,v)) return TRUE ;
+             }
+   default: duel_assert(0);
+   }
+   return FALSE ;
+#undef lev
+}
+
+
+
+LFUNC bool duel_eval_tri(tnode *n,tvalue *v)
+{
+#define lev n->eval.level
+   duel_assert(n->node_kind==NK_OP && n->op_kind==OPK_TRI);
+   switch(n->op) {
+   case OP_IF:  /* if(a) b else c return eval(b) for each eval(a)!=0
+                 * and eval(c) for each eval(a)==0 (usu. (a) is one result*/
+             if(lev>1) goto if2;
+             for(;;) {
+                   if(!duel_eval(n->kids[0],v)) return FALSE ;
+                   lev=(duel_mk_logical(v,"if(x) y else z")? 2:3) ;
+              if2: if(duel_eval(n->kids[lev-1],v)) return TRUE ;
+             }
+   case '?':    /* a? b:c has the same semantics as if(a) b else c */
+             if(lev>1) goto qm2;
+             for(;;) {
+                   if(!duel_eval(n->kids[0],v)) return FALSE ;
+                   lev=(duel_mk_logical(v,"x? y:z")? 2:3) ;
+              qm2: if(duel_eval(n->kids[lev-1],v)) return TRUE ;
+             }
+   default: duel_assert(0);
+   }
+   return FALSE ;
+#undef lev
+}
+
+LFUNC bool duel_eval_quad(tnode *n,tvalue *v)
+{
+#define lev n->eval.level
+   duel_assert(n->node_kind==NK_OP && n->op_kind==OPK_QUAD);
+   switch(n->op) {
+   case OP_FOR: /* for(a;b;c) d ;  */
+             if(lev==1) { lev=2 ; while(duel_eval(n->kids[0],v)); }
+             if(lev==3) goto fr3 ;
+             for(;;) {
+                  while(duel_eval(n->kids[1],v)) /* check &&/b */
+                    if(!duel_mk_logical(v,"for(a;x;y)z")) {
+                       stop_eval(n->kids[1]);
+                       return FALSE ;
+                    }
+                  lev=3 ;
+             fr3: if(duel_eval(n->kids[3],v)) return TRUE ;
+                  while(duel_eval(n->kids[2],v));
+             }
+   default: duel_assert(0);
+   }
+   return FALSE ;
+#undef lev
+}
+
+FUNC bool duel_eval(tnode *n,tvalue *v)
+{
+   tvalue u,tmp ;
+   bool ok=FALSE ;
+   tnode *prev_loc ;
+
+   if(!n) return FALSE ;
+   prev_loc=duel_set_eval_loc(n);        /* set current eval node, save prev */
+   if(n->eval.level==0) n->eval.level=1 ; /* indicate node is 'active' */
+
+   switch(n->node_kind) {
+      case NK_CONST: /* return a 'value' node made of this constant */
+         if(n->eval.level==1) {
+            n->eval.level=2 ;
+            *v=n->cnst ;
+            ok=TRUE ;
+         }
+      break ;
+      case NK_NAME:
+         if(n->eval.level==1) {
+            n->eval.level=2 ;
+            duel_eval_name(n->name,v);
+            ok=TRUE ;
+         }
+      break ;
+      case NK_OP:
+         switch(n->op_kind) {
+          case OPK_SUNARY:              /* special unary ops */
+             if(n->op=='#') {
+                 int count=0 ;
+                 if(n->eval.level==1) {
+                     while(duel_eval(n->kids[0],&u)) 
+		       if(count++ == 0) duel_set_symb_val(v,"#/(%s ...)",&u,0);
+		     if(count == 0) duel_set_symb_val(v,"#/(empty)",0,0);
+                     v->val_kind=VK_RVALUE ;
+                     v->ctype=ctype_int ;
+                     v->u.rval_int=count ;
+                     n->eval.level=2 ;
+                     ok=TRUE ;
+                 }
+             }
+             else 
+             if(n->op==OP_AND) {
+                 if(n->eval.level==1) { int result=1 ;
+                     while(duel_eval(n->kids[0],v)) {
+                         if(!duel_mk_logical(v,"&&/x")) {
+                             stop_eval(n->kids[0]);
+                             result=0 ;
+                             break ;
+                         }
+                     }
+                     v->val_kind=VK_RVALUE ;
+                     v->ctype=ctype_int ;
+                     v->u.rval_int=result ;
+                     sprintf(v->symb_val,"%d",result);
+                     n->eval.level=2 ;
+                     ok=TRUE ;
+                 }
+             }
+             else 
+             if(n->op==OP_OR) {
+                 if(n->eval.level==1) { int result=0 ;
+                     while(duel_eval(n->kids[0],v)) {
+                         if(duel_mk_logical(v,"||/x")) {
+                             stop_eval(n->kids[0]);
+                             result=1 ;
+                             break ;
+                         }
+                     }
+                     v->val_kind=VK_RVALUE ;
+                     v->ctype=ctype_int ;
+                     v->u.rval_int=result ;
+                     sprintf(v->symb_val,"%d",result);
+                     n->eval.level=2 ;
+                     ok=TRUE ;
+                 }
+             }
+             else 
+             if(n->op==OP_SIZ) {
+                 if(n->eval.level==1) {
+		     char *tname=n->kids[0]->ctype->name ;
+                     duel_assert(n->kids[0]->node_kind==NK_CTYPE);
+                     v->val_kind=VK_RVALUE ;
+                     v->ctype=ctype_size_t ;
+                     v->u.rval_size_t=n->kids[0]->ctype->size ;
+                     n->eval.level=2 ; 
+		     if(tname==NULL || *tname=='\0') tname="T" ; /* cheating */
+		     sprintf(v->symb_val,"sizeof(%s)",tname);
+                     ok=TRUE ;
+                 }
+             }
+             else duel_assert(0);
+          break ;
+          case OPK_UNARY:
+            if(!duel_eval(n->kids[0],v)) break ;
+            duel_apply_unary_op(n->op,v);
+            ok=TRUE ;
+          break ;
+          case OPK_POST_UNARY:
+            if(!duel_eval(n->kids[0],v)) break ;
+            duel_apply_post_unary_op(n->op,v);
+            ok=TRUE ;
+          break ;
+          case OPK_BIN:    /* a+b, compute and hold a, iterate on b, redo a */
+             while(n->eval.level==2 || duel_eval(n->kids[0],&n->eval.v1)) {
+                n->eval.level=2 ;  /* left side active op in vals[0] */
+                while(duel_eval(n->kids[1],&u)) {
+                  tmp= n->eval.v1 ;  /* copy left val, it is destoryed*/
+                  ok=duel_apply_bin_op(n->op,&tmp,&u,v);
+                  if(ok) goto done;
+                }
+                n->eval.level=1 ;   /*left side val no longer valid, re-eval*/
+             }
+          break ;
+          case OPK_SBIN:   /* a,b etc, special ops */
+             ok=duel_eval_sbin(n,v) ;
+          break ;
+          case OPK_TRI: 
+             ok=duel_eval_tri(n,v) ;
+          break ;
+          case OPK_QUAD: 
+             ok=duel_eval_quad(n,v) ;
+          break ;
+          case OPK_CAST:
+             duel_assert(n->kids[0]->node_kind==NK_CTYPE);
+             if(!duel_eval(n->kids[1],v)) break ;
+             duel_do_cast(n->kids[0]->ctype,v);
+             ok=TRUE ;
+          break ;
+          case OPK_ASSIGN: 
+             duel_gen_error("modified assignment is not supported yet",0);
+          case OPK_FUNC: 
+             ok=eval_func_call(n,v) ;
+          break ;
+          default: duel_assert(0);
+         }
+      break ;
+      default: duel_assert(0);
+   }
+done:
+   if(!ok) n->eval.level=0 ;  /* no other val available */
+   duel_set_eval_loc(prev_loc);
+   return ok ;
+}
+
+
--- gdb/duel/evalops.c
+++ gdb/duel/evalops.c
@@ -0,0 +1,1273 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code                            */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* this module contains evalauation code for many standard operators, eg '+'
+ */
+
+/*
+ * $Log: 10_all_gdb-6.6-duel.patch,v $
+ * Revision 1.1  2007/12/29 21:06:06  vapier
+ * add DUEL support #199987 by Sergei Golubchik
+ *
+ * Revision 1.14  93/03/19  15:40:17  mg
+ * fixed bug long symbolics handling
+ * 
+ * Revision 1.13  93/03/12  05:50:01  mg
+ * uses tuint instead of uint, etc.
+ * 
+ * Revision 1.12  93/02/26  05:00:13  mg
+ * fixed void pointers compare. ctype_voidptr is not unique!
+ * 
+ * Revision 1.11  93/02/04  02:09:55  mg
+ * typo
+ * 
+ * Revision 1.10  93/02/04  01:24:51  mg
+ * better error reports for "="
+ * 
+ * Revision 1.9  93/02/03  21:47:43  mg
+ * support "signed char"
+ * 
+ * Revision 1.8  93/01/12  21:51:29  mg
+ * cleanup and set for release
+ * 
+ * Revision 1.7  93/01/07  00:10:51  mg
+ * auto convert func to &func
+ * find a frame for a func
+ * 
+ * 
+ * Revision 1.6  93/01/03  07:30:02  mg
+ * function calls, error reporting, printing.
+ * 
+ * Revision 1.5  92/12/24  23:34:47  mg
+ * frames support
+ * 
+ * Revision 1.4  92/10/19  15:07:46  mg
+ * fvalue added (not ready yet), svalues dropped
+ * 
+ * Revision 1.3  92/10/14  02:05:10  mg
+ * add print/{x} support
+ * 
+ * Revision 1.2  92/09/15  05:48:57  mg
+ * support '..' new formats
+ * 
+ */
+
+#include "duel.h"
+
+/*
+ * This file is made up of three parts:
+ * (1) low-level functions that interact with the debugger/type system directly
+ * (2) mid-level functions that compute the result of simple operators like '+'
+ * (3) high-level functions that compute any binary/unary op.
+ * Only some of the functions in (1) are global, and all of the (3) are.
+ * this collection is in one file to allow a minimal of global symbols
+ * (for minimum collision with the debugger)
+ */
+
+
+
+/****************************************************************************
+ A low-level set of functions follows. They interact with the type system
+ and the debugger/target's space directly:
+ get_storage_type_kind - retrieve ctype_kind, with special conversion for enums
+ get_rvalue - retrieve the rvalue of a variable/lvalue.
+ set_symb_val - set the symbolic value of a tvalue.
+ upgrade_small_int_types - figure out the type to upgrade to from char etc.
+ find_numeric_result_type - figure type of x+y where + is generic C op
+ convert_scalar_type - convert one scalar type to another
+ get_numeric_val - retrieve rvalue, making sure it is numeric
+ get_scalar_val  - retrieve rvalue, making sure it is numeric or pointer
+ get_integral_val- retrieve rvalue, making sure it is an integer
+ get_int_val     - retrieve rvalue, make sure it's an integer, return int val
+ get_pointer_val - retrieve rvalue, make sure it's a pointer.
+ ****************************************************************************/ 
+
+/* give the storage-type kind of a given type. 
+ * this is the same type-kind as the type itslef, except in the case of enums
+ * where the type-kind of the storage will be CTK_INT etc (integral type)
+ * the storage type kind is set when the enum is created.
+ */
+
+LFUNC tctype_kind get_storage_type_kind(tctype *t)
+{
+    if(t->type_kind!=CTK_ENUM) return t->type_kind ;
+    return t->u.e.real_type_kind ;
+}
+
+/* try_get_rvalue -- make an rvalue of v. if v is already an rvalue, 
+ * nothing is done. Else v is an b/lvalue, so its rvalue is fetched.
+ * special care:
+ * (1) Enums are fetched as int of same size. type stay enum!
+ * (2) Arrays and functions are made into pointers
+ * (3) Bitfields are converted to ints (debugger dependent)
+ *     there are no rvalues of 'bitfield' type!
+ * return succ/fail for bad mem ref. the "real" function everyone calls is
+ * get_rvalue (this function is used only by printing functions to avoid
+ * chicken&egg problem of error reporting.)
+ */
+
+FUNC duel_try_get_rvalue(tvalue *v,char *op)
+{
+   void *p ;
+   int n ;
+   bool ok;
+   if(v->val_kind == VK_RVALUE) return TRUE;
+   if(v->val_kind == VK_FVALUE) 
+       duel_op_error("illegal type 'frame' for operand x of '%s'",op,v,0);
+   switch(get_storage_type_kind(v->ctype)) {
+      case CTK_CHAR:    p= &v->u.rval_char   ; n=sizeof(char)         ;break ;
+      case CTK_SCHAR:   p= &v->u.rval_schar  ; n=sizeof(tschar)       ;break ;
+      case CTK_UCHAR:   p= &v->u.rval_uchar  ; n=sizeof(tuchar)       ;break ;
+      case CTK_USHORT:  p= &v->u.rval_ushort ; n=sizeof(tushort)      ;break ;
+      case CTK_SHORT:   p= &v->u.rval_short  ; n=sizeof(short)        ;break ;
+      case CTK_INT:     p= &v->u.rval_int    ; n=sizeof(int)          ;break ;
+      case CTK_UINT:    p= &v->u.rval_uint   ; n=sizeof(tuint)        ;break ;
+      case CTK_LONG:    p= &v->u.rval_long   ; n=sizeof(long)         ;break ;
+      case CTK_ULONG:   p= &v->u.rval_ulong  ; n=sizeof(tulong)       ;break ;
+      case CTK_LONGLONG:p= &v->u.rval_longlong ; n=sizeof(long long)  ;break ;
+      case CTK_ULONGLONG:p= &v->u.rval_ulonglong;n=sizeof(tulonglong) ;break ;
+      case CTK_FLOAT:   p= &v->u.rval_float  ; n=sizeof(float)        ;break ;
+      case CTK_DOUBLE:  p= &v->u.rval_double ; n=sizeof(double)       ;break ;
+      case CTK_PTR:     p= &v->u.rval_ptr    ; n=sizeof(ttarget_ptr) ;break ;
+      case CTK_ARRAY:   /* the lvalue becomes an rvalue, a real pointer! */
+                 duel_assert(v->val_kind==VK_LVALUE); /* duel exp rules */
+                 v->val_kind=VK_RVALUE ;
+                 v->ctype=duel_mkctype_ptr(v->ctype->u.kid) ;
+                 v->u.rval_ptr=v->u.lvalue ;
+                 return TRUE;   
+      case CTK_FUNC:   /* makes it a pointer to a func*/
+                 duel_assert(v->val_kind==VK_LVALUE); /* duel exp rules */
+                 v->val_kind=VK_RVALUE ;
+                 v->ctype=duel_mkctype_ptr(v->ctype) ;
+                 v->u.rval_ptr=v->u.lvalue ;
+                 return TRUE;   
+
+      case CTK_STRUCT: /* can't have an rval from struct? */
+      case CTK_UNION:  
+      /* enums were eliminated above */
+      default: duel_assert(0);
+   }
+   if(v->val_kind == VK_BVALUE) {        /* bitfield: lvalue+bitpos/len */
+       tbvalue_info bv; 
+       bv=v->u.bvalue ;
+       ok=duel_get_target_bitfield(bv.lvalue, bv.bitpos, bv.bitlen, p,
+                                    v->ctype->type_kind);
+       if(!ok) { v->u.bvalue=bv ; return FALSE ; } 
+   }
+   else {
+       ttarget_ptr lv=v->u.lvalue ;
+       ok=duel_get_target_bytes(lv,p,n); /*fetch n debuggee bytes*/
+       if(!ok) { v->u.lvalue=lv ; return FALSE ; }
+   }
+
+   v->val_kind=VK_RVALUE ;
+   /* in remote debugging, one might need to swap byte order at this
+    * point. [remote debugging is not supported by duel v1.0]
+    */
+   return TRUE ;
+}
+
+
+/*
+ * safe get_rvalue - produce error messages on memory access failer.
+ */
+
+LPROC get_rvalue(tvalue *v,char *op)
+{
+   bool ok=duel_try_get_rvalue(v,op);
+   if(!ok) duel_op_error("illegal address for operand x of '%s'",op,v,0);
+}
+
+/* put_rvalue: put the rvalue of v2 into the location in v1.
+ * types are assumed to be the same.
+ */
+
+LPROC put_rvalue(tvalue *v1,tvalue *v2,char *op)
+{
+   void *p ;
+   int n ;
+   duel_assert(v1->val_kind!=VK_RVALUE);
+   duel_assert(v1->val_kind!=VK_FVALUE);
+   duel_assert(v2->val_kind==VK_RVALUE);
+   duel_assert(v1->ctype->size == v2->ctype->size);
+   switch(get_storage_type_kind(v2->ctype)) {
+      case CTK_CHAR:    p= &v2->u.rval_char   ; n=sizeof(char)         ;break ;
+      case CTK_SCHAR:   p= &v2->u.rval_schar  ; n=sizeof(tschar)       ;break ;
+      case CTK_UCHAR:   p= &v2->u.rval_uchar  ; n=sizeof(tuchar)       ;break ;
+      case CTK_USHORT:  p= &v2->u.rval_ushort ; n=sizeof(tushort)      ;break ;
+      case CTK_SHORT:   p= &v2->u.rval_short  ; n=sizeof(short)        ;break ;
+      case CTK_INT:     p= &v2->u.rval_int    ; n=sizeof(int)          ;break ;
+      case CTK_UINT:    p= &v2->u.rval_uint   ; n=sizeof(tuint)        ;break ;
+      case CTK_LONG:    p= &v2->u.rval_long   ; n=sizeof(long)         ;break ;
+      case CTK_ULONG:   p= &v2->u.rval_ulong  ; n=sizeof(tulong)       ;break ;
+      case CTK_LONGLONG:  p= &v2->u.rval_longlong  ; n=sizeof(long long);break ;
+      case CTK_ULONGLONG: p= &v2->u.rval_ulonglong ; n=sizeof(tulonglong);break ;
+      case CTK_FLOAT:   p= &v2->u.rval_float  ; n=sizeof(float)        ;break ;
+      case CTK_DOUBLE:  p= &v2->u.rval_double ; n=sizeof(double)       ;break ;
+      case CTK_PTR:     p= &v2->u.rval_ptr    ; n=sizeof(ttarget_ptr) ;break ;
+      default: duel_assert(0);  /* other types not supported as rvalues */
+   }
+   if(v1->val_kind == VK_BVALUE) 
+       duel_gen_error("assignment to bitfields is not yet supported",0);
+   else
+   if(!duel_put_target_bytes(v1->u.lvalue,p,n)) /*store n debuggee bytes*/
+       duel_op_error("cant write memory for operand x of '%s'",op,v1,0);
+}
+
+/* set the symbolic val for tvalue. input format is a sprintf,
+ * with v1,v2 being other values that show as '%s' in the format.
+ * v1,v2 can be zero if they are unused by the format.
+ */
+PROC duel_set_symb_val(tvalue *r,char *format,tvalue *v1,tvalue *v2)
+{
+   char s[3*VALUE_MAX_SYMBOLIC_SIZE];
+   sprintf(s,format,v1->symb_val,v2->symb_val);
+   s[VALUE_MAX_SYMBOLIC_SIZE-1]=0 ; /* chop as needed */
+   strcpy(r->symb_val,s);
+}
+
+/* given a small int type (short,char,enum) return the upgraded (int or 
+ * uint) type. Else return the original type
+ */
+LFUNC tctype* upgrade_small_int_types(tctype *t)
+{
+   switch(t->type_kind) {
+      case CTK_ENUM:
+      case CTK_CHAR:
+      case CTK_SCHAR:
+      case CTK_UCHAR:
+      case CTK_SHORT:
+                     return ctype_int ;
+      case CTK_USHORT:
+                     if(sizeof(tushort)==sizeof(int)) return ctype_uint ;
+                     else return ctype_int ;
+        default:
+                      return t ;    
+   }
+}
+
+/* find the type of the result of a generic numeric operation on
+ * v1,v2. This applies the standard C type upgrade rules.
+ * The type of the result is returned.
+ * r is setup so it can receive the result: an RVALUE of the specified
+ * type. Its symbolic value is also setup based on the symbolic value
+ * of v1 v2 and the operation op.
+ * Note: op is not used to figure out the numeric result, only
+ * the types of v1 and v2. As a side effect, the answer for x|y where
+ * y is a double will be given as double. it is up to the caller to
+ * verify that v1,v2 have meaningful types of this operation
+ * 
+ */
+
+LFUNC tctype* find_numeric_result_type(tvalue *v1,tvalue *v2,
+                                          tvalue *r,char *op)
+{
+    tctype *t1=upgrade_small_int_types(v1->ctype);   /* upgrade to int etc */
+    tctype *t2=upgrade_small_int_types(v2->ctype);
+    char s[80] ;
+    r->val_kind=VK_RVALUE ;
+    sprintf(s,"%%s%s%%s",op) ;  /* eg, if op=">>" then s becomes "%s>>%s" */
+    duel_set_symb_val(r,s,v1,v2);
+
+    if(t1==ctype_double || t2==ctype_double) return r->ctype=ctype_double ;
+    if(t1==ctype_float  || t2==ctype_float)  return r->ctype=ctype_float ;
+    if(t1==ctype_ulonglong  || t2==ctype_ulonglong)  return r->ctype=ctype_ulonglong ;
+    if(t1==ctype_longlong  || t2==ctype_longlong)  return r->ctype=ctype_longlong ;
+    if(t1==ctype_ulong  || t2==ctype_ulong)  return r->ctype=ctype_ulong ;
+    if(sizeof(unsigned)==sizeof(long) &&
+       (t1==ctype_long && t2==ctype_uint  ||
+        t1==ctype_uint && t2==ctype_long))    return r->ctype=ctype_ulong ;
+    if(t1==ctype_long  || t2==ctype_long)     return r->ctype=ctype_long ;
+    if(t1==ctype_uint  || t2==ctype_uint)     return r->ctype=ctype_uint ;
+    return r->ctype=ctype_int ;
+}
+
+/* convert_to_fix assisting-macro: takes the val stored in v and put it
+ * into w. w is an lvalue with a 'fixed' type (t).
+ */
+
+#define convert_to_fix(v,w)                          \
+     switch(get_storage_type_kind(v->ctype)) {         \
+      case CTK_CHAR:    w (v->u.rval_char)     ; break ; \
+      case CTK_SCHAR:   w (v->u.rval_schar)    ; break ; \
+      case CTK_UCHAR:   w (v->u.rval_uchar)    ; break ; \
+      case CTK_USHORT:  w (v->u.rval_ushort)   ; break ; \
+      case CTK_SHORT:   w (v->u.rval_short)    ; break ; \
+      case CTK_INT:     w (v->u.rval_int)      ; break ; \
+      case CTK_UINT:    w (v->u.rval_uint)     ; break ; \
+      case CTK_LONG:    w (v->u.rval_long)     ; break ; \
+      case CTK_ULONG:   w (v->u.rval_ulong)    ; break ; \
+      case CTK_LONGLONG:    w (v->u.rval_longlong)     ; break ; \
+      case CTK_ULONGLONG:   w (v->u.rval_ulonglong)    ; break ; \
+      case CTK_FLOAT:   w (v->u.rval_float)    ; break ; \
+      case CTK_DOUBLE:  w (v->u.rval_double)   ; break ; \
+      case CTK_PTR:     w (tptrsize_int) (v->u.rval_ptr) ; break ; \
+      default: duel_assert(0);                         \
+   }
+
+
+/* convert_scalar_type -- convert rvalue v to type t.
+ * uses convert_to_fix macro. In effect, this is a huge switch for
+ * all possible combinations of basic C types.
+ */
+
+LPROC convert_scalar_type(tvalue *v,tctype *t,char *op)
+{
+   get_rvalue(v,op);
+   switch(get_storage_type_kind(t)) {
+      case CTK_CHAR:   convert_to_fix(v,v->u.rval_char=(char))      ; break ;
+      case CTK_SCHAR:  convert_to_fix(v,v->u.rval_schar=(tschar))   ; break ;
+      case CTK_UCHAR:  convert_to_fix(v,v->u.rval_uchar=(tuchar))   ; break ;
+      case CTK_SHORT:  convert_to_fix(v,v->u.rval_short=(short))    ; break ;
+      case CTK_USHORT: convert_to_fix(v,v->u.rval_ushort=(tushort)) ; break ;
+      case CTK_INT:    convert_to_fix(v,v->u.rval_int=(int))        ; break ;
+      case CTK_UINT:   convert_to_fix(v,v->u.rval_uint=(tuint))     ; break ;
+      case CTK_LONG:   convert_to_fix(v,v->u.rval_long=(long))      ; break ;
+      case CTK_ULONG:  convert_to_fix(v,v->u.rval_ulong=(tulong))   ; break ;
+      case CTK_LONGLONG:   convert_to_fix(v,v->u.rval_longlong=(long long))      ; break ;
+      case CTK_ULONGLONG:  convert_to_fix(v,v->u.rval_ulonglong=(tulonglong))   ; break ;
+      case CTK_FLOAT:  convert_to_fix(v,v->u.rval_float=(float))    ; break ;
+      case CTK_DOUBLE: convert_to_fix(v,v->u.rval_double=(double))  ; break ;
+      case CTK_PTR:    convert_to_fix(v,
+                        v->u.rval_ptr=(ttarget_ptr)(tptrsize_int)) ; break ;
+      default: duel_assert(0);
+   }
+   v->ctype=t ;
+}
+
+
+/* verify v is numeric, get its rvalue converted to type tout or at least int*/
+LPROC get_numeric_val(tvalue *v,char *op,tctype *tout)
+{
+   if(!ctype_kind_numeric(v->ctype)) 
+       duel_op_error("operand x of '%s' is not numeric",op,v,0);
+   if(!tout) tout=upgrade_small_int_types(v->ctype);   /* upgrade to int etc */
+   convert_scalar_type(v,tout,op);
+}
+
+/*verify v is integral, get its rvalue converted to type tout or at least int*/
+LPROC get_integral_val(tvalue *v,char *op,tctype *tout)
+{
+   if(!ctype_kind_integral(v->ctype)) 
+       duel_op_error("operand x of '%s' is not integral",op,v,0);
+   if(!tout) tout=upgrade_small_int_types(v->ctype);   /* upgrade to int etc */
+   convert_scalar_type(v,tout,op);
+}
+
+/* verify v is integral, return its actual value as 'int' */
+FUNC int duel_get_int_val(tvalue *v,char *op)
+{
+   get_integral_val(v,op,ctype_int);
+   return v->u.rval_int ;
+}
+
+/* verify v is numeric or pointer/array, upgrade type to at least int or ptr
+   and get the rvalue */
+LPROC get_scalar_val(tvalue *v,char *op)
+{
+   if(ctype_kind_ptr_like(v->ctype)) get_rvalue(v,op);
+   else {
+       tctype *t=upgrade_small_int_types(v->ctype);   /* upgrade to int */
+       if(!ctype_kind_numeric(v->ctype)) 
+           duel_op_error("operand x of '%s' is not a scalar",op,v,0);
+       convert_scalar_type(v,t,op);
+   }
+}
+
+LPROC get_pointer_val(tvalue *v,char *op,bool zero_ok)
+{
+   if(ctype_kind_ptr_like(v->ctype)) get_rvalue(v,op);
+   else
+   if(zero_ok && v->ctype->type_kind==CTK_INT && 
+      v->val_kind==VK_RVALUE && v->u.rval_int==0) {
+           v->ctype=ctype_voidptr ;
+           v->u.rval_ptr=0 ;
+   }
+   else duel_op_error("operand x of '%s' is not a pointer",op,v,0);
+}
+
+/* copy one lvalue over the other. This copy is used for assignment,
+ * including the assignment of structures and unions.
+ * supports unlimited size and error reports when memory access fails.
+ */
+
+LPROC copy_lvalues(tvalue *v1,tvalue *v2,char *op)
+{
+    size_t size ;
+    ttarget_ptr to=v1->u.lvalue,from=v2->u.lvalue ;
+    char buf[BUFSIZ] ;
+    duel_assert(v1->val_kind==VK_LVALUE && v2->val_kind==VK_LVALUE);
+    size=v1->ctype->size ;
+    duel_assert(v2->ctype->size==size);
+    while(size!=0) {
+        size_t chunk_size=((size>BUFSIZ)? BUFSIZ:size) ;
+        if(!duel_get_target_bytes(from,buf,chunk_size))
+            duel_op_error("error reading memory (copy) in '%s'",op,v1,v2);
+        if(!duel_put_target_bytes(to,buf,chunk_size))
+            duel_op_error("error writing memory (copy) in '%s'",op,v1,v2);
+        size-=chunk_size ;
+        to+=chunk_size ;
+        from+=chunk_size ;
+    }
+}
+
+/*
+ * check that two values have "compatible" types.
+ * since structs compiled in different modules are each unique,
+ * we settle for comparing the number of references (array/ptr)
+ * and then  make sure the same type-kind is used, with the same
+ * physical size. 
+ * this allows, e.g. struct {short x,y }  and struct {int x}
+ * to be considered equal. Possibly one could compare struct/union
+ * for member sizes (but not names?!). this however requires to keep
+ * track of self references and is not implemented here.
+ */
+
+LPROC duel_check_type_eq(tvalue *v1,tvalue *v2,char *op)
+{
+    tctype *t1=v1->ctype, *t2=v2->ctype ;
+    if(ctype_kind_ptr_like(t1) && ctype_kind_ptr_like(t2) &&  /*(void*) match*/
+       (t1->u.kid==ctype_void || t2->u.kid==ctype_void)) return; 
+
+    while(ctype_kind_ptr_like(t1) && ctype_kind_ptr_like(t2)) 
+        t1=t1->u.kid, t2=t2->u.kid ;
+    if(t1==t2) return ; /* exact same type */
+    if(t1->type_kind != t2->type_kind || t1->size != t2->size) 
+        duel_op_error("incompatible types for op %s",op,v1,v2);
+}
+
+
+/**************************************************************************
+ a set of mid-level functions follow. These actually apply duel/C
+ operators to values 
+ **************************************************************************/
+
+/* these do pointer+int addition/subtraction of v1,v2 and store result in r.
+ * NOTE: r's symbolic value is not set.
+ */
+
+LPROC add_offset_to_ptr(tvalue *v1,tvalue *v2,tvalue *r)
+{
+   size_t len ;
+   get_pointer_val(v1,"x+y (ptr add)",FALSE);
+   get_integral_val(v2,"y+x (ptr add)",NULL);
+   r->val_kind=VK_RVALUE ;
+   r->ctype=v1->ctype ;
+   len=v1->ctype->u.kid->size ;
+   if(len==0) duel_op_error("unknown pointer object size for '+' op",0,v1,0);
+   switch(v2->ctype->type_kind) {
+    case CTK_INT:   r->u.rval_ptr =v1->u.rval_ptr +len*v2->u.rval_int  ;break ;
+    case CTK_UINT:  r->u.rval_ptr =v1->u.rval_ptr +len*v2->u.rval_uint ;break ;
+    case CTK_LONG:  r->u.rval_ptr =v1->u.rval_ptr +len*v2->u.rval_long ;break ;
+    case CTK_ULONG: r->u.rval_ptr =v1->u.rval_ptr +len*v2->u.rval_ulong;break ;
+    case CTK_LONGLONG:  r->u.rval_ptr =v1->u.rval_ptr +len*v2->u.rval_longlong ;break ;
+    case CTK_ULONGLONG: r->u.rval_ptr =v1->u.rval_ptr +len*v2->u.rval_ulonglong;break ;
+    default: duel_assert(0);
+   }
+}
+
+LPROC sub_offset_from_ptr(tvalue *v1,tvalue *v2,tvalue *r)
+{
+   size_t len ;
+   get_pointer_val(v1,"x-y (ptr sub)",FALSE);
+   get_integral_val(v2,"y-x (ptr sub)",NULL);
+   r->val_kind=VK_RVALUE ;
+   r->ctype=v1->ctype ;
+   len=v1->ctype->u.kid->size ;
+   if(len==0) duel_op_error("unknown pointer object size for '-' op",0,v1,0);
+   switch(v2->ctype->type_kind) {
+    case CTK_INT:   r->u.rval_ptr =v1->u.rval_ptr -len*v2->u.rval_int  ;break ;
+    case CTK_UINT:  r->u.rval_ptr =v1->u.rval_ptr -len*v2->u.rval_uint ;break ;
+    case CTK_LONG:  r->u.rval_ptr =v1->u.rval_ptr -len*v2->u.rval_long ;break ;
+    case CTK_ULONG: r->u.rval_ptr =v1->u.rval_ptr -len*v2->u.rval_ulong;break ;
+    case CTK_LONGLONG:  r->u.rval_ptr =v1->u.rval_ptr -len*v2->u.rval_longlong ;break ;
+    case CTK_ULONGLONG: r->u.rval_ptr =v1->u.rval_ptr -len*v2->u.rval_ulonglong;break ;
+    default: duel_assert(0);
+   }
+}
+
+
+/* do addition of v1,v2 and store result in r.
+ * NOTE: v1, v2 are destroyed!
+ */
+LPROC do_op_add(tvalue *v1,tvalue *v2,tvalue *r)
+{
+   tctype *t=find_numeric_result_type(v1,v2,r,"+");
+   if(ctype_kind_ptr_like(v1->ctype)) {
+       get_integral_val(v2,"pointer+x",NULL);
+       add_offset_to_ptr(v1,v2,r);
+       return ;
+   }
+   if(ctype_kind_ptr_like(v2->ctype)) {
+       get_integral_val(v1,"x+pointer",NULL);
+       add_offset_to_ptr(v2,v1,r);
+       return ;
+   }
+   get_numeric_val(v1,"x+y",t);
+   get_numeric_val(v2,"y+x",t);
+   r->val_kind=VK_RVALUE ;
+   r->ctype=t ;
+   duel_set_symb_val(r,"%s+%s",v1,v2);
+   switch(t->type_kind) {
+    case CTK_INT:   r->u.rval_int  =v1->u.rval_int   +v2->u.rval_int   ;break ;
+    case CTK_UINT:  r->u.rval_uint =v1->u.rval_uint  +v2->u.rval_uint  ;break ;
+    case CTK_LONG:  r->u.rval_long =v1->u.rval_long  +v2->u.rval_long  ;break ;
+    case CTK_ULONG: r->u.rval_ulong=v1->u.rval_ulong +v2->u.rval_ulong ;break ;
+    case CTK_LONGLONG:  r->u.rval_longlong =v1->u.rval_longlong  +v2->u.rval_longlong  ;break ;
+    case CTK_ULONGLONG: r->u.rval_ulonglong=v1->u.rval_ulonglong +v2->u.rval_ulonglong ;break ;
+    case CTK_FLOAT: r->u.rval_float=v1->u.rval_float +v2->u.rval_float ;break ;
+    case CTK_DOUBLE:r->u.rval_double=v1->u.rval_double+v2->u.rval_double;break;
+    default: duel_assert(0);
+   }
+}
+
+/* do arithmeric subtraction of v1,v2 and store result in r.
+ * v1 and v2 should be of numeric type to begin with.
+ * NOTE: v1, v2 are destroyed!
+ */
+LPROC do_op_subtract(tvalue *v1,tvalue *v2,tvalue *r)
+{
+   tctype *t=find_numeric_result_type(v1,v2,r,"-");
+   if(ctype_kind_ptr_like(v1->ctype)) {
+       if(ctype_kind_ptr_like(v2->ctype)) {
+           long len ;   /* length must be signed to allow signed p-q result*/
+           get_pointer_val(v1,"x-y",FALSE);
+           get_pointer_val(v2,"x-y",FALSE);
+           duel_check_type_eq(v1,v2,"- (ptr)");
+           /* should compare pointer types */
+           len=v1->ctype->u.kid->size ;
+           if(len<=0) 
+              duel_op_error("illegal object size for op %s","- (ptr)",v1,v2);
+           r->ctype=ctype_ptrdiff_t ;
+           r->u.rval_ptrdiff_t= (v1->u.rval_ptr - v2->u.rval_ptr)/len ;
+           return ;
+       }
+       get_integral_val(v2,"pointer-x",NULL);
+       sub_offset_from_ptr(v1,v2,r);
+       return ;
+   }
+   get_numeric_val(v1,"x-y",t);
+   get_numeric_val(v2,"y-x",t);
+   switch(t->type_kind) {
+    case CTK_INT:   r->u.rval_int  =v1->u.rval_int   - v2->u.rval_int   ;break;
+    case CTK_UINT:  r->u.rval_uint =v1->u.rval_uint  - v2->u.rval_uint  ;break;
+    case CTK_LONG:  r->u.rval_long =v1->u.rval_long  - v2->u.rval_long  ;break;
+    case CTK_ULONG: r->u.rval_ulong=v1->u.rval_ulong - v2->u.rval_ulong ;break;
+    case CTK_LONGLONG:  r->u.rval_longlong =v1->u.rval_longlong  - v2->u.rval_longlong  ;break;
+    case CTK_ULONGLONG: r->u.rval_ulonglong=v1->u.rval_ulonglong - v2->u.rval_ulonglong ;break;
+    case CTK_FLOAT: r->u.rval_float=v1->u.rval_float - v2->u.rval_float ;break;
+    case CTK_DOUBLE:r->u.rval_double=v1->u.rval_double-v2->u.rval_double;break;
+    default: duel_assert(0);
+   }
+}
+
+/* compare values of v1 and v2, knowing that at least one is a frame-value
+ * type. Allows two fvals to be compared, or an fval to be compared
+ * to a func (this compares the func at the frame to the given func)
+ */
+
+LFUNC bool comp_bin_op_eq_fvals(tvalue *v1,tvalue *v2)
+{
+   bool v1f=v1->val_kind == VK_FVALUE ;
+   bool v2f=v2->val_kind == VK_FVALUE ;
+   int frame_no ;
+   ttarget_ptr frame_func,p ;
+   if(v1f && v2f) return v1->u.fvalue == v2->u.fvalue ; /*cmp frames */
+   if(v1f) { 
+       frame_no = v1->u.fvalue ;
+       get_pointer_val(v2,"frame==x",FALSE) ;
+       if(v2->ctype->u.kid->type_kind!=CTK_FUNC) 
+          duel_op_error("operand x of 'frame=x' not a func pointer",0,v2,0);
+       p=v2->u.rval_ptr ;
+   }
+   else {
+       frame_no = v2->u.fvalue ;
+       get_pointer_val(v1,"x==frame",FALSE) ;
+       if(v1->ctype->u.kid->type_kind!=CTK_FUNC) 
+          duel_op_error("operand x of 'x==frame' not a func pointer",0,v1,0);
+       p=v1->u.rval_ptr ;
+   }
+   frame_func = duel_get_function_for_frame(frame_no);
+   return frame_func == p ; 
+}
+
+
+/* compares of v1,v2 and store result in r.
+ * v1 and v2 should be of numeric/pointer type to begin with.
+ * NOTE: v1, v2 are destroyed!
+ */
+
+LPROC do_op_eq(tvalue *v1,tvalue *v2,tvalue *r)
+{                                                              
+   tctype *t=find_numeric_result_type(v1,v2,r,"==");            
+   r->ctype=ctype_int ;                                        
+   if(v1->val_kind==VK_FVALUE || v2->val_kind==VK_FVALUE) {
+       r->u.rval_int = comp_bin_op_eq_fvals(v1,v2);
+       return ;
+   }
+   if(ctype_kind_ptr_like(v1->ctype) || ctype_kind_ptr_like(v2->ctype)) {
+       get_pointer_val(v1,"x==y",TRUE); 
+       get_pointer_val(v2,"y==x",TRUE);       
+       duel_check_type_eq(v1,v2,"==");          
+       r->u.rval_int = v1->u.rval_ptr == v2->u.rval_ptr ;
+       return ;                                 
+   }                                            
+   get_numeric_val(v1,"x==y",t);                   
+   get_numeric_val(v2,"y==x",t);                   
+   switch(t->type_kind) {                       
+   case CTK_INT:   r->u.rval_int=v1->u.rval_int    == v2->u.rval_int   ;break;
+   case CTK_UINT:  r->u.rval_int=v1->u.rval_uint   == v2->u.rval_uint  ;break;
+   case CTK_LONG:  r->u.rval_int=v1->u.rval_long   == v2->u.rval_long  ;break;
+   case CTK_ULONG: r->u.rval_int=v1->u.rval_ulong  == v2->u.rval_ulong ;break;
+   case CTK_LONGLONG:  r->u.rval_int=v1->u.rval_longlong   == v2->u.rval_longlong  ;break;
+   case CTK_ULONGLONG: r->u.rval_int=v1->u.rval_ulonglong  == v2->u.rval_ulonglong ;break;
+   case CTK_FLOAT: r->u.rval_int=v1->u.rval_float  == v2->u.rval_float ;break;
+   case CTK_DOUBLE:r->u.rval_int=v1->u.rval_double == v2->u.rval_double;break;
+   default: duel_assert(0);                                     
+   }                                                            
+}
+
+
+/* compares of v1,v2 and store result in r.
+ * v1 and v2 should be of numeric/pointer type to begin with.
+ * NOTE: v1, v2 are destroyed!
+ */
+#define mk_func_compare(func,op,sop,xysop,yxsop,nullok) \
+LPROC func(tvalue *v1,tvalue *v2,tvalue *r)                    \
+{                                                              \
+   tctype *t=find_numeric_result_type(v1,v2,r,sop);             \
+   r->ctype=ctype_int ;                                         \
+                                                                \
+   if(ctype_kind_ptr_like(v1->ctype) || ctype_kind_ptr_like(v2->ctype)) { \
+       get_pointer_val(v1,xysop,nullok);                        \
+       get_pointer_val(v2,yxsop,nullok);                        \
+       duel_check_type_eq(v1,v2,sop);                           \
+       r->u.rval_int = v1->u.rval_ptr op v2->u.rval_ptr ;       \
+       return ;                                                 \
+   }                                                            \
+   get_numeric_val(v1,xysop,t);                                 \
+   get_numeric_val(v2,yxsop,t);                                 \
+   switch(t->type_kind) {                                       \
+   case CTK_INT:   r->u.rval_int=v1->u.rval_int    op v2->u.rval_int   ;break;\
+   case CTK_UINT:  r->u.rval_int=v1->u.rval_uint   op v2->u.rval_uint  ;break;\
+   case CTK_LONG:  r->u.rval_int=v1->u.rval_long   op v2->u.rval_long  ;break;\
+   case CTK_ULONG: r->u.rval_int=v1->u.rval_ulong  op v2->u.rval_ulong ;break;\
+   case CTK_LONGLONG:  r->u.rval_int=v1->u.rval_longlong   op v2->u.rval_longlong  ;break;\
+   case CTK_ULONGLONG: r->u.rval_int=v1->u.rval_ulonglong  op v2->u.rval_ulonglong ;break;\
+   case CTK_FLOAT: r->u.rval_int=v1->u.rval_float  op v2->u.rval_float ;break;\
+   case CTK_DOUBLE:r->u.rval_int=v1->u.rval_double op v2->u.rval_double;break;\
+   default: duel_assert(0);                                     \
+   }                                                            \
+}
+
+mk_func_compare(do_op_ne,!=,"!=","x!=y","y!=x",TRUE)
+mk_func_compare(do_op_ge,>=,">=","x>=y","y>=x",FALSE)
+mk_func_compare(do_op_le,<=,"<=","x<=y","y<=x",FALSE)
+mk_func_compare(do_op_ls,<, "<", "x<y", "y<x",FALSE)
+mk_func_compare(do_op_gt,>, ">", "x>y", "y>x",FALSE)
+#undef mk_func_compare 
+
+
+/* do_compare_questionmark -- handle the <? >? etc ops */
+
+LFUNC bool do_compare_questionmark(topcode op,tvalue *v1,tvalue *v2,tvalue *r)
+{
+   tvalue tmp ;
+   tmp= *v1 ; 
+   switch(op) {
+     case OP_EQQ: do_op_eq(v1,v2,r); break ;
+     case OP_NEQ: do_op_ne(v1,v2,r); break ;
+     case OP_GEQ: do_op_ge(v1,v2,r); break ;
+     case OP_LEQ: do_op_le(v1,v2,r); break ;
+     case OP_LSQ: do_op_ls(v1,v2,r); break ;
+     case OP_GTQ: do_op_gt(v1,v2,r); break ;
+   }
+   if(r->u.rval_int==0) return FALSE ;
+   *r=tmp ;
+   return TRUE ;
+}
+
+
+
+/* apply indirection of a pointer.
+ * this  is easy, you just force the value to be an rvalue pointer, then 
+ * make it into an lvalue with the pointed-to type.
+ * useful for (*x x[y] x->y etc)
+ * does not setup a symbolic value!
+ */
+
+
+LPROC follow_pointer(tvalue *v,char *op,bool nonull)
+{
+   get_pointer_val(v,op,FALSE);
+   if(nonull && v->u.rval_ptr == NULL)
+        duel_op_error("dereference NULL pointer x in '%s'",op,v,0);
+   v->val_kind=VK_LVALUE ;
+   v->u.lvalue=v->u.rval_ptr ;
+   v->ctype=v->ctype->u.kid ;
+}
+
+PROC duel_get_struct_val(tvalue *v,char *op)
+{
+   if(!ctype_kind_struct_like(v->ctype)) 
+       duel_op_error("operand x of '%s' not a sturct/union",op,v,0);
+   duel_assert(v->val_kind==VK_LVALUE);
+}
+
+PROC duel_get_struct_ptr_val(tvalue *v,char *op)
+{
+   follow_pointer(v,op,FALSE);
+   if(!ctype_kind_struct_like(v->ctype)) 
+     duel_op_error("operand x of '%s' not a pointer to sturct/union",op,v,0);
+}
+
+FUNC int duel_get_posint_val(tvalue *v,char *op)    
+{
+    int x ;
+    x=duel_get_int_val(v,op);
+    if(x<0) duel_op_error("operand x of '%s' can not be negative",op,v,0);
+   return x ;
+}
+
+/* indirection operator (*x) */
+
+LPROC do_op_indirection(tvalue *v)
+{
+   follow_pointer(v,"*x",TRUE);
+   duel_set_symb_val(v,"*%s",v,0);
+}
+
+/* address operator (&x) 
+ * x must be an lvalue. it is converted into a pointer to the given type,
+ * an rvalue.
+ */
+
+LPROC do_op_address(tvalue *v)
+{
+   if(v->val_kind != VK_LVALUE) 
+       duel_op_error("operand x of '&x' is not a lvalue",0,v,0);
+   v->val_kind=VK_RVALUE ;
+   v->u.rval_ptr=v->u.lvalue ;
+   v->ctype=duel_mkctype_ptr(v->ctype);
+   duel_set_symb_val(v,"&%s",v,0);
+}
+
+LPROC do_op_index(tvalue *v1,tvalue *v2,tvalue *r)
+{
+    get_pointer_val(v1,"x[y]",FALSE);
+    get_integral_val(v2,"y[x]",NULL);
+    add_offset_to_ptr(v1,v2,r);
+    follow_pointer(r,"[]",TRUE);
+    duel_set_symb_val(r,"%s[%s]",v1,v2);
+}
+
+
+/* do arithmeric multiply of v1,v2 and store result in r.
+ * NOTE: v1, v2 are destroyed!
+ */
+LPROC do_op_multiply(tvalue *v1,tvalue *v2,tvalue *r)
+{
+   tctype *t=find_numeric_result_type(v1,v2,r,"*");
+   get_numeric_val(v1,"x*y",t);
+   get_numeric_val(v2,"y*x",t);
+   r->val_kind=VK_RVALUE ;
+   r->ctype=t ;
+   duel_set_symb_val(r,"%s*%s",v1,v2);
+   switch(t->type_kind) {
+    case CTK_INT:   r->u.rval_int   =v1->u.rval_int   * v2->u.rval_int  ;break;
+    case CTK_UINT:  r->u.rval_uint  =v1->u.rval_uint  * v2->u.rval_uint ;break;
+    case CTK_LONG:  r->u.rval_long  =v1->u.rval_long  * v2->u.rval_long ;break;
+    case CTK_ULONG: r->u.rval_ulong =v1->u.rval_ulong * v2->u.rval_ulong;break;
+    case CTK_LONGLONG:  r->u.rval_longlong  =v1->u.rval_longlong  * v2->u.rval_longlong ;break;
+    case CTK_ULONGLONG: r->u.rval_ulonglong =v1->u.rval_ulonglong * v2->u.rval_ulonglong;break;
+    case CTK_FLOAT: r->u.rval_float =v1->u.rval_float * v2->u.rval_float;break;
+    case CTK_DOUBLE:r->u.rval_double=v1->u.rval_double*v2->u.rval_double;break;
+    default: duel_assert(0);
+   }
+}
+
+/* do numeric divide of v1,v2 and store result in r.
+ * v1 and v2 should be of numeric type to begin with.
+ * NOTE: v1, v2 are destroyed!
+ */
+LPROC do_op_divide(tvalue *v1,tvalue *v2,tvalue *r)
+{
+   tctype *t=find_numeric_result_type(v1,v2,r,"/");
+   get_numeric_val(v1,"x/y",t);
+   get_numeric_val(v2,"y/x",t);
+   switch(t->type_kind) {
+    case CTK_INT:   if(v2->u.rval_int==0) goto div_err;
+                    r->u.rval_int   =v1->u.rval_int  / v2->u.rval_int   ;break;
+    case CTK_UINT:  if(v2->u.rval_uint==0) goto div_err;
+                    r->u.rval_uint  =v1->u.rval_uint / v2->u.rval_uint  ;break;
+    case CTK_LONG:  if(v2->u.rval_long==0) goto div_err;
+                    r->u.rval_long  =v1->u.rval_long / v2->u.rval_long  ;break;
+    case CTK_ULONG: if(v2->u.rval_ulong==0) goto div_err;
+                    r->u.rval_ulong =v1->u.rval_ulong/ v2->u.rval_ulong ;break;
+    case CTK_LONGLONG:  if(v2->u.rval_longlong==0) goto div_err;
+                    r->u.rval_longlong  =v1->u.rval_longlong / v2->u.rval_longlong  ;break;
+    case CTK_ULONGLONG: if(v2->u.rval_ulonglong==0) goto div_err;
+                    r->u.rval_ulonglong =v1->u.rval_ulonglong/ v2->u.rval_ulonglong ;break;
+    case CTK_FLOAT: if(v2->u.rval_float==0.0) goto div_err;
+                    r->u.rval_float =v1->u.rval_float/ v2->u.rval_float ;break;
+    case CTK_DOUBLE:if(v2->u.rval_double==0.0) goto div_err;
+                    r->u.rval_double=v1->u.rval_double/v2->u.rval_double;break;
+    default: duel_assert(0);
+   }
+   return ;
+div_err: duel_op_error("division by zero",0,v1,v2);
+}
+
+
+/* do arithmeric reminder of v1,v2 and store result in r.
+ * NOTE: v1, v2 are destroyed!
+ */
+LPROC do_op_reminder(tvalue *v1,tvalue *v2,tvalue *r)
+{
+   tctype *t=find_numeric_result_type(v1,v2,r,"%");
+   get_integral_val(v1,"x%y",t);
+   get_integral_val(v2,"y%x",t);
+   switch(t->type_kind) {
+    case CTK_INT:    if(v2->u.rval_int==0) goto div_err;
+               r->u.rval_int   = v1->u.rval_int   % v2->u.rval_int    ; break ;
+    case CTK_UINT:   if(v2->u.rval_uint==0) goto div_err;
+               r->u.rval_uint  = v1->u.rval_uint  % v2->u.rval_uint   ; break ;
+    case CTK_LONG:   if(v2->u.rval_long==0) goto div_err;
+               r->u.rval_long  = v1->u.rval_long  % v2->u.rval_long   ; break ;
+    case CTK_ULONG:  if(v2->u.rval_ulong==0) goto div_err;
+               r->u.rval_ulong = v1->u.rval_ulong % v2->u.rval_ulong  ; break ;
+    case CTK_LONGLONG:   if(v2->u.rval_longlong==0) goto div_err;
+               r->u.rval_longlong  = v1->u.rval_longlong  % v2->u.rval_longlong   ; break ;
+    case CTK_ULONGLONG:  if(v2->u.rval_ulonglong==0) goto div_err;
+               r->u.rval_ulonglong = v1->u.rval_ulonglong % v2->u.rval_ulonglong  ; break ;
+    default: duel_assert(0);
+   }
+   return ;
+div_err: duel_op_error("reminder modulo zero",0,v1,v2);
+}
+
+/* do arithmeric or (bitwise) of v1,v2 and store result in r.
+ * NOTE: v1, v2 are destroyed!
+ */
+LPROC do_op_or(tvalue *v1,tvalue *v2,tvalue *r)
+{
+   tctype *t=find_numeric_result_type(v1,v2,r,"|");
+   get_integral_val(v1,"x|y",t);
+   get_integral_val(v2,"y|x",t);
+   switch(t->type_kind) {
+    case CTK_INT:  r->u.rval_int  = v1->u.rval_int   | v2->u.rval_int  ; break;
+    case CTK_UINT: r->u.rval_uint = v1->u.rval_uint  | v2->u.rval_uint ; break;
+    case CTK_LONG: r->u.rval_long = v1->u.rval_long  | v2->u.rval_long ; break;
+    case CTK_ULONG:r->u.rval_ulong= v1->u.rval_ulong | v2->u.rval_ulong; break;
+    case CTK_LONGLONG: r->u.rval_longlong = v1->u.rval_longlong  | v2->u.rval_longlong ; break;
+    case CTK_ULONGLONG:r->u.rval_ulonglong= v1->u.rval_ulonglong | v2->u.rval_ulonglong; break;
+    default: duel_assert(0);
+   }
+   return ;
+}
+
+/* do arithmeric and (bitwise) of v1,v2 and store result in r.
+ * NOTE: v1, v2 are destroyed!
+ */
+LPROC do_op_and(tvalue *v1,tvalue *v2,tvalue *r)
+{
+   tctype *t=find_numeric_result_type(v1,v2,r,"&");
+   get_integral_val(v1,"x&y",t);
+   get_integral_val(v2,"y&x",t);
+   switch(t->type_kind) {
+    case CTK_INT:  r->u.rval_int  = v1->u.rval_int   & v2->u.rval_int  ; break;
+    case CTK_UINT: r->u.rval_uint = v1->u.rval_uint  & v2->u.rval_uint ; break;
+    case CTK_LONG: r->u.rval_long = v1->u.rval_long  & v2->u.rval_long ; break;
+    case CTK_ULONG:r->u.rval_ulong= v1->u.rval_ulong & v2->u.rval_ulong; break;
+    case CTK_LONGLONG: r->u.rval_longlong = v1->u.rval_longlong  & v2->u.rval_longlong ; break;
+    case CTK_ULONGLONG:r->u.rval_ulonglong= v1->u.rval_ulonglong & v2->u.rval_ulonglong; break;
+    default: duel_assert(0);
+   }
+}
+
+/* do arithmeric xor (bitwise) of v1,v2 and store result in r.
+ * NOTE: v1, v2 are destroyed!
+ */
+LPROC do_op_xor(tvalue *v1,tvalue *v2,tvalue *r)
+{
+   
+   tctype *t=find_numeric_result_type(v1,v2,r,"^");
+   get_integral_val(v1,"x^y",t);
+   get_integral_val(v2,"y^x",t);
+   switch(t->type_kind) {
+    case CTK_INT:  r->u.rval_int  = v1->u.rval_int  ^ v2->u.rval_int  ; break ;
+    case CTK_UINT: r->u.rval_uint = v1->u.rval_uint ^ v2->u.rval_uint ; break ;
+    case CTK_LONG: r->u.rval_long = v1->u.rval_long ^ v2->u.rval_long ; break ;
+    case CTK_ULONG:r->u.rval_ulong= v1->u.rval_ulong^ v2->u.rval_ulong; break ;
+    case CTK_LONGLONG: r->u.rval_longlong = v1->u.rval_longlong ^ v2->u.rval_longlong ; break ;
+    case CTK_ULONGLONG:r->u.rval_ulonglong= v1->u.rval_ulonglong ^ v2->u.rval_ulonglong; break ;
+    default: duel_assert(0);
+   }
+   return ;
+}
+
+/* do arithmeric leftshift of v1,v2 and store result in r.
+ * v1 and v2 should be of numeric type to begin with.
+ * NOTE: v1, v2 are destroyed!
+ */
+LPROC do_op_leftshift(tvalue *v1,tvalue *v2,tvalue *r)
+{
+   int by;
+   get_integral_val(v1,"x<<y",NULL);
+   by=duel_get_int_val(v2,"y<<x");
+   r->val_kind=VK_RVALUE ;
+   r->ctype=v1->ctype ;
+   duel_set_symb_val(r,"%s<<%s",v1,v2);
+   switch(v1->ctype->type_kind) {
+    case CTK_INT:    r->u.rval_int   = v1->u.rval_int   << by ; break ;
+    case CTK_UINT:   r->u.rval_uint  = v1->u.rval_uint  << by ; break ;
+    case CTK_LONG:   r->u.rval_long  = v1->u.rval_long  << by ; break ;
+    case CTK_ULONG:  r->u.rval_ulong = v1->u.rval_ulong << by ; break ;
+    case CTK_LONGLONG:   r->u.rval_longlong  = v1->u.rval_longlong  << by ; break ;
+    case CTK_ULONGLONG:  r->u.rval_ulonglong = v1->u.rval_ulonglong << by ; break ;
+    default: duel_assert(0);
+   }
+}
+
+/* do arithmeric rightshift of v1,v2 and store result in r.
+ * v1 and v2 should be of numeric type to begin with.
+ * NOTE: v1, v2 are destroyed!
+ */
+LPROC do_op_rightshift(tvalue *v1,tvalue *v2,tvalue *r)
+{
+   int by ;
+   get_integral_val(v1,"x>>y",NULL);
+   by=duel_get_int_val(v2,"y>>x");
+   r->val_kind=VK_RVALUE ;
+   r->ctype=v1->ctype ;
+   duel_set_symb_val(r,"%s>>%s",v1,v2);
+   switch(v1->ctype->type_kind) {
+    case CTK_INT:    r->u.rval_int   = v1->u.rval_int   >> by ; break ;
+    case CTK_UINT:   r->u.rval_uint  = v1->u.rval_uint  >> by ; break ;
+    case CTK_LONG:   r->u.rval_long  = v1->u.rval_long  >> by ; break ;
+    case CTK_ULONG:  r->u.rval_ulong = v1->u.rval_ulong >> by ; break ;
+    case CTK_LONGLONG:   r->u.rval_longlong  = v1->u.rval_longlong  >> by ; break ;
+    case CTK_ULONGLONG:  r->u.rval_ulonglong = v1->u.rval_ulonglong >> by ; break ;
+    default: duel_assert(0);
+   }
+}
+
+/* do arithmeric not of v (!v) */
+LPROC do_op_not(tvalue *v)
+{
+   get_scalar_val(v,"!x");
+   duel_set_symb_val(v,"!%s",v,0);
+   switch(v->ctype->type_kind) {
+    case CTK_PTR:    v->u.rval_int   =  ! v->u.rval_ptr    ; break ;
+    case CTK_INT:    v->u.rval_int   =  ! v->u.rval_int    ; break ;
+    case CTK_UINT:   v->u.rval_int   =  ! v->u.rval_uint   ; break ;
+    case CTK_LONG:   v->u.rval_int   =  ! v->u.rval_long   ; break ;
+    case CTK_ULONG:  v->u.rval_int   =  ! v->u.rval_ulong  ; break ;
+    case CTK_LONGLONG:   v->u.rval_int   =  ! v->u.rval_longlong   ; break ;
+    case CTK_ULONGLONG:  v->u.rval_int   =  ! v->u.rval_ulonglong  ; break ;
+    case CTK_FLOAT:  v->u.rval_int   =  ! v->u.rval_float  ; break ;
+    case CTK_DOUBLE: v->u.rval_int   =  ! v->u.rval_double ; break ;
+    default: duel_assert(0);
+   }
+   v->ctype=ctype_int ;         /* always returns an int */
+}
+
+/* do bit-complement of v (~v) */
+LPROC do_op_complement(tvalue *v)
+{
+   get_integral_val(v,"~x",NULL);
+   duel_set_symb_val(v,"~%s",v,0);
+   switch(v->ctype->type_kind) {
+    case CTK_INT:    v->u.rval_int   =  ~ v->u.rval_int    ; break ;
+    case CTK_UINT:   v->u.rval_uint  =  ~ v->u.rval_uint   ; break ;
+    case CTK_LONG:   v->u.rval_long  =  ~ v->u.rval_long   ; break ;
+    case CTK_ULONG:  v->u.rval_ulong =  ~ v->u.rval_ulong  ; break ;
+    case CTK_LONGLONG:   v->u.rval_longlong  =  ~ v->u.rval_longlong   ; break ;
+    case CTK_ULONGLONG:  v->u.rval_ulonglong =  ~ v->u.rval_ulonglong  ; break ;
+    default: duel_assert(0);
+   }
+}
+
+ /* do arithmeric minus of v (-v) */
+LPROC do_op_minus(tvalue *v)
+{
+   get_numeric_val(v,"-x",NULL);
+   duel_set_symb_val(v,"-%s",v,0);
+   switch(v->ctype->type_kind) {
+    case CTK_INT:    v->u.rval_int   =  - v->u.rval_int    ; break ;
+    case CTK_UINT:   v->u.rval_uint  =  - v->u.rval_uint   ; break ;
+    case CTK_LONG:   v->u.rval_long  =  - v->u.rval_long   ; break ;
+    case CTK_ULONG:  v->u.rval_ulong =  - v->u.rval_ulong  ; break ;
+    case CTK_LONGLONG:   v->u.rval_longlong  =  - v->u.rval_longlong   ; break ;
+    case CTK_ULONGLONG:  v->u.rval_ulonglong =  - v->u.rval_ulonglong  ; break ;
+    case CTK_FLOAT:  v->u.rval_float =  - v->u.rval_float  ; break ;
+    case CTK_DOUBLE: v->u.rval_double=  - v->u.rval_double ; break ;
+    default: duel_assert(0);
+   }
+}
+
+/* do sizeif(exp) - simply return the size of the exp's type */
+LPROC do_op_sizeofexp(tvalue *v)
+{
+    v->val_kind=VK_RVALUE ;
+    v->u.rval_size_t=v->ctype->size ;
+    v->ctype=ctype_size_t ;
+    duel_set_symb_val(v,"sizeof(%s)",v,0);
+}
+
+LPROC do_op_assignment(tvalue *v1,tvalue *v2,tvalue *r,char *op)
+{
+    char xopy[10],yopx[10] ;
+    sprintf(xopy,"x%sy",op);
+    sprintf(yopx,"y%sx",op);
+    if(v1->val_kind!=VK_LVALUE && v1->val_kind!=VK_BVALUE)
+       duel_op_error("operand x is not an lvalue for operator '%s'",xopy,v1,0);
+
+    if(ctype_kind_struct_like(v1->ctype)) {
+        duel_check_type_eq(v1,v2,xopy);
+        copy_lvalues(v1,v2,xopy);
+        *r= *v2 ;  /* return the result as an lvalue. this means (x1=x2)=x3
+                      is legal for struct, unlike ansi-c. */
+        return ;
+    }
+    if(ctype_kind_numeric(v1->ctype)) get_numeric_val(v2,yopx,v1->ctype);
+    else
+    if(v1->ctype->type_kind==CTK_PTR) {
+      get_pointer_val(v2,yopx,TRUE);
+      duel_check_type_eq(v1,v2,xopy);
+    }
+    else duel_op_error("bad operand x type for operator '%s'",xopy,v1,0);
+    put_rvalue(v1,v2,xopy);
+    *r= *v2 ;
+}
+
+LPROC do_op_increment(tvalue *v,char *op,int inc,bool postfix)
+{
+    tvalue lvalue_v,oldv ;
+    char s[80] ;
+    if(v->val_kind!=VK_LVALUE) 
+      duel_op_error("operand of '%s' must be an lvalue",op,v,0);
+    lvalue_v= *v ;
+    if(v->ctype->type_kind==CTK_PTR) get_pointer_val(v,op,FALSE);
+    else get_integral_val(v,op,0);
+    oldv= *v ;
+
+   switch(v->ctype->type_kind) {
+    case CTK_INT:   v->u.rval_int   +=  inc ; break ;
+    case CTK_UINT:  v->u.rval_uint  +=  inc ; break ;
+    case CTK_LONG:  v->u.rval_long  +=  inc ; break ;
+    case CTK_ULONG: v->u.rval_ulong +=  inc ; break ;
+    case CTK_LONGLONG:  v->u.rval_longlong  +=  inc ; break ;
+    case CTK_ULONGLONG: v->u.rval_ulonglong +=  inc ; break ;
+    case CTK_PTR:   v->u.rval_ptr   +=  inc*v->ctype->u.kid->size ; break;
+    default: duel_assert(0);
+   }
+   convert_scalar_type(v,lvalue_v.ctype,op);  /* back to the original type */
+   put_rvalue(&lvalue_v,v,op);
+   if(postfix) {                        /* if prefix, keep v and its sym val*/
+       *v= oldv ;
+       convert_scalar_type(v,lvalue_v.ctype,op);  /* back to original type */
+       sprintf(s,"%%s%s",op);
+       duel_set_symb_val(v,s,v,0);
+   }
+}
+
+/* unary op 'frame(n)' converts int n to a "frame type" */
+LPROC do_op_frame(tvalue *v)
+{
+   int f=duel_get_int_val(v,"frame(x)");
+   if(f<0 || f>=duel_get_frames_number()) 
+       duel_gen_error("Frame number too big",0);
+   v->val_kind=VK_FVALUE ;
+   v->ctype=ctype_int ;
+   v->u.fvalue=f ;
+   duel_set_symb_val(v,"frame(%s)",v,0);
+}
+
+/* unary op '(x)'. this only add parenthesis to the symbolic value, if needed*/
+
+LPROC do_op_parenthesis(tvalue *v)
+{
+    char *s=v->symb_val ;
+    int l=strlen(s);
+    if(s[0]=='(' && s[l-1]==')') return ; /* val is (x) dont make it ((x)) */
+    while(*s!=0 && (isalnum(*s) || *s=='_')) s++ ; /* find first non alnum*/
+    if(*s==0) return ;  /* no need for (x) if x is a name or constant number */
+    duel_set_symb_val(v,"(%s)",v,0); 
+}
+
+/***********************************************************************
+ High-level functions, major entries to this module, evaluate a node
+ with a standard (single value) result
+ ***********************************************************************/
+
+
+/* standardize a paramater to a function call according to the standard rules.
+ * we currently don't support union/struct paramater passing
+ */
+
+PROC duel_standardize_func_parm(tvalue *p)
+{
+   /* convert paramater into "standard" function calling */   
+   if(ctype_kind_integral(p->ctype)) get_integral_val(p,"f()",NULL);
+   else 
+   if(ctype_kind_numeric(p->ctype))     /* float, double to double */
+       convert_scalar_type(p,ctype_double,"f()");
+   else
+   if(ctype_kind_ptr_like(p->ctype)) get_pointer_val(p,"f()",FALSE);
+   else
+       duel_op_error("unsupported paramater type",0,p,0);
+}
+
+
+/* given a function (or pointer), find the first (top-most) frame that
+ * the function is active in, and return the FVALUE  for it
+ */
+PROC duel_find_func_frame(tvalue *v,char *op)
+{
+    int i, frames_no=duel_get_frames_number();
+    get_pointer_val(v,op,FALSE);
+
+    for(i=0 ; i<frames_no ; i++) {
+        ttarget_ptr frame_func = duel_get_function_for_frame(i);
+        if(frame_func==v->u.rval_ptr) {
+            v->val_kind=VK_FVALUE ;
+            v->ctype=ctype_int ;
+            v->u.rval_int=i ;
+            return ;
+        }
+    }
+    duel_op_error("func x is not on the call stack for operator '%s'",op,v,0);
+}
+
+
+/* compute the n'th result of v1..v2 operator.
+ * result is returned in r, returns false if there isnt an nth result
+ * v1,v2 are converted to integer values (but can be used to call this 
+ * function again. errors are reported if they arenot integral.
+ */
+
+FUNC bool duel_do_op_to(tvalue *v1,tvalue *v2,int n,tvalue *r)
+{
+    int a,b,inc,x ;
+    char *p,*fmt ;
+
+    if(!v1) { a=0 ; b=duel_get_int_val(v2,"..x")-1 ; }
+    else if(!v2) { a=duel_get_int_val(v1,"x.."); b=INT_MAX ; }
+    else { a=duel_get_int_val(v1,"x..y"); b=duel_get_int_val(v2,"x..y"); }
+    if(a<=b) inc=1 ;
+    else inc= -1 ;
+    x=a+n*inc ;
+    if(inc>0 && x>b || inc<0 && x<b) return FALSE ;
+
+    r->val_kind=VK_RVALUE ;
+    r->ctype=ctype_int ;
+    r->u.rval_int=x ;
+    if(v1) p=v1->symb_val ;
+    else   p=v2->symb_val ;
+    if(     *p=='0'  && p[1]=='x'  || p[1]=='X')  fmt="0x%x" ;
+    else if(*p=='0'  && p[1]>='0'  && p[1]<='7')  fmt="0%o"  ;
+    else if(*p=='\'' && isascii(x) && isprint(x)) fmt="'%c'" ;
+    else                                          fmt="%d"   ;
+    sprintf(r->symb_val,fmt,x);
+    return TRUE ;
+}
+
+/* convert value to True/False and return it 
+ * in case of an illegal operand, indicateds the operator is (op)
+ * main use: in operators '&&' '||' and 'if'
+ */
+
+FUNC bool duel_mk_logical(tvalue *v,char *op)
+{
+   get_scalar_val(v,op);                /* verify v is scalar */
+   do_op_not(v);                        /* convert and force 0 or 1 */
+   v->u.rval_int = !v->u.rval_int ;
+   sprintf(v->symb_val,"%d",v->u.rval_int);
+   return(v->u.rval_int);
+}
+
+/* cast the value v into type t. */
+
+PROC duel_do_cast(tctype *tout,tvalue *v)
+{
+    tctype *t=v->ctype ;
+    if(ctype_kind_scalar(t) && ctype_kind_scalar(tout)) {
+        if(tout->type_kind==CTK_ARRAY) 
+            duel_gen_error("casting to an array type is illegal",0);
+        else convert_scalar_type(v,tout,"(cast) x");
+    }
+    else duel_op_error("illegal type conversion in cast op",0,v,0);
+}
+
+
+/* apply unary oprand op to the given value. The original value is 
+ * destoryed (of course)
+ */
+
+PROC duel_apply_unary_op(topcode op,tvalue *v)
+{
+   switch(op) {
+      case '(':  do_op_parenthesis(v);            break ;
+      case '{':  duel_sprint_scalar_value(v->symb_val,v);break ;
+      case '-':  do_op_minus(v);                  break ;
+      case '!':  do_op_not(v);                    break ;
+      case '*':  do_op_indirection(v);            break ;
+      case '~':  do_op_complement(v);             break ;
+      case '&':  do_op_address(v);                break ;
+      case OP_SIZ: do_op_sizeofexp(v);            break ;
+      case OP_INC: do_op_increment(v,"++",1,FALSE); break ;
+      case OP_DEC: do_op_increment(v,"--",-1,FALSE); break ;
+      case OP_FRAME: do_op_frame(v);    break ;
+      default: duel_assert(0);
+   }
+}
+
+PROC duel_apply_post_unary_op(topcode op,tvalue *v)
+{
+   switch(op) {
+      case OP_INC: do_op_increment(v,"++",1,TRUE); break ;
+      case OP_DEC: do_op_increment(v,"--",-1,TRUE); break ;
+      default: duel_assert(0);
+   }
+}
+
+
+/* apply_bin_op -- apply the operator op to the values v1 v2 and return
+ *                 the result in r. the bin op is a 'regular' one, like
+ *                 '+', '*', etc. in the C language.
+ * note: v1,v2 are destroyed
+ * returns: true if a value has been produced, false otherwise. 
+ *       (ops like '+' always return true. ops like '<=?' also return false)
+ */
+
+FUNC bool duel_apply_bin_op(topcode op,tvalue *v1,tvalue *v2,tvalue *r)
+{
+  switch(op) {
+   case '[': do_op_index(v1,v2,r); break ;
+   case '+':  do_op_add(v1,v2,r);      break ;
+   case '-':  do_op_subtract(v1,v2,r); break ;
+   case '*':  do_op_multiply(v1,v2,r); break ;
+   case '/':  do_op_divide(v1,v2,r);   break ;
+   case '%':  do_op_reminder(v1,v2,r); break ;
+   case '|':  do_op_or(v1,v2,r);       break;
+   case '&':  do_op_and(v1,v2,r);      break ;
+   case '^':  do_op_xor(v1,v2,r); break ;
+   case OP_LSH: do_op_leftshift(v1,v2,r); break ;
+   case OP_RSH: do_op_rightshift(v1,v2,r); break ;
+   case OP_EQ:  do_op_eq(v1,v2,r); break ;
+   case OP_NE:  do_op_ne(v1,v2,r); break ;
+   case OP_GE:  do_op_ge(v1,v2,r); break ;
+   case OP_LE:  do_op_le(v1,v2,r); break ;
+   case '<':    do_op_ls(v1,v2,r); break ;
+   case '>':    do_op_gt(v1,v2,r); break ;
+   case OP_EQQ: 
+   case OP_NEQ:
+   case OP_GEQ:
+   case OP_LEQ:
+   case OP_LSQ:
+   case OP_GTQ: return do_compare_questionmark(op,v1,v2,r); 
+   case '=':    do_op_assignment(v1,v2,r,"="); break ;
+   default: duel_assert(0);
+  }
+  return TRUE ;
+}
--- gdb/duel/global.h
+++ gdb/duel/global.h
@@ -0,0 +1,450 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code                            */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* this include file contains global definitions for duel. All global info
+ * is shared thru this single file.
+ */
+
+/*
+ * $Log: 10_all_gdb-6.6-duel.patch,v $
+ * Revision 1.1  2007/12/29 21:06:06  vapier
+ * add DUEL support #199987 by Sergei Golubchik
+ *
+ * Revision 1.12  93/03/12  05:50:35  mg
+ * uses tuint instead of uint, etc.
+ * 
+ * Revision 1.11  93/02/27  06:03:26  mg
+ * added HP9000 support by not defining uint etc
+ * clean annoying enum {x,y,} warnings
+ * 
+ * Revision 1.10  93/02/03  21:49:32  mg
+ * support "signed char"
+ * 
+ * Revision 1.9  93/01/12  21:52:11  mg
+ * cleanup and set for release
+ * 
+ * Revision 1.8  93/01/07  00:10:53  mg
+ * macros for func ptr auto-convert
+ * 
+ * Revision 1.7  93/01/03  07:30:23  mg
+ * *** empty log message ***
+ * 
+ * Revision 1.6  92/12/24  23:49:25  mg
+ * *** empty log message ***
+ * 
+ * Revision 1.5  92/10/19  15:07:58  mg
+ * fvalue added (not ready yet), svalues dropped
+ * 
+ * Revision 1.4  92/10/14  02:05:37  mg
+ * misc
+ * 
+ * Revision 1.3  92/09/16  11:11:54  mg
+ * add builtin ctype_charptr
+ * 
+ * Revision 1.2  92/09/15  05:47:49  mg
+ * some ops added
+ * 
+ */
+
+
+/* The following definitions are common programming tricks that I use
+ * in every program I write. I hope they are obvious. the FUNC/PROC
+ * constants are useful mainly when editing (to find a function def.)
+ * or when grep'ing on source files. DEF is set to "extern" by default,
+ * allowing declaration and definition of globals in one source. only
+ * duel.c should have #define DEF before including duel.h
+ */
+
+#define FUNC
+#define PROC void
+#define LPROC static void
+#define LFUNC static
+
+#ifndef DEF
+#define DEF extern            /* declare only, 'int x' become 'extern int x'*/
+#endif
+
+/* use simpler names for unsigned types, very common,
+ * too common, indeed, so I forced 't' as a prefix.
+ */
+
+typedef unsigned int       tuint ;
+typedef unsigned char      tuchar ;
+typedef unsigned short     tushort ;
+typedef unsigned long      tulong ;
+typedef unsigned long long tulonglong ;
+
+typedef signed char tschar ;   /* explicit signed char */
+typedef int bool ;             /* suppose to be just 0,1 */
+#define FALSE 0
+#define TRUE  1
+
+ /* these should be inline functions, they replace common lib func which
+  * change from system to system.
+  * duel_assert can be modified to call duel_fatal, so gdb itself isn't
+  * aborted because on an internal duel error.
+  */
+
+#define duel_assert(x)    assert(x)
+#define duel_bzero(x,y)   memset(x,0,y)
+#define duel_bcopy(x,y,s) memcpy(x,y,s)
+
+
+
+/*************
+ Parsing: the expression is converted into a tree.
+ Each node of this tree is of 'tnode' type.
+ Nodes can be:
+ An operator (like '+', or ':=' or 'for')
+ A  constant (numbers. Strings are pointers to space!)
+ A  symbol.
+ A  regular expression (really a symbol extention)
+
+ The evaluation of any node results in:
+ 1. 'Environment': duel variables and their values
+ 2. symbolic expression which describe the computation
+    meaning: keep the parentethis. in the expression a<<(3+b) (even if not needed!)
+ 3. A type & value
+ 
+ Values:
+ Values are always a fixed length area of bytes; Any C type is like that.
+**************/
+
+
+/****** TYPES *******
+  A type is described in the typical compiler's way, which is also gdb's
+  way. That is, a type is made of 'atomic' types, like 'pointer to',
+  'array of', etc. Each atomic type is described by a 'ctype' node. Ctype
+  node points to other ctype nodes as required. For example, a ctype node
+  of 'array of' will point to the node 'int' for the 'C' type array of int.
+  [The name ctype is used to indicate the C language type; 'type' is too
+   generic a term]
+  Example:
+   char *(*f[])() ;
+  Here, f is an array of pointers to functions returning a pointer to char.
+  The type is described with the top node being of CTK_ARRAY type. It
+  points to a 'CTK_PTR' node, which points to a 'CTK_FUNC' node which
+  points to a 'CTK_PTR' node which points to a 'CTK_CHAR' node which has,
+  as size, 1.
+
+  The size of a type is the number of bytes occupied by it. it is zero
+  for types like 'function'. An array of 10 integers will have as size
+  10*sizeof(int)
+
+  A note on UCHAR vs CHAR vs SCHAR:
+  Internally, duel supports all three forums (for aritmetic).
+  For output, only "char" types are considered ASCII, and will be displayed
+  as 'A' instead of "65", etc. The same is true for char[] and char*.
+  GDB doesn't really support "signed char", but some compilers do;
+  we convert "signed char" into just a "char" when the default char is signed.
+  This is only significant for output.
+  Maybe duel shouldn't support "char" at all, and force everything to be
+  "schar" or "uchar". I'm not sure. I prefer "char" as a distinct  type
+  which implies "string" and uchar/schar as "integral".
+ ********************/
+
+typedef enum {     /* 'C' Type atomic primitive Kinds (CTK_) */
+   CTK_VOID,       /* void type   'void'     */
+   CTK_CHAR,       /* primitive types        */     
+   CTK_SCHAR,      /* signed char (ansi c) */
+   CTK_UCHAR,      /* note order is used in some macros */
+   CTK_SHORT,
+   CTK_USHORT,
+   CTK_INT,
+   CTK_UINT,
+   CTK_LONG,
+   CTK_ULONG,
+   CTK_LONGLONG,
+   CTK_ULONGLONG,
+   CTK_FLOAT,
+   CTK_DOUBLE,
+   CTK_PTR,          /* pointer '*'            */
+   CTK_ARRAY,        /* array   '[]'           */
+   CTK_FUNC,         /* a function '()'        */
+   CTK_STRUCT,       /* a sturcture 'struct{}' */
+   CTK_UNION,        /* a union     'union{}'  */
+   CTK_ENUM          /* enum type   'enum{}'   */
+ } tctype_kind ;
+
+typedef struct {                /* a field (of struct) info */
+  char *name ;                  /* field name */ 
+  struct sctype *ctype ;        /* field type */
+  int bitpos, bitlen ;          /* for bit fields only */
+} tctype_field ;
+
+typedef struct {                /* an enumerator (constant of an enum)  info */
+  char *name ;                  /* enumerator name */
+  int val ;                     /* value assigned to the name */
+                                /* question: ansi-C say cosnt fit in int?*/
+} tctype_enumerator ;
+
+
+typedef struct sctype {       /* a 'C' type description  */
+   tctype_kind type_kind ;
+   char *name ;               /* named of this type, if any       */
+   size_t size ;              /* size (total bytes) for this type */
+   union {
+    struct sctype *kid ;       /* pointer to next atomic type               */
+    struct {
+      int fields_no ;
+      tctype_field *fields ;     /* union/struct fields */
+    } f ;
+    struct {
+       tctype_kind real_type_kind ; /* the type used for storage of the enum */
+       int enumerators_no ;
+       tctype_enumerator *enumerators ; /* enum's type enumerators list */
+    } e; 
+   } u ;
+ } tctype ;
+
+
+/**** BASIC C TYPES
+  these are initialized at run type to point to the basic C types.
+  basic types are never created again, e.g. pointer comparison with
+  these is sufficient to check type equality.
+  the voidptr is (void*) which is a basic type (what zero is converted 
+  to when it is a pointer).
+  ptrdiff_t and size_t are actually pointing to their actualy types,
+  ie. normally point to ctype_int.
+ ****/
+
+DEF tctype *ctype_int,  *ctype_uint, *ctype_short, *ctype_ushort, 
+           *ctype_char, *ctype_schar, *ctype_uchar,  
+           *ctype_long, *ctype_ulong, *ctype_longlong, *ctype_ulonglong,
+           *ctype_float, *ctype_double,
+           *ctype_void, *ctype_charptr,
+           *ctype_voidptr,*ctype_ptrdiff_t,*ctype_size_t ;
+
+/* type checking macros */
+
+/** tell if type is a struct or union */
+#define ctype_kind_struct_like(t) ((t)->type_kind==CTK_STRUCT || \
+                                   (t)->type_kind==CTK_UNION)
+
+/** tell if type is a pointer or can be made one (array, func) */
+#define ctype_kind_ptr_like(t)   ((t)->type_kind==CTK_PTR || \
+                         (t)->type_kind==CTK_ARRAY || (t)->type_kind==CTK_FUNC)
+/* tell if type is numeric */
+#define ctype_kind_numeric(t) (((t)->type_kind>=CTK_CHAR && \
+                     (t)->type_kind<=CTK_DOUBLE) || (t)->type_kind==CTK_ENUM) 
+
+/* tell if type is integral */
+#define ctype_kind_integral(t) ((t)->type_kind>=CTK_CHAR && \
+                     (t)->type_kind<=CTK_ULONG || (t)->type_kind==CTK_ENUM)
+
+/* tell if type fits into fixed memory size (void not included) */
+#define ctype_kind_scalar(t) (ctype_kind_numeric(t) || ctype_kind_ptr_like(t))
+
+/* tell if type is a "base" ie can't have kids */
+
+#define ctype_kind_base(t) ((t)->type_kind>=CTK_VOID && \
+                            (t)->type_kind<=CTK_DOUBLE)
+
+/* tell if a type is a function pointer or like a func ptr (ie a func!) */
+#define ctype_kind_func_ptr_like(t) ((t)->type_kind==CTK_FUNC || \
+                    (t)->type_kind==CTK_PTR && t->u.kid->type_kind==CTK_FUNC)
+
+
+/***** VALUES
+   used to keep information when evaluating an expression. A value is
+   either:
+   1) a right-value, which is represented in a fixed number of bytes that
+      actually contain its value. Example: result of '+' operation.
+   2) a left-value. This is a reference to the actual value, which
+      resides in the debuggee's address space.
+   3) a special-value. This contains a long value specifying a special
+      target location (e.g. register) from which values can be fetched
+      or written to. However, special-values can not be manipulated (i.e
+      have an offset added to them, as done to an lvalue struct).
+
+   Note that the operation '*x' starts with x as an lvalue - a pointer to
+   x is kept. Then, '*x' is executed, fetching the value of x and creating
+   another lvalue, which points to where x has pointed to! This allows
+   &*x to be executed, as well as *x=1 or &x[1] ...
+   When the value of an lvalue is actually needed, it must be fetched
+   from the debugge's space.
+ *****/
+
+#define VALUE_MAX_CONST_SIZE        8
+#define VALUE_MAX_SYMBOLIC_SIZE     128
+
+typedef long tptrsize_int ;     /* type so that 
+                                   tptrsize x; char *p ;
+                                   p == (char*) (tptrsize) p
+                                 */
+
+  /* type that represent a target address space location.  */
+
+typedef char* ttarget_ptr ; /* pointer to target's address */
+
+typedef struct {
+    ttarget_ptr lvalue ;        /* pointer to target's location of struct*/
+    int bitpos,bitlen ;         /* as specified in the field info of stuct*/
+ } tbvalue_info ;
+
+typedef enum {
+  VK_RVALUE,      /* this value represent a constant, in the rval_ union */
+  VK_LVALUE,      /* this value represent a left-value. address in lvalue*/
+  VK_BVALUE,      /* a bit-field lvalue, given as point and bitpos/bitlen*/
+  VK_FVALUE       /* a frame, fvalue contains it number */
+ } tval_kind ;
+
+typedef struct {
+   tval_kind val_kind ;
+   tctype *ctype ;       /* type of this value */
+   union {
+      ttarget_ptr lvalue ; /* location in target of the value */
+      tbvalue_info bvalue ; /* location in target of a bitfield */
+      int          fvalue ; /* a frame number (0 = top of stack) */
+      char         rval_char ;
+      tschar       rval_schar ;
+      tuchar       rval_uchar ;
+      short        rval_short ;
+      tushort      rval_ushort ;
+      int          rval_int ;
+      tuint        rval_uint ;
+      long         rval_long ;
+      tulong       rval_ulong ;
+      long long    rval_longlong ;
+      tulonglong   rval_ulonglong ;
+      float        rval_float ;
+      double       rval_double ;
+      ttarget_ptr  rval_ptr ;
+      ptrdiff_t    rval_ptrdiff_t ; /* Synonyms to one of the above fields! */
+      size_t       rval_size_t ;    /* normally these are simply = rval_int */
+   } u ;
+   char symb_val[VALUE_MAX_SYMBOLIC_SIZE];
+ }  tvalue ;
+
+
+typedef struct sval_lcell {    /* a cell on a linked-list containing a tvalue*/
+    tvalue val ;
+    struct sval_lcell *next ;
+ } tval_lcell ;
+
+typedef struct {               /* a linked list of tvalue's */
+    tval_lcell *head ;
+    tval_lcell *tail ;
+} tval_list ;
+
+/**** OP CODES ****
+ Opcodes are divided into groups, or 'kinds'. For example, all the
+ C regular unary operators, binary operators, etc.
+ An opcode is defined by its 'kind' and actual value. The value is,
+ in most cases, a single char. For example, the C plus operator is
+ defined as op_kind=OPK_BIN and op='+'. The C operator '+=' is
+ defined as op_kind=OPK_ASSIGN and op='+'.
+ some operators are uniquely identified by type alone (e.g. func call).
+ In the lexer there is a table of actual operators as tokens, and
+ the kind & value assigned to each.
+ Several opertors use more than one char, and are defined below.
+ the OPK_SBIN, etc kinds are special in the sense that A op B isn't
+ computed in the normal way of the C language (i.e. compute both sides,
+ then apply the operator). Such operators include ',' '&&', etc.
+ **********/
+typedef enum {
+    /* '+' '-' etc are used directly and have their ascii value */
+    OP_LSH = 300,     /* '<<' */
+    OP_RSH = 301,     /* '>>' */
+    OP_INC = 302,     /* '++' */
+    OP_DEC = 303,     /* '--' */
+    OP_ARR = 304,     /* '->' */
+    OP_AND = 305,     /* '&&' */
+    OP_OR  = 306,     /* '||' */
+    OP_EQ  = 307,     /* '==' */
+    OP_GE  = 308,     /* '>=' */
+    OP_LE  = 309,     /* '<=' */
+    OP_NE  = 310,     /* '!=' */
+    OP_SIZ = 311,     /* 'sizeof' */
+    OP_TO  = 312,     /* '..' */
+    OP_EQQ  = 313,     /* '==?' */
+    OP_NEQ  = 314,     /* '!=?' */
+    OP_GEQ  = 315,     /* '>=?' */
+    OP_LEQ  = 316,     /* '<=?' */
+    OP_GTQ  = 317,     /* '>?'  */
+    OP_LSQ  = 318,     /* '<?'  */
+    OP_IMP  = 319,     /* '=>'  */
+    OP_IF   = 320,     /* if()  */
+    OP_DEF  = 321,     /* ':='  */
+    OP_DFS  = 322,     /* '-->' */
+    OP_BFS  = 323,     /* '->>' */
+    OP_POS  = 324,     /* '>--' */
+    OP_IOS  = 325,     /* '->-' */
+    OP_SEL  = 326,     /*'x[[y]]'*/
+    OP_FOR  = 327,     /*for(;;)'*/
+    OP_WHILE= 328,     /*while() */
+    OP_DECL = 329,     /* var decl*/
+    OP_FRAME= 330      /* frame(i)*/
+   } topcode ;
+
+/**** OPCODE KINDS ****/
+
+typedef enum {          /* the kind of the opcode, 'OPK_' = OPcode Kind */
+   OPK_UNARY      =0,   /* regular unary operator                       */
+   OPK_SUNARY     =1,   /* special unary operator (sizeof)              */
+   OPK_POST_UNARY =2,   /* post unary operator (x++ etc)                */
+   OPK_BIN        =3,   /* regular binary operator                      */
+   OPK_SBIN       =4,   /* special binary operator                      */
+   OPK_TRI        =5,   /* trinary (eg ?:) operator                     */
+   OPK_QUAD       =6,   /* quad (e.g.for(;;)) operator                  */
+   OPK_ASSIGN     =7,   /* assignment ie =, +=, -= etc                  */
+   OPK_FUNC       =8,   /* function call. 2nd kid made of ',' kids for parms */
+   OPK_CAST       =9,   /* type cast.  2nd kid convert to type in 1st kid */
+   OPK_NUM_OF     =10   /* number of OPK_* op kinds                       */
+ } top_kind ;
+
+
+/**** NODE KINDS ****/
+
+typedef enum {           /* the kind of node        */
+   NK_OP,               /* contain an operator     */
+   NK_CONST,            /* contains a constant     */
+   NK_NAME,             /* contains a name/symbol  */
+   NK_CTYPE             /* contain a 'C' type      */
+ } tnode_kind ;
+
+#define NODE_MAX_KIDS      4     /* maximum no of kids per node         */
+#define NODE_MAX_SYM_LEN  50     /* maximum length for a symbol         */
+
+/* the following structure is used to store one node of the expression tree.
+ * It contains two parts: (a) information to describe the node and (b)
+ * information used during the evaluation of the node.
+ *
+ * This structure could/should be optimized with ugly unions (e.g., for
+ * a node describing a constant(node_kind==NK_CONST) there is no need for
+ * the op, kids or any eval stuff!). However, only few nodes (less than 100?)
+ * are expected to be in memory at any time (how complex can a user
+ * expression be?). Hence, for clarity, no unions where used.
+ * 
+ * All nodes have kids in the typical way. the opcode OPK_FUNC node is tricky:
+ * see parsing - the commas are handled as operators and not as part of the
+ * syntax. when a func call is evaluated, the top comma nodes are used to
+ * separate the arguments (this hack prevents complex parsing and complex tnode
+ * with variable num of kids, which would force the kids[] to be malloc etc.)
+ */
+
+typedef struct snode {          /* a single node on an expression tree     */
+   tnode_kind node_kind ;       /* what kind of note this is               */
+                                /* NK_OP node info: op_kind,op,kids        */
+   int src_pos ;           /* starting source code location (op etc)  */
+   top_kind op_kind ;           /* opcode type (unary,bin etc)   */
+   topcode op ;                 /* actual opcode: '-' for both unary&bin '-'*/
+   struct snode *kids[NODE_MAX_KIDS] ;   /* pointers to node's kids     */
+   tvalue cnst ;                /* NK_CONST info - constant value       */
+   char *name ;                 /* NK_NAME  info - variable name        */
+   tctype *ctype ;              /* NK_CTYPE info - a type               */
+
+   struct {                     /* information used during node evaluation   */
+       int level ;              /* evaluation level (0=none, 1=left in x etc)*/
+       tvalue  v1,v2 ;          /* keep last computed operands, etc          */
+       tval_list vlist ;        /* value list for node (used in --> etc ops) */
+       int counter ;            /* used for counting            */
+   } eval ;             
+ } tnode ;
+
+
+DEF bool duel_debug ;                   /* debugging duel-itself mode   */
+DEF bool duel_output_pipe_style ;       /* pipe-style output of values  */
+
+/* this things are machine dependent stuff */
+
+#define BITS_PER_BYTE 8  /* no of bits in (char) (right. try '9' :-) */
--- gdb/duel/internals.doc
+++ gdb/duel/internals.doc
@@ -0,0 +1,129 @@
+DUEL 1.0x INTERNALS
+This documents some of the basics internal info, and might help porting
+duel. Incomplete and probably badly written. sorry.
+
+Entry points and modules
+--------------------------
+duel_eval_and_parse is entry point into duel, in duel.c
+duel_parse in parse.y does all parsing
+duel_eval  in eval.c makes the evaluation 
+evalop.c contains low-level evaluation
+misc.c   contains misc stuff
+types.c  type create/manage
+output.c all output goes thru duel_printf
+output2.c same as output, but support sending eval output to a pipe,
+	  like the duel.pipe perl script.
+print.c  all output of values is done here
+eval.c   high level evaluation code (generators)
+evalops.c low level evaluation code (operators)
+error.c   handle erros, display error info "nicely"
+
+start reading the code from duel.c, then global.h, then eval.c.
+eval.c is hairy, especially the state-keeping code. The goto's are
+intentional, they convey control better than other constructs. 
+
+Types
+------
+A relatively straight-forward system, if you have read code of real C
+compilers. A type is a "graph" with each node being a base type or
+a composition of other types. see global.h and types.c
+
+Value system
+-------------
+also pretty simple, either an LVALUE, which have u.lvalue point to it,
+or an RVALUE, so u.rval_type contains the actual value. There is also
+a special BVALUE hack to hold lvalued bitfields, which is only useful
+is someone implements modifying a bitfield. and there is an FVALUE, which
+is just stored in u.rval_int but has the special value type (it was either
+this or add a new TYPE, i preferred a new value).
+Note the there is no "register" type support. You must read register variables
+as rvalues (duelgdb.c does that). I don't think it is essential, since 
+gdb can be used directly to modify such values (this might be a
+problem in watchpoint/cond.breaks however). Also cc -g don't usually keep
+stuff in registers. We could add "SVALUE" for these.
+Bitfields are a pain, but bvalue is really needed, eg for x[..100].bitfield=0
+
+Memory allocation
+-----------------
+go through duel_malloc/duel_free. 
+Memory is allocated only for (a) a new node, while parsing, (b) a value pushed
+on stack for x-->y operator (c) duel aliases.
+It is always safe to call duel_free_nodes  which free everything except
+for aliases. 
+Memory spill can occur in asynchronous interrupts (^C), but they at most
+reflect items moved from one list to another. This isn't too bad.
+
+Interrupts
+----------
+Duel ignores the issues of interrupts, but is written so it can be
+interrupted at any time. Naturally, some memory could be lost if an
+operation is interrupted, since Duel does not setup critical sections.
+However, interrupts will no result in bad internal structures, so it is
+safe to call duel_free_nodes after an interrupt.
+duelgdb.c implements exactly that - interrupts at all times, and cleanup
+using duel_free_nodes.
+
+Parsing
+--------
+yacc is pretty weak, especially when I tried complex ops like x\y#z 
+(as a single, 3 val op!). I have up on such things and the syntax is
+pretty clean. Things to watch for are the semicolon nonsense,
+especially with optional-expressions (as in for(a;b;c);), the T hack
+for user types (only fix is to delay decision on (x)(y) till runtime
+or make clearer rules (consider   something; (x)(y), do you parse x as a type 
+and ignore the possible x:=printf in "something", etc), and the use of ","
+regular op and nodes for function parameters (the parser knows only about
+a single parameter, an exp!).
+
+Search ops
+-----------
+Straight forward stacking in dfs_... in eval.c 
+Note things are put in reversed, so root-->(left,right) does what you 
+expect. Also linked-lists could be greatly optimized.
+The functionality for ->> (BFS) is already in, all you need is to
+make the stack into a queue by pushing from the other side (really append)
+
+Multi-expressions
+--------------------
+As far as I know, you could save root (in duel.h) and use it to evaluate
+as often as needed (e.g for breakpoints/watchpoints), the internals
+of the nodes hold all eval info. You must reset the expression 
+with eval_stop, if u dont eval it to the last value. Also make sure you
+cleanup the dot stack. Aliases (in misc.c) could become scoped, of course.
+
+Interface to the debugger
+-------------------------
+
+What DUEL needs:
+1. A way to access the symbol table for variable names, types, etc.
+2. A way to access the value of a variable, both for read and writes.
+3. A way to call debuggee functions.
+4. A way to get locals of frame n
+5. misc functions, eg memory alloc, entery/exit code
+
+In practice, you will probably take duelgdb.c and modify it until you
+get the "right thing" for your debugger.
+NOTE: duelgdb.c was written from scratch and has *no* GNU code in it.
+
+The most complex issue is types - you must pass names in a tvalue,
+which include a tctype (the C reminds one of a "C" type, not just 'type'
+which is ambiguous). The code to convert gdb types into duel types is
+typical. Watch out for recursive struct pointers (the hash table handles
+these problems), and for partial types, e.g. pointer to struct which
+contains no fields (size zero!).
+
+You can return a BVALUE an LVALUE (preferred) or an RVALUE for a name 
+lookup. use RVALUE for names found in registers, and return the actual
+value. 
+
+if a frame number is given for symbol lookup, only local variables 
+allocated in that frame should be returned. (else return none. don't
+return a global if it exist with the same name, this will make the dot
+stack compute things wrong). 
+
+Node that this doesnt help with scoping problems (for duel)- e.g. 
+you can't do myfunc.x if x is a static variable in myfunc. There needs to
+be a more complex & general way in the language to specify this (i.e.
+specify a source location in which the variable is visible, AND a frame
+to use if the value is kept on a frame)  frame(n).(scope(file,line).x)?
+
--- gdb/duel/misc.c
+++ gdb/duel/misc.c
@@ -0,0 +1,145 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code                            */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* misc function/library-like */
+
+/*
+ * $Log: 10_all_gdb-6.6-duel.patch,v $
+ * Revision 1.1  2007/12/29 21:06:06  vapier
+ * add DUEL support #199987 by Sergei Golubchik
+ *
+ * Revision 1.5  93/03/12  05:51:00  mg
+ * support output redirection
+ * 
+ * Revision 1.4  93/01/13  16:22:09  mg
+ * allow malloc to return int (is a mini symbol on SUN)
+ * 
+ * Revision 1.3  93/01/12  21:52:43  mg
+ * moved aliases mgmt here
+ * cleanup and set for release
+ * 
+ */
+
+#include "duel.h"
+
+/* like strncpy, but put a zero at to[len] anyway.
+ * are copied (hence taking len+1 bytes
+ */
+
+FUNC char* strncpyz(char *to,char *from,size_t len)
+{
+   strncpy(to,from,len);
+   to[len]=0 ;
+   return to ;
+}
+
+/* allocate n bytes in the target's space. Used for storing constant
+ * strings when they are parsed, and for variables declaration
+ * note: on SUN (and others?) gdb claims malloc to return an integer. we
+ * accept this (silly but probably no harm done)
+ */
+
+FUNC ttarget_ptr duel_alloc_target_space(size_t n)
+{
+  tvalue p,f,r,*parms[1] ;
+
+  p.val_kind=VK_RVALUE ;        /* mk n into a value, to pass as parm */
+  p.ctype=ctype_int ;
+  p.u.rval_int=n ;
+  parms[0]= &p ;
+
+  if(!duel_get_target_variable("malloc",-1,&f) || 
+     f.ctype->type_kind!=CTK_FUNC || 
+     f.ctype->u.kid->type_kind!=CTK_INT && f.ctype->u.kid->type_kind!=CTK_PTR) 
+      duel_fatal("malloc() function returning a pointer required in target");
+
+  duel_target_func_call(&f,parms,1,&r);
+  if(r.u.rval_ptr==NULL) duel_fatal("target's malloc() failed");
+  return r.u.rval_ptr ;
+}
+
+PROC duel_free_val_list(tval_list *l)  /*free a val list and mark list empty */
+{
+  tval_lcell *cell,*next ;
+  for(cell=l->head ; cell!=NULL ; cell=next ) {
+      next=cell->next ;
+      duel_free(cell);
+  }
+  l->head=l->tail=NULL ;
+}
+
+/* free all the memory allocated in the parse tree from node */
+
+PROC duel_free_nodes(tnode *n)
+{
+    int i;
+    if(!n) return ;
+    for(i=0 ; i<NODE_MAX_KIDS ; i++) 
+        duel_free_nodes(n->kids[i]);
+    duel_free_val_list(&n->eval.vlist);
+    duel_free(n);
+}
+
+
+
+/* Aliases management */
+
+typedef struct sduel_var {      /* an alias */
+    char *name ;
+    tvalue val ;
+    struct sduel_var *next ;
+ } tduel_var ;
+tduel_var *duel_vars_head ;
+
+/* find the value of a duel variable, if exist (else return null */
+
+FUNC tvalue* duel_find_alias(char *name)
+{
+   tduel_var *p ;
+   for(p=duel_vars_head ; p ; p=p->next) {
+        if(strcmp(name,p->name)==0) return(&p->val);
+   }
+   return NULL ;
+}
+
+/* set a value of a duel alias. Create var as needed */
+
+PROC duel_set_alias(char *name,tvalue *v)
+{
+   tduel_var *p ;
+   tvalue *found = duel_find_alias(name) ;
+   if(found!=NULL) *found= *v ;
+   else {
+     p=duel_malloc(sizeof(tduel_var)) ;
+     p->next=duel_vars_head ;
+     p->val= *v ;
+     p->name=name ;
+     duel_vars_head=p ;
+  }
+}
+
+PROC duel_clear_aliases(void)   /* clear all defined aliases */
+{
+   tduel_var *p=duel_vars_head ;
+   while(p) {
+        tduel_var *q=p ;
+        p=p->next ;
+        duel_free(q);
+    }
+   duel_vars_head=0 ;
+}
+
+PROC duel_show_aliases(void)
+{
+   tduel_var *p ;
+   if(!duel_vars_head) duel_printf("No aliases defined\n");
+   else {
+     duel_printf("Aliases table:\n");
+     for(p=duel_vars_head ; p ; p=p->next) {
+        duel_printf("%s:  ",p->name);
+        duel_print_value(&p->val);
+     }
+   }
+}
+
+
+
--- gdb/duel/output.c
+++ gdb/duel/output.c
@@ -0,0 +1,53 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code                            */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* This module supports i/o for duel. Normally output goes to stdout,
+ * but it could be piped out instead. 
+ * this module support minimal duel output w/o pipes. output2.c which
+ * support piped i/o is still an alpha version.
+ */
+
+#include <stdarg.h>  /* for duel_printf */
+#include "duel.h"
+
+/* output functions:
+ * duel_printf	  all duel output goes thru this - like printf()
+ * duel_flush	  used by duel to flush the output.
+ */
+
+PROC duel_printf(char *fmt, ...)    /* like printf, but for duel output */
+{
+  va_list args;
+  va_start(args, fmt);
+  vfprintf(stdout,fmt,args);
+  va_end(args);
+}
+
+PROC duel_flush(void)	/* flush out output from duel */
+{
+   fflush(stdout);
+}
+
+/* tells us the output is "directable" now. s is the expression 
+ * being evaluated for this */
+
+PROC duel_redirectable_output_start(char *s)
+{
+   if(s) duel_flush();	/* if(s) is always true. prevents warnings ...*/
+}
+
+PROC duel_redirectable_output_end(void)
+{
+   duel_flush();
+}
+
+PROC duel_redirectable_output_abort(void)
+{
+    duel_flush();
+}
+
+PROC duel_redirectable_output_init(void)
+{
+}
--- gdb/duel/output2.c
+++ gdb/duel/output2.c
@@ -0,0 +1,141 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code                            */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* This module supports i/o for duel. Normally output goes to stdout,
+ * but it could be piped out instead.
+ * Still alpha version.
+ * HOW: if file duel.pipe exists, it is opened with stdin/out piped 
+ *      here.  results of expressions evaluations are sent to the pipe
+ *	       with $$$START $$$END $$$ABORT and $$$SYM/$$$VAL. The pipe's
+ *	       output is passed back here and is printed to stdout until
+ *	       a $$$DONE is received. The pipe is normally a perl script,
+ *	       that can processes the output at a symbolic level. 
+ */
+
+#include <stdarg.h>    /* for duel_printf */
+#include <sys/types.h> /* for stat() */
+#include <sys/stat.h>  /* " */
+#include <fcntl.h>     /* for popen impl. */
+#include <signal.h>    /* " */
+
+#include "duel.h"
+
+/* output functions:
+ * duel_printf	  all duel output goes thru this - like printf()
+ * duel_flush	  used by duel to flush the output.
+ * duel_redirectable_output_start(s) - indicate start of output for exp s that
+ *			      	       can be redirected to a pipe.
+ * duel_redirectable_output_end()   - indicate end of that output.
+ * duel_redirectable_output_abort() - indicate output was aborted (error,intr)
+ * 
+ * duel_redirectable_output_init()   - called to init at first duel use.
+ */
+
+static FILE *duel_outf = stdout ;      /* current output stream */
+static FILE *poutf,*pinf ;	       /* pipe i/o streams      */
+
+#define PIPE_CMD "./duel.pipe"		/* command to pipe into */
+
+bool bidir_popen(void)
+{
+	int pout[2],pin[2];  /* pin[0] is my input, pout[1] my output */
+	int pid;
+	struct stat s ;
+
+        if(stat(PIPE_CMD,&s)!=0 || !(s.st_mode & S_IEXEC)) return FALSE;
+	if (pipe(pout) < 0 || pipe(pin) < 0) return FALSE ;
+
+	if ((pid = fork()) == 0) {
+	    signal(SIGINT, SIG_IGN);
+	    signal(SIGQUIT, SIG_IGN);
+	    dup2(pout[0],0); dup2(pin[1],1);  
+	    close(pin[0]);  close(pin[1]); close(pout[0]); close(pout[1]);
+	    execl(PIPE_CMD, PIPE_CMD, NULL);
+	    _exit(127);
+	}
+	close(pout[0]);	close(pin[1]);
+	if (pid == -1) return FALSE;
+	pinf =fdopen(pin[0], "r");
+	poutf=fdopen(pout[1],"w");
+	if(fcntl(pin[0],F_SETFL,O_NDELAY) < 0) return FALSE ;
+        return pinf!=NULL && poutf!=NULL ;
+}
+
+
+PROC duel_printf(char *fmt, ...)    /* like printf, but for duel output */
+{
+  va_list args;
+  va_start(args, fmt);
+  vfprintf(duel_outf,fmt,args);
+  va_end(args);
+}
+
+PROC duel_flush(void)	/* flush out output from duel */
+{
+   char s[256];
+   fflush(duel_outf);
+   while(pinf && fgets(s,sizeof(s),pinf))   /* note pinf is non blocking */
+	printf("%s",s);
+}
+
+LPROC duel_waitpipe(bool abort)	/* wait for pipe to finish working */
+{
+   char s[256];
+   if(abort) duel_printf("$$$ABORT\n");		/* write termination mesg */
+   else	     duel_printf("$$$DONE\n");
+   fflush(duel_outf);
+   fcntl(fileno(pinf),F_SETFL,0);	/* restore blocking for pipe */
+   while(fgets(s,sizeof(s),pinf)!=NULL && strcmp(s,"$$$DONE\n")!=0) 
+	if(!abort) printf("%s",s);
+   fcntl(fileno(pinf),F_SETFL,O_NDELAY);
+   if(abort) printf("\n");
+}
+
+/* tells us the output is "directable" now. s is the expression 
+ * being evaluated for this */
+
+PROC duel_redirectable_output_start(char *s)
+{
+    duel_flush();
+    if(poutf) {
+	duel_flush();
+	duel_outf=poutf ;
+	duel_output_pipe_style=1 ;
+	duel_printf("$$$START: %s\n",s);
+	duel_flush();
+    }
+}
+
+PROC duel_redirectable_output_end(void)
+{
+    duel_flush();
+    if(poutf && duel_outf == poutf) {
+	duel_waitpipe(FALSE);
+	duel_outf=stdout ;
+	duel_output_pipe_style=0 ;
+    }
+}
+
+PROC duel_redirectable_output_abort(void)
+{
+    if(poutf && duel_outf == poutf) {
+	duel_waitpipe(TRUE);
+	duel_outf=stdout ;
+	duel_output_pipe_style=0 ;
+    }
+    duel_flush();
+}
+
+PROC duel_redirectable_output_init(void)
+{
+	/* open the duel pipe, if available. Verify that duel.pipe
+	 * as an existing executable, because popen() does not, and can
+         * later fail with pipe signal!
+         */
+         if(bidir_popen()) {
+	       duel_printf("Duel results directed to pipe \"duel.pipe\"\n");
+	}
+	else poutf=pinf=NULL ;
+}
--- gdb/duel/parse.y
+++ gdb/duel/parse.y
@@ -0,0 +1,940 @@
+%{
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code			           */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* this module contains the duel parser, in yacc, plus a simple lexer.
+ * the lexer is slow, but duel expressions are tiny.
+ * the parsing generate an AST with essentially no type checking.
+ * names are only looked up when the refer explicitly to types. This forces
+ * the use of "T" before user types. You can't parse (x)(y) correctly, if
+ * you want the node to contain "cast" or "func", without knowing the x is 
+ * not a type. (It is interesting to note that (x *)(y) is clearly a cast,
+ * but it can not be parsed without a context sensitive grammer!). 
+ *
+ * Version 1.1 now accept (x) as a type cast, so (print)("hi") fails, but
+ * (uint)z is ok. Also accepted is (uint*)z. T is still required in sizeof
+ * and in variable declarations. A side effect was making "sizeof x" illegal
+ * (since then sizeof(x)-1 was parsed sizeof((x)-1) with (x) a cast), so
+ * now sizeof(x) must be used. Note that in C, sizoef(x)++ is acceptable,
+ * and the '++' operate on x (which is optimized out!) This can be confusing.
+ *
+ * yacc is also not smart enough to recognize e.g. "if(e) e ; else e" as
+ * a special case (redundent ';'). I hacked this in the lexer. It should
+ * reduce the trouble with C->duel coding. (It can also be done for {e1}e2,
+ * in some speical cases, e.g. if e2 is a keyword, or a name or a unary op,
+ * but this can confuse some people, e.g. in {i}[5], so I left it alone.)
+ * Finally, the %/ operator is accepted as "#/" and "%%" as "#", to those
+ * who wish to keep gdb with # comments.
+ * memory: nodes are alloc'ed dynamically. a parsing error loose so-far
+ * allocated nodes, which is normally acceptable (yyerror can probably hack
+ * into the yacc stack to release them.)
+ */
+
+/*
+ * $Log: 10_all_gdb-6.6-duel.patch,v $
+ * Revision 1.1  2007/12/29 21:06:06  vapier
+ * add DUEL support #199987 by Sergei Golubchik
+ *
+ * Revision 1.14  93/03/17  11:04:12  mg
+ * fixed (t*)x bug, was parsed as (t**)x 
+ * 
+ * Revision 1.13  93/03/12  06:15:09  mg
+ * modified unary's a bit - cosmetics
+ * support (x)y as type cast
+ * support (x*)y as type cast
+ * replace sizeof exp  with sizeof(exp) to prevent clash with above
+ * more cosmetics, including yyerror abort, tuint for uint.
+ * takes anything after |> to be comment (pipe command really)
+ * 
+ * 
+ * Revision 1.12  93/02/27  06:06:09  mg
+ * added signed char parsing.
+ * 
+ * Revision 1.11  93/02/23  19:15:38  mg
+ * improved escaped char support
+ * 
+ * Revision 1.10  93/02/03  21:49:34  mg
+ * bug fix - yyerror calls now abort parsing (eg called from lex)
+ * 
+ * Revision 1.9  93/01/12  21:53:07  mg
+ * cleanup and set for release
+ * 
+ * Revision 1.8  93/01/07  00:14:33  mg
+ * add &&/ ||/
+ * fixed parsing of trailing ';' was a mess.
+ * ignore ';' before 'else' and '}' w/warning.
+ * 
+ * Revision 1.7  93/01/03  07:31:01  mg
+ * error reporting
+ * 
+ * Revision 1.6  92/12/24  23:35:50  mg
+ * began src pos support
+ * 
+ * Revision 1.5  92/10/19  15:08:02  mg
+ * frames() added; bug fixed
+ * 
+ * Revision 1.4  92/10/14  02:06:32  mg
+ * misc/change casting parsing/variable def.
+ * 
+ * Revision 1.3  92/09/16  11:09:39  mg
+ * add typedef/struct support, const strings 
+ * cleanup s/r conflict by setting ELSE to a token. explained some stuff in
+ * comments.
+ * 
+ * Revision 1.2  92/09/15  06:10:46  mg
+ * cosmetics and new ops: x@y, for() while() ..x and x..
+ * generic '.' and '_'  support. x@y. '..x' and 'x..'.  while(), for(), ?:
+ * 
+ */
+
+#include "duel.h"
+
+static char *inputstr ;		/* pointer to string being parsed */
+static char *lexptr ;           /* current lexer pointer into input str */
+static tnode *root ;		/* result of parsing stored here */
+
+/* pick unique names for globals of yacc. gdb has other parsers! */
+#define	yyparse	duel_yyparse
+#define	yylex	duel_yylex
+#define	yyerror	duel_yyerror
+#define	yylval	duel_yylval
+#define	yychar	duel_yychar
+#define	yydebug	duel_yydebug
+#define	yypact	duel_yypact	
+#define	yyr1	duel_yyr1			
+#define	yyr2	duel_yyr2			
+#define	yydef	duel_yydef		
+#define	yychk	duel_yychk		
+#define	yypgo	duel_yypgo		
+#define	yyact	duel_yyact		
+#define	yyexca	duel_yyexca
+#define yyerrflag duel_yyerrflag
+#define yynerrs	duel_yynerrs
+#define	yyps	duel_yyps
+#define	yypv	duel_yypv
+#define	yys	duel_yys
+#define	yystate	duel_yystate
+#define	yytmp	duel_yytmp
+#define	yyv	duel_yyv
+#define	yyval	duel_yyval
+#define	yylloc	duel_yylloc
+
+typedef struct {                /* token info for operators */
+        int src_pos ;            /* source position */
+        topcode opcode ;        /* opcode          */
+       } topinfo ;
+
+typedef struct {                /* token info for symbols */
+        int src_pos ;            /* source position */
+        char *name ;             /* symbol          */
+       } tnameinfo ;
+
+/* these are used as operators to mknode_... when source location is unknown*/
+static topinfo seq_op  = { -1,';' } ; /* sequencing operator, src pos unkown */
+static topinfo decl_op = { -1,OP_DECL } ; /* declare var op, src pos unkown */
+
+/* local prototypes. */
+LPROC  yyerror(char *msg);
+LFUNC  int yylex (void);
+
+LPROC push_type(char desc) ;
+LPROC push_type_int(char desc,tnode *n)  ;
+LFUNC bool pop_type(char *desc,int *size);
+
+LFUNC tnode* mknode_op(top_kind,topinfo opinfo,tnode*,tnode*,tnode*,tnode*);
+LFUNC tnode* mknode_const(int src_pos,tctype *ctype);
+LFUNC tnode* mknode_ctype(tctype *ctype);
+LFUNC tnode* mknode_name(tnameinfo nameinfo);
+LFUNC tnode* mknode_modified_ctype(tctype *base);
+
+#define mknode_post_unary(op,n) (mknode_op(OPK_POST_UNARY,op,n, 0, 0,0))
+#define mknode_unary(op,n)      (mknode_op(OPK_UNARY,     op,n, 0, 0,0))
+#define mknode_sunary(op,n)     (mknode_op(OPK_SUNARY,    op,n, 0, 0,0))
+#define mknode_bin(op,n1,n2)    (mknode_op(OPK_BIN,       op,n1,n2,0,0))
+#define mknode_sbin(op,n1,n2)   (mknode_op(OPK_SBIN,      op,n1,n2,0,0))
+#define mknode_tri(op,n1,n2,n3) (mknode_op(OPK_TRI,       op,n1,n2,n3,0))
+
+static tctype *decl_tbase ; /* used for variables decl */
+
+/* #define	YYDEBUG	1 */
+
+%}
+
+%union
+  {
+    tnode   *node ;                 /* node pointer for constructed exp tree */
+    tctype  *ctype;                 /* type for type nodes                   */
+    tnameinfo nameinfo ;            /* a name/symbol + src position */
+    topinfo opinfo;                 /* keyword/operator + source position    */
+  }
+
+%type  <node>   start duel_inp duel_exp exp type nameexp sm_exp oexp  
+%type  <node>   all_decls vars_decl var_decl name_decl1 name_decl
+%type  <ctype>  typebase 
+%type  <nameinfo>   name
+
+%token <node>   T_CONST
+%token <nameinfo>   T_SYM
+%token <opinfo> T_ASSIGN T_DEFVAR
+
+
+%token <opinfo> T_CHAR T_INT T_SHORT T_LONG  T_UNSIGNED T_FLOAT T_DOUBLE T_VOID
+%token <opinfo> T_STRUCT T_UNION T_ENUM T_SIZEOF T_TYPEDEF_INDICATOR T_SIGNED
+
+%token <opinfo> T_IF T_ELSE T_FOR T_WHILE 
+%token <opinfo> ';' ',' '=' '?' '|' '^' '&' '<' '>' '+' '-' '*' '/' '%'
+%token <opinfo> '.' '[' ']' '(' ')' '{' '}' '#' '@' '!' '~' 
+%token <opinfo> T_OR T_AND T_RSH T_LSH T_INC T_DEC T_COUNT T_FRAME T_TO
+%token <opinfo> T_DFS T_BFS T_ARROW T_OSEL T_CSEL T_IMP T_ANDL T_ORL
+%token <opinfo> T_EQ T_NE T_EQQ T_NEQ T_LE T_GE T_LSQ T_GTQ T_LEQ T_GEQ
+
+%left  ';'
+%right STMT T_ELSE
+%right T_IMP
+%right ','
+%right '=' T_ASSIGN T_DEFVAR
+%right '?'
+%left  T_OR  T_ORL
+%left  T_AND T_ANDL
+%left  '|'
+%left  '^'
+%left  '&'
+%left  T_EQ T_NE T_EQQ T_NEQ
+%left  '<' '>' T_LE T_GE T_LSQ T_GTQ T_LEQ T_GEQ
+%nonassoc T_TO
+%left  T_LSH T_RSH
+%left  '+' '-'
+%left  '*' '/' '%'
+%right UNARY '!' '~' T_INC T_DEC T_COUNT T_FRAME
+%left T_DFS T_BFS T_POS T_ARROW '.' '[' ']' '(' ')' '{' '}' '#' '@' T_OSEL T_CSEL 
+%%
+
+start : duel_inp     { root=$1 ; }
+      ;
+
+duel_inp : all_decls 
+         | all_decls ';'
+         | all_decls ';' duel_exp	{ $$=mknode_sbin($2,$1,$3);}
+         | duel_exp
+         ;
+duel_exp : sm_exp
+         | sm_exp ';' { $$=mknode_sbin($2,$1,0); }
+         ;
+all_decls:  vars_decl			      
+          | all_decls ';' vars_decl  	{ $$=mknode_sbin($2,$1,$3); }
+          ;
+
+vars_decl: typebase { decl_tbase=$1 ; } var_decl { $$=$3 ; }
+         ;
+var_decl : name_decl1
+         | var_decl ',' name_decl1  { $$=mknode_sbin(seq_op,$1,$3); }
+         ;
+
+name_decl1: name_decl	    { $$=mknode_sbin(decl_op,$1,
+ 				   mknode_modified_ctype(decl_tbase)); }
+          ;
+
+name_decl : '(' name_decl ')'		   { $$=$2 ; }
+	  | '(' name_decl ')' '(' ')'	   { $$=$2 ; push_type('('); }
+	  | '*' name_decl	           { $$=$2 ; push_type('*'); }
+	  | name_decl '[' T_CONST ']' 	   { $$=$1 ; push_type_int('[',$3); }
+	  | nameexp
+	  ;
+
+/* Statements   - not really, these are expressions too!
+   Notes: for(;;) oexp - will create lots of shift/reduce conflicts, 
+                        'for(;;;)' and 'for(;;) exp' are specified
+			instead and yacc handle this as a "standard" s/r.
+			the only diff is yacc dont complain on these!
+	   if() - same comments as above, plus, we prevent meaningless
+	          if's like in C: ' if(x); else;' - a useless statement.
+ */
+exp   :   T_IF '(' exp ')' exp %prec STMT { $$=mknode_tri($1,$3,$5,0); }
+      |   T_IF '(' exp ')' exp T_ELSE %prec STMT 
+                                          { $$=mknode_tri($1,$3,$5,0); } 
+      |   T_IF '(' exp ')' T_ELSE exp %prec STMT 
+                                          { $$=mknode_tri($1,$3,0,$6); } 
+      |   T_IF '(' exp ')' exp T_ELSE exp %prec STMT 
+                                          { $$=mknode_tri($1,$3,$5,$7); } 
+
+      |   T_FOR '(' oexp ';' exp ';' oexp ')' exp %prec STMT
+                              {  $$=mknode_op(OPK_QUAD,$1,$3,$5,$7,$9); } 
+      |   T_FOR '(' oexp ';' exp ';' oexp ')' %prec STMT
+                              {  $$=mknode_op(OPK_QUAD,$1,$3,$5,$7,0); } 
+      |   T_WHILE '(' exp ')' exp %prec STMT
+                              {  $$=mknode_sbin($1,$3,$5); } 
+      |   T_WHILE '(' exp ')' %prec STMT
+                              {  $$=mknode_sbin($1,$3,0); } 
+      ;
+
+/* Expressions  */
+
+exp   :      '*' exp          %prec UNARY  { $$=mknode_unary( $1,$2); }
+      |      '&' exp          %prec UNARY  { $$=mknode_unary( $1,$2); }
+      |      '-' exp          %prec UNARY  { $$=mknode_unary( $1,$2); }
+      |      '!' exp            	   { $$=mknode_unary( $1,$2); }
+      |      '~' exp                       { $$=mknode_unary( $1,$2); }
+      |  T_COUNT exp                 	   { $$=mknode_sunary($1,$2); }
+      |   T_ANDL exp	      		   { $$=mknode_sunary($1,$2); }
+      |   T_ORL  exp	      		   { $$=mknode_sunary($1,$2); }
+      |    T_INC exp                  	   { $$=mknode_unary( $1,$2); }
+      |    T_DEC exp                       { $$=mknode_unary( $1,$2); }
+      |    exp T_INC                       { $$=mknode_post_unary($2,$1); }
+      |    exp T_DEC                  	   { $$=mknode_post_unary($2,$1); }
+      |	T_SIZEOF '(' type ')'   	   { $$=mknode_sunary($1,$3); }
+      | T_SIZEOF '(' exp  ')'   	   { $$=mknode_unary($1,$3); }
+      | T_FRAME '(' exp ')'   %prec UNARY  { $$=mknode_unary( $1,$3); }
+      ;
+
+exp  :  exp T_DFS exp                     { $$=mknode_sbin($2,$1,$3); }
+      |  exp T_BFS exp                    { $$=mknode_sbin($2,$1,$3); }
+
+      |  exp '#' nameexp                  { $$=mknode_sbin($2,$1,$3); }
+      |  exp '@'     exp            { $$=mknode_sbin($2,$1,$3); }
+      |  exp T_ARROW exp            { $$=mknode_sbin($2,$1,$3); }
+      |  exp '.'     exp            { $$=mknode_sbin($2,$1,$3); }
+      |  exp '[' exp ']'            { $$=mknode_bin( $2,$1,$3); }
+      |  exp T_OSEL exp T_CSEL      { $$=mknode_sbin($2,$1,$3); }
+      |  exp '(' oexp ')' %prec '.' { $$=mknode_op(OPK_FUNC,$2,$1,$3,0,0); }
+      |  '(' sm_exp ')'             { $$=mknode_unary($1,$2); }
+      |  '{' sm_exp '}'             { $$=mknode_unary($1,$2); }
+      ;
+
+exp  :  '(' type ')' exp  %prec UNARY
+                                   { $$=mknode_op(OPK_CAST,$1,$2,$4,0,0); }
+/* HACKS to handle the most common cast cases with a typedef, without
+ * requiring a 'T'. This code breaks (printf)("hi"), which returns the
+ * error "printf not a typedef", but otherwise it works ok. 
+ * It might be confusing since "(uint *)p" works but "(uint (*)())p" wont,
+ * but it seems that (uint*)p, (uint)x are the most common, and users get
+ * confused w/o them. 
+ * The code below works essentially with context-sensitive parsing!
+ * see the hacked %prec for nameexp which prevents yacc s/r warning!
+ */
+     |  '(' name ')' exp %prec UNARY { 
+                  tctype *t=duel_get_target_typedef($2.name);
+                  if(t==NULL) yyerror("not a typedef name"); 
+                  $$=mknode_op(OPK_CAST,$1,mknode_ctype(t),$4,0,0); }
+     |  '(' name '*' type_mod ')' exp %prec UNARY { 
+                 tctype *t=duel_get_target_typedef($2.name);
+                 if(t==NULL) yyerror("not a typedef name"); 
+                 push_type('*');
+                 $$=mknode_op(OPK_CAST,$1,mknode_modified_ctype(t),$6,0,0); }
+     ;
+
+ /* Bin ops in decreasing precedence order:  */
+
+exp	:      exp  '*'  exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp  '/'  exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp  '%'  exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp  '+'  exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp  '-'  exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp T_LSH exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp T_RSH exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp T_EQ  exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp T_NE  exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp T_EQQ exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp T_NEQ exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp T_LE  exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp T_GE  exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp T_LEQ exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp T_GEQ exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp  '<'  exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp  '>'  exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp T_LSQ exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp T_GTQ exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp  '&'  exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp  '|'  exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp  '^'  exp	{ $$=mknode_bin($2,$1,$3); }
+   	|      exp T_AND exp	{ $$=mknode_sbin($2,$1,$3); }
+   	|      exp T_OR  exp	{ $$=mknode_sbin($2,$1,$3); }
+        ;
+
+exp	:    exp '?' exp ':' exp  %prec '?'
+                	{ $$=mknode_tri($2,$1,$3,$5); }
+	;
+			  
+exp	:    exp   '='    exp  { $$=mknode_bin($2,$1,$3); }
+   	|    exp T_ASSIGN exp  { $$=mknode_op(OPK_ASSIGN,$2, $1,$3,0,0);  }
+   	|nameexp T_DEFVAR exp  { $$=mknode_sbin($2,$1,$3);  }
+	;
+
+     /* generating expressions */
+
+exp	:      exp T_TO  exp   { $$=mknode_sbin($2,$1,$3); }
+        |      T_TO exp	       { $$=mknode_sbin($1, 0,$2); }
+        |      exp T_TO        { $$=mknode_sbin($2,$1, 0); }
+        |	exp ',' exp    { $$=mknode_sbin($2,$1,$3); }
+        |      exp T_IMP exp   { $$=mknode_sbin($2,$1,$3); }
+        ;
+
+sm_exp  :	sm_exp ';' exp { $$=mknode_sbin($2,$1,$3); }
+        |       exp 
+	;
+
+oexp	:	exp		/* optional expression, eg in for() */
+        |			{ $$=0 ; }
+        ;
+
+exp	:	T_CONST  ;
+exp	:	nameexp  ;
+               /* convert a string input (name) into an expression. 
+		* precedence of '+' is a hack to make the special case
+		* of (x*)(y) parsed as a cast, without shift/reduce conflict
+		*(this would work the same w/o the '+' but gives warning)
+		*/
+nameexp	:	name %prec '+'    { $$=mknode_name($1) ; } ;
+
+type	:	typebase type_mod { $$=mknode_modified_ctype($1); }
+        ;
+/* type_mod has no value. bison warning is meaningless. I cant find a way
+ * to shut it up
+ */
+type_mod: '(' type_mod ')'
+	| '(' type_mod ')' '(' ')'	   {  push_type('('); }
+	| '*' type_mod	 	           {  push_type('*'); }
+	| type_mod '[' T_CONST ']' 	   {  push_type_int('[',$3); }
+	| 
+	;
+
+
+/* note that names are evaluated at runtime. hence (name)(x) is ambigious
+ * as either a function call or a cast.
+ * We could identify a typedef 'name' as such and return a special token from
+ * the lexr, but this will make 'x.(5+y)' illegal if y is both a field and
+ * a typedef (Note that gdb's own code include such things).
+ *
+ * there is a complex solution, that keeps the the casting as a syntax tree,
+ * and compute ctype at runtime, too. However, we want to compute all types at
+ * parse time. Out solution forces the reserved word T_TYPEDEF_INDICATOR to
+ * appear before any typedef name. (the reserved word is normally just 'T')
+ * example: instead of '(list *) x'  use in duel:  '(T list *) x'
+ */
+
+typebase:	T_TYPEDEF_INDICATOR name           {
+                    $$=duel_get_target_typedef($2.name);
+		    if($$==NULL) {
+		       tvalue v;
+		       if(duel_get_target_variable($2.name,-1,&v)) $$=v.ctype;
+		       else  yyerror("not a typedef name"); 
+		    }
+		} 
+        ;
+
+typebase:	T_CHAR                   { $$ = ctype_char;  }
+	|	T_SIGNED T_CHAR          { $$ = ctype_schar; }
+	|	T_UNSIGNED T_CHAR        { $$ = ctype_uchar; }
+	|	T_INT                    { $$ = ctype_int;   }
+	|	T_UNSIGNED               { $$ = ctype_uint;  }
+	|	T_UNSIGNED T_INT         { $$ = ctype_uint;  }
+	|	T_LONG                   { $$ = ctype_long;  }
+	|	T_LONG T_INT             { $$ = ctype_long;  }
+	|	T_UNSIGNED T_LONG        { $$ = ctype_ulong; }
+	|	T_UNSIGNED T_LONG T_INT  { $$ = ctype_ulong; }
+	|	T_LONG T_LONG            { $$ = ctype_longlong; }
+	|	T_LONG T_LONG T_INT      { $$ = ctype_longlong; }
+	|	T_UNSIGNED T_LONG T_LONG { $$ = ctype_ulonglong; }
+	|	T_UNSIGNED T_LONG T_LONG T_INT { $$ = ctype_ulonglong; }
+	|	T_SHORT                  { $$ = ctype_short; }
+        |	T_SHORT T_INT		 { $$ = ctype_short; }
+	|	T_UNSIGNED T_SHORT    	 { $$ = ctype_ushort; }
+	|	T_UNSIGNED T_SHORT T_INT { $$ = ctype_ushort; }
+        |       T_FLOAT                  { $$ = ctype_float ; }
+        |       T_DOUBLE                 { $$ = ctype_double; }
+        |	T_VOID			 { $$ = ctype_void;   }
+	|	T_STRUCT name
+		   { $$ = duel_get_target_struct_tag($2.name);
+		     if($$==NULL) yyerror("not a struct tag"); }
+	|	T_UNION name
+		   { $$ = duel_get_target_union_tag($2.name);
+		     if($$==NULL) yyerror("not a union tag"); }
+	|	T_ENUM name
+		   { $$ = duel_get_target_enum_tag($2.name);
+		     if($$==NULL) yyerror("not an enum tag"); }
+        ;
+
+name    : T_SYM ;
+%%
+
+static struct stoken {    /* all opcodes we recognize */
+  char *opstr ;                 /* op code as a string      */
+  int token ;                   /* token to return to yacc  */
+  int opcode ;                  /* opcode value associated with the token */
+ } tokens[] =  {                /* the special tokens, longer ones 1st! */
+    {">>=",T_ASSIGN, OP_RSH},
+    {"<<=",T_ASSIGN, OP_LSH},
+    {"-->",T_DFS,    OP_DFS},
+    {"->>",T_BFS,    OP_BFS},
+    {"==?", T_EQQ,   OP_EQQ},
+    {"!=?", T_NEQ,   OP_NEQ},
+    {"<=?", T_LEQ,   OP_LEQ},
+    {">=?", T_GEQ,   OP_GEQ},
+    {"&&/", T_ANDL,  OP_AND},
+    {"||/", T_ORL,   OP_OR},
+
+    {"<?", T_LSQ,    OP_LSQ},
+    {">?", T_GTQ,    OP_GTQ},
+    {"#/", T_COUNT,  '#' },
+    {"%/", T_COUNT,  '#' }, /* gdb insists to recognize # as start of comma!*/
+    {"%%", '#',      '#' }, /* same. so %/ for #/ and %% for #. not doc!*/
+    {"+=", T_ASSIGN,  '+'},
+    {"-=", T_ASSIGN,  '-'},
+    {"*=", T_ASSIGN,  '*'},
+    {"/=", T_ASSIGN,  '/'},
+    {"%=", T_ASSIGN,  '%'},
+    {"|=", T_ASSIGN,  '|'},
+    {"&=", T_ASSIGN,  '&'},
+    {"^=", T_ASSIGN,  '^'},
+    {":=", T_DEFVAR,OP_DEF},
+    {"++", T_INC,   OP_INC },
+    {"--", T_DEC,   OP_DEC },
+    {"->", T_ARROW, OP_ARR },
+    {"&&", T_AND,   OP_AND },
+    {"||", T_OR,    OP_OR  },
+    {"<<", T_LSH,   OP_LSH },
+    {">>", T_RSH,   OP_RSH },
+    {"==", T_EQ,    OP_EQ  },
+    {"!=", T_NE,    OP_NE  },
+    {"<=", T_LE,    OP_LE  },
+    {">=", T_GE,    OP_GE  },
+    {"..", T_TO,    OP_TO  },
+    {"=>", T_IMP,   OP_IMP },
+    {"[[", T_OSEL,  OP_SEL },
+    {"]]", T_CSEL,  OP_SEL },
+  };
+
+static struct skeyword {  /* all keywords we recognize */
+  char *keyword_str ;           /* keyword as a string       */
+  int token ;                   /* token to return to yacc   */
+  topcode opcode ;              /* opcode associated w/keyword */
+ } keywords[] = {
+    {"if",	T_IF	   , OP_IF},
+    {"else",	T_ELSE	   },
+    {"for",	T_FOR	   , OP_FOR},
+    {"while",	T_WHILE	   , OP_WHILE},
+    {"sizeof",  T_SIZEOF   , OP_SIZ},
+    {"frame",	T_FRAME	   , OP_FRAME},
+
+    {"T", 	T_TYPEDEF_INDICATOR  },
+    {"struct",  T_STRUCT   },
+    {"union",   T_UNION    },
+    {"enum",    T_ENUM     },
+
+    {"unsigned",T_UNSIGNED },
+    {"signed",  T_SIGNED   },
+    {"short",   T_SHORT    },
+    {"long",    T_LONG     },
+    {"char",    T_CHAR     },
+    {"int",     T_INT      },
+    {"double",  T_DOUBLE   },
+    {"float",   T_FLOAT    },
+    {"void",	T_VOID	   },
+   } ;
+
+
+LFUNC tnode* duel_lex_int(void)    /* parse next token as integer num */
+{
+   tnode *n ;
+   tulonglong val=0 ;
+   char *p=lexptr ;
+   bool is_l=0,is_u=0 ;
+   int base=10 ;
+   int src_pos=lexptr-inputstr ;
+   
+   if(*p=='0') {                        /* figure out the base */
+      p++ ;
+      if(*p=='x' || *p=='X') base=16,p++ ;
+      else 
+      if(isdigit(*p)) base=8 ; /* avoid having '0' as a base 8 (uint) */
+   }
+
+   while(isdigit(*p) || base==16 && isxdigit(*p)) {  /* get the value */
+      val*=base ;
+      if(isupper(*p)) val+= *p-'A'+10 ;
+      else if(islower(*p)) val+= *p-'a'+10 ;
+      else val+= *p-'0' ;
+      p++ ;
+   }
+   for (;*p;p++) {          /* yuk. figure 0L etc */
+     if (*p == 'l' || *p == 'L') is_l++;
+     else if(*p == 'u' || *p == 'U') is_u++;
+     else break;
+   }
+   is_u=is_u || base!=10 ;
+
+   if((is_l>1 && is_u) || (long long) val < 0 || ((tulong) val != val && is_u)) {
+        n=mknode_const(src_pos,ctype_ulonglong);
+        n->cnst.u.rval_ulonglong=val ;
+   }
+   else
+   if(is_l>1 || (tulong) val != val) {
+        n=mknode_const(src_pos,ctype_longlong) ; 
+        n->cnst.u.rval_longlong=(long long) val ; 
+   }
+   else
+   if((is_l && is_u) || (long) val < 0 || ((tuint) val != val && is_u)) {
+        n=mknode_const(src_pos,ctype_ulong);
+        n->cnst.u.rval_ulong=val ;
+   }
+   else
+   if(is_l || (tuint) val != val) {
+        n=mknode_const(src_pos,ctype_long) ; 
+        n->cnst.u.rval_long=(long) val ; 
+   }
+   else
+   if(is_u || (int) val < 0) {
+        n=mknode_const(src_pos,ctype_uint) ; 
+        n->cnst.u.rval_uint=(tuint) val ; 
+   }
+   else {
+        n=mknode_const(src_pos,ctype_int) ; 
+        n->cnst.u.rval_int=(int) val ; 
+   }
+   strncpyz(n->cnst.symb_val,lexptr,p-lexptr); /* save the symbolic val*/
+   lexptr=p ;
+   return n ;
+}
+
+LFUNC tnode* duel_lex_float(void)    /* parse next token as float num */
+{
+  tnode *n=0 ;
+  char *p=lexptr ;
+  double val ;
+  char c,tmpc ;
+  bool ok=TRUE;
+  int src_pos = lexptr - inputstr ;
+
+  /* this is disgusting.. why isnt there a lib call to recognize floats?! */
+  while(isdigit(*p)) p++ ;
+  if(*p=='.') p++ ;
+  while(isdigit(*p)) p++ ;
+  if(*p=='e' || *p=='E') {
+     p++ ;
+     if(*p=='+' || *p=='-') p++ ;
+     if(!isdigit(*p)) ok=FALSE ;     /* force digit (scanf allows 1e-.2 ?!) */
+     while(isdigit(*p)) p++ ;
+  }
+  tmpc= *p ; *p=0 ;
+  ok=ok && sscanf(lexptr,"%lf%c",&val,&c)==1 ;
+  *p=tmpc ;
+  if(!ok) yyerror("Invalid float constant.");
+
+  n=mknode_const(src_pos,ctype_double); 
+  n->cnst.u.rval_double=val ; 
+  strncpyz(n->cnst.symb_val,lexptr,p-lexptr); /* save the symbolic val*/
+  lexptr=p ;
+  return(n);
+}
+
+/* parse_escaped_char -- parse an escaped char (e.g. '\n'). 
+ * lexptr expected to point to text right after the '\'. 
+ * return: actual char value (e.g. 012 if 'n' or '012' is found.)
+ *         lexptr is advanced after the espaced char.
+ */
+
+LFUNC char parse_escaped_char(void)
+{
+  char retc ;
+  switch(lexptr[0]) { 
+   /*case 'a': retc='\a' ; break ;	/* some compilers don't support it. */
+   case 'b': retc='\b' ; break ;
+   case 'f': retc='\f' ; break ;
+   case 'n': retc='\n' ; break ;
+   case 'r': retc='\r' ; break ;
+   case 't': retc='\t' ; break ;
+   case 'v': retc='\v' ; break ;
+   case 'x': yyerror("hex char const not yet suppported");
+   case '0': case '1': case '2': case '3': 
+	     retc= lexptr[0] - '0' ;
+	     if(lexptr[1]>='0' && lexptr[1]<='7') 
+		retc= retc* 010 +  *++lexptr - '0' ;
+	     if(lexptr[1]>='0' && lexptr[1]<='7') 
+		retc= retc* 010 +  *++lexptr - '0' ;
+             break ;
+   default:  retc=lexptr[0] ;     /* default also takes care of '\'' '\\' */
+  }
+  lexptr++ ;
+  return retc ;
+}
+
+/* FUNC yylex -- return the next token to yacc. 
+ * GLOBALS: lexptr point to the string we are parsing next. it is updated.
+ */
+
+LFUNC int yylex (void)
+{
+  int c,i,src_pos ;
+  char *p ;
+
+  for(c= *lexptr; c==' ' || c=='\t' || c=='\n' ; c= *++lexptr); /* skip blank*/
+
+  src_pos = lexptr - inputstr ;	/* current char being parsed */
+  yylval.opinfo.src_pos = src_pos ;
+
+  if(*lexptr=='\0' || strncmp(lexptr,"|>",2)==0) return 0 ; /* end of expr */
+
+  for (i = 0;  i < sizeof(tokens)/sizeof(struct stoken) ; i++) { 
+    int l=strlen(tokens[i].opstr) ;             /* check next token vs table */
+    if(strncmp(lexptr,tokens[i].opstr,l)==0) {
+	lexptr+=l ;
+	yylval.opinfo.opcode = tokens[i].opcode;
+	return tokens[i].token ;
+    }
+  }
+
+  switch (c = *lexptr) {
+    case '\'':                /* char constant, but stored as int (ansi-c) */
+      p=lexptr++ ;
+      c = *lexptr++ ;
+      if (c == '\\') c=parse_escaped_char();
+      if( *lexptr++ != '\'') yyerror("Invalid character constant.");
+      yylval.node=mknode_const(src_pos,ctype_int) ;
+      yylval.node->cnst.u.rval_int=c ;
+      strncpyz(yylval.node->cnst.symb_val,p,lexptr-p); /*save the symbol. val*/
+      return T_CONST ;
+    
+    case '0':                           /* chk hex  */
+        if(lexptr[1]=='x' || lexptr[1]=='X') {
+           yylval.node=duel_lex_int(); 
+           return T_CONST ;
+        }
+        /* fall thru for other numbers */
+    case '1': case '2': case '3':      /* decimal or floating point number */
+    case '4': case '5': case '6': case '7': case '8': case '9':
+          for(p=lexptr ; *p>='0' && *p<='9' ; p++ ) ;  /*find next non digit*/
+          if(*p=='.' && p[1]!='.' || *p=='e' || *p=='E') 
+               yylval.node=duel_lex_float();
+          else yylval.node=duel_lex_int();
+          return T_CONST ;
+
+    case '(':  case ')':
+    case '<':  case '>':
+    case '[':  case ']':
+    case '{':  case '}':
+    case '+':  case '-':  case '*':  case '/':  case '%':
+    case '|':  case '&':  case '^':  case '~':  case '!':
+    case ',':  case '?':  case ':':  case '=':  
+    case '.':  case '@':  case '$':  case '#':  case '`': case '\\': 
+      lexptr++;
+      yylval.opinfo.opcode=c ;
+      return c;
+    case ';': { /* hack, ignore ';' before '}' and else. for C compatability*/
+	        char *save_lexptr= ++lexptr ;
+		int tok=yylex()	;	/* hack, call myself for next token */
+		if(tok=='}' || tok==T_ELSE) {
+		    duel_printf("warning: useless ';' ignored\n");
+		    return tok ;
+		}
+		/* else restore position and return the ';' */
+		lexptr=save_lexptr ;
+		yylval.opinfo.opcode=';' ;
+		yylval.opinfo.src_pos = src_pos ;
+		return ';';
+    }
+    case '"': {
+          char s[512] ;
+	  size_t len=0 ;
+	  ttarget_ptr dptr ;
+	  tnode *n ;
+
+	  p=lexptr++ ; 
+	  while((c= *lexptr++)!='"') {
+	       if (c == '\\') c=parse_escaped_char();
+	       s[len++]=c ;
+	  }
+	  s[len++]=0 ;
+	  dptr=duel_alloc_target_space(len);
+	  duel_put_target_bytes(dptr,s,len);
+	  
+	  n=mknode_const(src_pos,ctype_charptr); 
+	  n->cnst.u.rval_ptr=dptr ; 
+	  len=lexptr-p ;
+	  if(len>60) len=60 ;
+	  strncpyz(n->cnst.symb_val,p,len); /* save the symbolic val*/
+          yylval.node=n ;
+          return T_CONST ;
+      }
+    }
+
+  if(c != '_' && !isalpha(c))
+     yyerror ("Invalid character in expression.");
+
+  p=lexptr ;
+  do { c= *++lexptr ; } while(c=='_' || isalnum(c));
+  
+  for (i = 0;  i < sizeof(keywords)/sizeof(struct skeyword) ; i++) { 
+    int l=strlen(keywords[i].keyword_str) ;   /* check next token vs keywords*/
+    if(l==lexptr-p && strncmp(p,keywords[i].keyword_str,l)==0) {
+        yylval.opinfo.opcode=keywords[i].opcode ;
+	return keywords[i].token ;
+    }
+  }
+
+  /* the symbol/name found is not a reserved word, so return it as a T_SYM
+   */
+    
+  i=lexptr-p ;          /* length of string found (symbol/name) */
+  yylval.nameinfo.src_pos=src_pos ;
+  yylval.nameinfo.name=duel_malloc(i+1);
+  strncpyz(yylval.nameinfo.name,p,i);
+  return T_SYM;
+}
+
+LPROC yyerror(char *msg)
+{
+  int i,n=lexptr-inputstr ;
+  duel_printf("%s\n",inputstr);
+  for(i=0 ; i<n ; i++) duel_printf("-");
+  duel_printf("^ %s\n",msg);
+  duel_abort();		/* terminate parsing. some callers depend on this*/
+}
+
+/*************************************************************************/
+/* utility functions used to parse the expression and build it as a tree */
+/*************************************************************************/
+
+/* mknode_op -- make a tree node of type op with given opcode and kids
+ */
+
+LFUNC tnode* mknode_op(top_kind op_kind,topinfo opinfo,
+                       tnode *k1,tnode *k2,tnode *k3,tnode *k4)
+{
+   tnode *n ;
+   duel_assert(opinfo.opcode>' ');
+   n=(tnode *) duel_malloc(sizeof(tnode));
+   duel_bzero((char*) n,sizeof(tnode));
+   n->node_kind=NK_OP ;
+   n->op_kind=op_kind ;
+   n->op=opinfo.opcode ;
+   n->src_pos=opinfo.src_pos ;
+   n->kids[0]=k1 ;  n->kids[1]=k2 ;  n->kids[2]=k3 ; n->kids[3]=k4 ;
+   return n ;
+}
+
+
+ /* mknode_const -- make a constant node for the given type. 
+  */
+
+LFUNC tnode* mknode_const(int src_pos,tctype *ctype)
+{
+   tnode *n ;
+   n=(tnode *) duel_malloc(sizeof(tnode));
+   duel_bzero((char*) n,sizeof(tnode));
+   n->node_kind=NK_CONST ;
+   n->src_pos=src_pos ;
+   n->cnst.val_kind=VK_RVALUE ;
+   n->cnst.ctype=ctype ;
+   return n ;
+}
+
+ /* mknode_ctype -- make a node of the given c-type. 
+  */
+
+LFUNC tnode* mknode_ctype(tctype *ctype)
+{
+   tnode *n ;
+   n=(tnode *) duel_malloc(sizeof(tnode));
+   duel_bzero((char*) n,sizeof(tnode));
+   n->node_kind=NK_CTYPE ;
+   n->ctype=ctype ;
+   return n ;
+}
+
+ /* mknode_name -- make a node of the given name/symbol.
+  * input is pointer to the saved name (on heap)
+  */
+
+LFUNC tnode* mknode_name(tnameinfo nameinfo)
+{
+   tnode *n ;
+   n=(tnode *) duel_malloc(sizeof(tnode));
+   duel_bzero((char*) n,sizeof(tnode));
+   n->node_kind=NK_NAME ;
+   n->name=nameinfo.name ;
+   n->src_pos=nameinfo.src_pos ;
+   return n ;
+}
+
+/* In order to parse C types, which are 'reversed' in the parser, a stack
+ * is used to push abstract declarators, e.g. in (*)() we first push a func
+ * indicator '(' and then push a pointer indicator '*'. for arrays we push
+ * a '[' and the array size. 
+ * This stack is popped and a ctype is constructed at the end of the 
+ * abstract type parsing. The following functions implement the stack
+ */
+
+typedef struct stype_desc {  /* stack of type descriptors is made of these */
+        char desc ; 
+        int size ;
+        struct stype_desc *next ;       /* next on stack */
+      } ttype_desc ;
+
+ttype_desc *top = 0 ;
+
+
+LPROC push_type(char desc)     /* put desc on the types stack */
+{
+    ttype_desc *p = (ttype_desc* ) duel_malloc(sizeof(ttype_desc));
+    p->desc=desc ;
+    p->size=0 ;
+    p->next=top ;
+    top=p ;
+}
+
+/* push_type_int -- same as push_type but also set the size parameter, which
+ *                  is given as a constant node (which is expected to be int)
+ */
+
+LPROC push_type_int(char desc,tnode *n)  
+{
+   duel_assert(n->node_kind==NK_CONST);
+   if(n->cnst.ctype != ctype_int || 
+      n->cnst.u.rval_int <=0 ) duel_gen_error("Illegal array size",0);
+   push_type(desc);
+   top->size=n->cnst.u.rval_int ;
+}
+
+LFUNC bool pop_type(char *desc,int *size)  /* pop item from stack. */
+{
+   ttype_desc *p = top ;
+   if(p==0) return FALSE ;
+   *desc=p->desc ;
+   *size=p->size ;
+   top=p->next ;
+   duel_free(p) ;
+   return TRUE ;
+}
+
+
+/* abstract type-modifiers were pushed on a stack. Retrieve
+ * them (reversed) creating type nodes as we go 
+ * input: base type (e.g. 'long'). 
+ * returns: node of the modified type. 
+ * modification is based on the stack of things pushed while parsing.
+ */
+
+LFUNC tnode* mknode_modified_ctype(tctype *base)
+{  
+    int size;
+    char tdesc ;           /* descriptor of abs decl eg '*' */
+    tctype *t=base ;       /* type under construction       */
+    
+    while(pop_type(&tdesc,&size))    /* pop next abs decl    */
+	switch (tdesc) {
+	  case '*':  t=duel_mkctype_ptr(t);         break ;
+	  case '(':  t=duel_mkctype_func(t);        break ;
+	  case '[':  t=duel_mkctype_array(t,size);  break ;
+	}	
+    return mknode_ctype(t) ;
+}
+
+/* entry point for parsing. the given expression is parsed into the given
+ * node as root.
+ */
+
+FUNC tnode* duel_parse(char *s)
+{
+  lexptr=inputstr=s ;
+  top=0 ; 				/* reset the types stack */
+  if(duel_yyparse()) root=NULL ;
+  return root ;
+}
--- gdb/duel/patchlevel.h
+++ gdb/duel/patchlevel.h
@@ -0,0 +1,7 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code                            */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+#define PATCHLEVEL 4
+#define  VERSION "DUEL 1.20"
--- gdb/duel/print.c
+++ gdb/duel/print.c
@@ -0,0 +1,300 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code			           */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* handle value/type printing */
+
+/*
+ * $Log: 10_all_gdb-6.6-duel.patch,v $
+ * Revision 1.1  2007/12/29 21:06:06  vapier
+ * add DUEL support #199987 by Sergei Golubchik
+ *
+ * Revision 1.9  93/03/12  06:01:00  mg
+ * cosmetics: tuint for uint, etc.
+ * display union like structs
+ * suport piped output
+ * note for all pointers if illegal, better handling of string bad pointers
+ * 
+ * Revision 1.8  93/02/27  06:06:50  mg
+ * removed usage of fabs() so -lm is not required in gdb's linking (HP9000)
+ * 
+ * Revision 1.7  93/02/26  05:00:42  mg
+ * fixed display of *p for void *p
+ * 
+ * Revision 1.6  93/02/23  20:57:56  mg
+ * *** empty log message ***
+ * 
+ * Revision 1.5  93/02/23  19:16:00  mg
+ * improved escaped char support
+ * 
+ * Revision 1.4  93/02/03  21:54:49  mg
+ * support "signed char"
+ * 
+ * Revision 1.3  93/01/12  21:53:45  mg
+ * cleanup and set for release
+ * 
+ * Revision 1.2  93/01/07  00:14:34  mg
+ * print union name
+ * 
+ * Revision 1.1  93/01/03  07:31:55  mg
+ * Initial revision
+ * 
+ */
+
+#include "duel.h"
+
+/* print type information (no new lines)
+ * parm 'expand' controls expansion level for structs & unions. normally 1.
+ */
+
+PROC duel_print_type(tctype *t,int expand)
+{
+   int i ;
+   tctype *kid=t->u.kid ;
+   
+   switch(t->type_kind) {
+      case CTK_VOID:      duel_printf("void ")      ; break ;
+      case CTK_CHAR:      duel_printf("char ")      ; break ;
+      case CTK_SCHAR:     duel_printf("schar ")     ; break ;
+      case CTK_UCHAR:     duel_printf("uchar ")     ; break ;
+      case CTK_USHORT:    duel_printf("ushort ")    ; break ;
+      case CTK_SHORT:     duel_printf("short ")     ; break ;
+      case CTK_INT:       duel_printf("int ")       ; break ;
+      case CTK_UINT:      duel_printf("uint ")      ; break ;
+      case CTK_LONG:      duel_printf("long ")      ; break ;
+      case CTK_ULONG:     duel_printf("ulong ")     ; break ;
+      case CTK_LONGLONG:  duel_printf("longong ")   ; break ;
+      case CTK_ULONGLONG: duel_printf("ulonglong ") ; break ;
+      case CTK_FLOAT:     duel_printf("float ")     ; break ;
+      case CTK_DOUBLE:    duel_printf("double ")    ; break ;
+      case CTK_ENUM:      duel_printf("enum %s ",t->name); break ;
+   
+      case CTK_PTR: 
+                  if(ctype_kind_base(kid)) {
+                      duel_print_type(kid,0);
+                      duel_printf("* ");
+                  }
+                  else {
+                      duel_printf("ptr to ");
+                      duel_print_type(kid,expand-1) ;
+                  }
+      break ;
+      case CTK_ARRAY: {
+                  int n=t->size ;
+                  if(kid->size>0) n/=kid->size ;
+
+                  if(ctype_kind_base(kid)) {
+                      duel_print_type(kid,0);
+                      duel_printf("[%d] ",n);
+                  }
+                  else {
+                      duel_printf("array [%d] of ",n);
+                      duel_print_type(kid,expand) ;
+                  }
+               }
+      break ;
+      case CTK_FUNC:  duel_printf("func returning ");
+                      duel_print_type(kid,expand);
+      break ;
+      case CTK_STRUCT: 
+	if(expand <= 0) {
+	    duel_printf("struct %s ",t->name);
+	    break ;
+	}
+	duel_printf("struct %s { ",t->name) ; 
+	 for(i=0 ; i<t->u.f.fields_no ; i++) {
+   	    tctype_field *f= &t->u.f.fields[i] ;
+	    duel_print_type(f->ctype,expand-1); 
+	    duel_printf("%s ",f->name);
+	    if(f->bitlen != 0) duel_printf(":%d ",f->bitlen);
+	    duel_printf("; ");
+	}
+	duel_printf("} ; ");
+      break ;
+      case CTK_UNION:   duel_printf("union %s",t->name)  ; break ;
+      default: duel_assert(0);
+   }
+}
+
+/* display char 'c' in a "neat" way, e.g. c='\n' is displayed as such,
+ * etc. Special case for c==quote (normally ' or "), we add '\\'
+ * return a pointer to a static string which is overriden each call etc
+ */
+char *neat_char(char c,char quote)
+{
+   static char s[8] ;
+   switch(c) {
+     case '\0': strcpy(s,"\\0");  break ;
+     case '\n': strcpy(s,"\\n");  break ;
+     case '\r': strcpy(s,"\\r");  break ;
+     case '\t': strcpy(s,"\\t");  break ;
+     case '\\': strcpy(s,"\\\\"); break ;
+     default:
+      if(!isprint(c) || !isascii(c)) sprintf(s,"\\%3.3o",c & 0377); 
+      else 
+      if(c==quote) sprintf(s,"\\%c",c);
+      else sprintf(s,"%c",c);
+   }
+   return s ;
+}
+
+/* print the given scalar value into string s.
+ * for none-scalar values, print the lval's address.
+ * note: v's value is not modified.
+ */
+
+PROC duel_sprint_scalar_value(char *s,tvalue *v)
+{
+   bool ok ;
+   tvalue rval ;  /* copy of v, but as an rval */
+   rval = *v ;
+   if(v->val_kind==VK_FVALUE) {
+        sprintf(s,"frame(%d)",v->u.fvalue);
+        return ;
+   }
+   if(v->val_kind==VK_LVALUE) {
+        char tmpstr[256],*m="" ; /* tmpstr= temporary for check, m= message */
+	int sz = v->ctype->size ; /* size of object ref. */
+	if(sz<1) sz=1 ;
+	if(sz>256) sz=256 ;
+	/* check for null and bad (try read sz bytes at addr ) references */
+	if(v->u.lvalue==NULL ||
+	   !duel_get_target_bytes(v->u.lvalue,tmpstr,sz)) m=" [ILLEGAL]" ;
+
+        switch(v->ctype->type_kind) {
+          case CTK_VOID:   sprintf(s,"void @%p%s",v->u.lvalue,m); return;
+          case CTK_STRUCT: sprintf(s,"struct @%p%s",v->u.lvalue,m); return;
+          case CTK_UNION:  sprintf(s,"union @%p%s",v->u.lvalue,m); return;
+          case CTK_FUNC:   sprintf(s,"func @%p%s",v->u.lvalue,m)  ; return;
+          case CTK_ARRAY:
+	     if(*m!='\0' || v->ctype->u.kid!=ctype_char) {
+                sprintf(s,"array @%p%s",v->u.lvalue,m); 
+                return;
+             }
+        }
+	/* convert scalar type to rvalue */
+        if(!duel_try_get_rvalue(&rval,"")) {
+           sprintf(s,"ref @%p [ILLEGAL]",v->u.lvalue,m);
+           return ;
+        }
+   }
+   else
+   if(v->val_kind==VK_BVALUE) {
+        if(!duel_try_get_rvalue(&rval,"")) {
+           sprintf(s,"ref @%p [ILLEGAL]",v->u.bvalue.lvalue);
+           return ;
+        }
+   }
+
+   switch(rval.ctype->type_kind) {   			/* handle rvalues */
+      case CTK_VOID:   sprintf(s,"void") ; break ;
+      case CTK_CHAR: sprintf(s,"'%s'",neat_char(rval.u.rval_char,'\''));break;
+      case CTK_SHORT:   sprintf(s,"%d",     rval.u.rval_short)  ; break ;
+      case CTK_INT:     sprintf(s,"%d",     rval.u.rval_int)    ; break ;
+      case CTK_LONG:    sprintf(s,"%ldL",   rval.u.rval_long)   ; break ;
+      case CTK_LONGLONG: sprintf(s,"%lldLL",   rval.u.rval_longlong) ; break ;
+      case CTK_SCHAR:   if(rval.u.rval_schar==0) sprintf(s,"'\\0'");
+		        else sprintf(s,"%d", rval.u.rval_schar)  ; break ;
+      case CTK_UCHAR:   if(rval.u.rval_uchar==0) sprintf(s,"'\\0'");
+		        else sprintf(s,"'\\x%d'", rval.u.rval_uchar)  ; break ;
+      case CTK_USHORT:  if(rval.u.rval_ushort==0) sprintf(s,"0");
+		        else sprintf(s,"0x%x",   rval.u.rval_ushort) ; break ;
+      case CTK_UINT:    if(rval.u.rval_uint==0) sprintf(s,"0");
+		        else sprintf(s,"0x%x",   rval.u.rval_uint)   ; break ;
+      case CTK_ULONG:   if(rval.u.rval_ulong==0L) sprintf(s,"0");
+		        else sprintf(s,"0x%lxUL", rval.u.rval_ulong)  ; break ;
+      case CTK_ULONGLONG: if(rval.u.rval_ulonglong==0L) sprintf(s,"0");
+		        else sprintf(s,"0x%llxULL", rval.u.rval_ulonglong) ; break ;
+      case CTK_FLOAT:   rval.u.rval_double=rval.u.rval_float ;
+      case CTK_DOUBLE:  { double x=rval.u.rval_double ;
+			  if(x >= -1e-6 && x <= 1e-6 || x >= 1e8 || x <= -1e8)
+	                     sprintf(s,"%.4le",x);	/* standard 'e' fmt */
+                          else {	/* fixed point removing trailing '0'*/
+			     int l;
+ 			     sprintf(s,"%.8lf",x);
+			     l=strlen(s)-1;
+			     while(s[l]=='0' && s[l-1]!='.') s[l--]=0 ;
+			 }
+		        }
+      break ;
+      case CTK_PTR: 
+	  if(rval.u.rval_ptr==NULL) sprintf(s,"NULL");
+	  else {
+	      char sval[41];
+	      bool ok=duel_get_target_bytes(rval.u.lvalue,sval,1);
+	      if(ok && rval.ctype->u.kid==ctype_char) {
+		 int i ;
+		 duel_get_target_bytes(rval.u.lvalue,sval,41);
+		 strcpy(s,"\"");
+		 for(i=0 ; i<40 && sval[i]!='\0' ; i++) 
+		    strcat(s,neat_char(sval[i],'"'));
+	         if(sval[i]=='\0') strcat(s,"\"");
+	         else strcat(s,"...\"");
+	     }
+	     else sprintf(s,"@%p%s",rval.u.rval_ptr,ok? "":" [ILLEGAL]");
+	  }
+      break ;
+      case CTK_ENUM:    {
+	  int i, n=rval.ctype->u.e.enumerators_no ;
+	  tctype_enumerator *e=rval.ctype->u.e.enumerators ;
+	  int val=duel_get_int_val(v,"");
+	  for(i=0 ; i<n ; i++)
+	      if(e[i].val == val) { strcpy(s,e[i].name); return ;}
+	  sprintf(s,"%d",val);
+      }
+      break ;
+      default: duel_assert(0);
+   }
+}
+
+/* print the given value, symbolic+val. Handles structures */
+
+PROC duel_print_value(tvalue *v)
+{
+   tctype *t=v->ctype ;
+   int i ;
+   bool topipe=duel_output_pipe_style ;
+   char s[160];
+
+   duel_printf(topipe? "$$$SYM: %s\n":"%s",v->symb_val);
+
+   if(duel_debug && !topipe) {
+       duel_printf("`` %s '' ",v->symb_val);
+       duel_printf("{ ");
+       duel_print_type(v->ctype,2);
+       duel_printf("} ");
+       if(v->val_kind==VK_LVALUE) {
+	  duel_printf("lval @%p",v->u.lvalue);
+       }
+       else
+       if(v->val_kind==VK_BVALUE) {
+	  duel_printf("bval @%p [%d,%d]",v->u.bvalue.lvalue,v->u.bvalue.bitpos,
+                                    v->u.bvalue.bitlen);
+       }
+       duel_printf("\n");
+   }
+
+   duel_sprint_scalar_value(s,v);
+   if(v->val_kind==VK_LVALUE && strstr(s,"ILLEGAL")==NULL) {
+      switch(t->type_kind) {
+        case CTK_UNION: 
+        case CTK_STRUCT:
+	     duel_printf(topipe? "$$$VAL: { " : " = { ");
+	     for(i=0 ; i<t->u.f.fields_no ; i++) {
+               tvalue u ;
+               char *name=t->u.f.fields[i].name ;
+               duel_get_dot_name(v,name,&u);
+               duel_sprint_scalar_value(s,&u);
+               duel_printf("%s = %s",name,s) ;
+	       if(i < t->u.f.fields_no-1) duel_printf(", ");
+             } 
+	     duel_printf(" }\n");
+        return ;
+        case CTK_ARRAY: ;  /* not handled except for char[] as scalar*/
+      }
+   }
+
+   if(topipe) duel_printf("$$$VAL: %s",s);
+   else
+   if(strcmp(v->symb_val,s)!=0) duel_printf(" = %s",s);
+   duel_printf("\n");
+}
+
--- gdb/duel/proto.h
+++ gdb/duel/proto.h
@@ -0,0 +1,101 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code			           */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* prototypes for all of duel's global functions */
+
+FUNC tctype* duel_mkctype_ptr(tctype *t);
+FUNC tctype* duel_mkctype_func(tctype *t);
+FUNC tctype* duel_mkctype_array(tctype *t,int size);
+FUNC tctype* duel_mkctype_struct(char *name,size_t size,int fields_no,
+				 bool is_union);
+PROC duel_mkctype_struct_field(tctype *t,int field_no,char *name,
+			       int bitpos,int bitlen, tctype *fctype);
+FUNC tctype* duel_mkctype_enum(char *name,tctype_kind real_type_kind,
+			       size_t size,int enumerators_no);
+PROC duel_mkctype_enumerator(tctype *t,int enumerator_no,char *name,int val);
+
+PROC duel_init_basic_ctypes(void);
+
+PROC duel_print_value(tvalue *v);
+PROC duel_print_type(tctype *t,int expand);
+PROC duel_sprint_scalar_value(char *s,tvalue *v);
+
+
+PROC duel_fatal(char *msg);
+PROC duel_abort(void);
+PROC duel_cleanup(void *);
+
+FUNC tnode* duel_parse(char *s);
+
+
+PROC duel_reset_eval(void);
+FUNC bool duel_eval(tnode *n,tvalue *v);
+FUNC bool duel_get_dot_name(tvalue *v,char *name,tvalue *ret);
+
+FUNC tnode* duel_set_eval_loc(tnode *n);
+FUNC char* duel_set_input_string(char *s);
+PROC duel_op_error(char *mesg,char *op,tvalue *v1,tvalue *v2);
+PROC duel_gen_error(char *mesg,char *arg1);
+
+PROC duel_parse_and_eval(char *s);
+
+FUNC bool duel_try_get_rvalue(tvalue *v,char *op);
+PROC duel_standardize_func_parm(tvalue *p);
+FUNC bool duel_do_op_to(tvalue *v1,tvalue *v2,int n,tvalue *r);
+PROC duel_do_cast(tctype *tout,tvalue *v);
+FUNC bool duel_mk_logical(tvalue *v,char *op);
+PROC duel_set_symb_val(tvalue *r,char *format,tvalue *v1,tvalue *v2);
+PROC duel_get_struct_val(tvalue *v,char *op);
+PROC duel_get_struct_ptr_val(tvalue *v,char *op);
+FUNC int duel_get_int_val(tvalue *v,char *op);
+FUNC int duel_get_posint_val(tvalue *v,char *op);
+PROC duel_apply_unary_op(topcode op,tvalue *v);
+PROC duel_apply_post_unary_op(topcode op,tvalue *v);
+FUNC bool duel_apply_bin_op(topcode op,tvalue *v1,tvalue *v2,tvalue *r);
+PROC duel_find_func_frame(tvalue *v,char *op);
+
+/* output management */
+
+PROC duel_printf(char *fmt, ...);
+PROC duel_flush(void);
+PROC duel_redirectable_output_start(char *);
+PROC duel_redirectable_output_end(void);
+PROC duel_redirectable_output_abort(void);
+PROC duel_redirectable_output_init(void);
+
+/* debugger dependent functions */
+
+FUNC void* duel_malloc(size_t size);
+PROC duel_free(void *);
+
+FUNC bool duel_get_target_bytes(ttarget_ptr from,void *to,size_t n);
+FUNC bool duel_put_target_bytes(ttarget_ptr to,void *from,size_t n);
+
+FUNC bool duel_get_target_bitfield(ttarget_ptr struct_at,int bitpos,
+				    int bitlen,void *to,tctype_kind tkind);
+FUNC bool duel_get_target_variable(char *name, int frame_no, tvalue *v);
+FUNC tctype* duel_get_target_typedef(char *name);
+FUNC tctype* duel_get_target_struct_tag(char *name);
+FUNC tctype* duel_get_target_union_tag(char *name);
+FUNC tctype* duel_get_target_enum_tag(char *name);
+FUNC ttarget_ptr duel_alloc_target_space(size_t n);
+
+FUNC int duel_get_frames_number(void);
+FUNC ttarget_ptr duel_get_function_for_frame(int frame_no);
+PROC duel_target_func_call(tvalue *func, tvalue *parms[],
+			    int parms_no,tvalue *ret);
+
+/* prototypes for misc functions */
+
+FUNC char* strncpyz(char *to,char *from,size_t len);
+
+PROC duel_free_val_list(tval_list *l);
+PROC duel_free_nodes(tnode *);
+
+FUNC tvalue* duel_find_alias(char *name);
+PROC duel_set_alias(char *name,tvalue *v);
+PROC duel_clear_aliases(void);
+PROC duel_show_aliases(void);
+
--- gdb/duel/tsuite.c
+++ gdb/duel/tsuite.c
@@ -0,0 +1,64 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code                            */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* this is a test program to be used with tsuite.gdb */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+int gint ;
+typedef unsigned int uint ;
+
+struct { int a,b ; char *name ; } emp[100] ;
+enum { MIKI, DAVE, ELA } us ;
+struct snode { int code ; struct snode *left,*right ; } ;
+typedef struct snode tnode ;
+
+/* amazing, but DEC compiled strcmp such that gdb thinks it returns void */
+int mystrcmp(s,t) char *s; char *t; { return strcmp(s,t); }
+
+void main() 
+{ 
+     char *s="main string" ; 
+     FILE *out=stdout ;	/* stdout is not a variable on some machines */
+			/* will use fflush(out) from debugger */
+     int i ;
+     tnode *root,*p,**q ;
+
+      for(i=0 ; i<100 ; i++) {
+	emp[i].a=i ; emp[i].b=i*i ;
+        emp[i].name=(char*) malloc(10);
+	sprintf(emp[i].name,"emp%3.3d",i);
+      }
+      emp[53].a=76 ;	/* bug */
+      emp[36].b-- ;	/* bug */
+      emp[74].name[3]='5' ;	/* another bug */
+
+     root=(tnode*) malloc(sizeof(tnode));
+     root->left=root->right=0 ;
+     root->code=5000 ;
+     for(i=1 ; i<10000 ; i++) {	/* insert elements into tree */
+	 int code=((i*997*1013)>>10)%11000 ; /* "fixed" "random" generaor */
+	 if(code<0) code= -code ;	
+	 p=root ;
+	 while(p) {
+	     if(p->code==code) break ;
+	     if(p->code<code) q= &p->right, p=p->right ;
+	     else q= &p->left, p=p->left ;
+	 }
+	 if(p==0) {
+	     p=(tnode*) malloc(sizeof(tnode));
+	     p->code=code ;
+	     if(i>8680) p->code+=(i<9210)? 1:-1 ;	/* bug */
+	     p->left=p->right=0 ;
+	     *q=p ;
+	 }
+     }
+
+    printf("trivial tsuite program\n");
+    printf("trivial tsuite program\n");
+}
+
--- gdb/duel/tsuite.gdb
+++ gdb/duel/tsuite.gdb
@@ -0,0 +1,126 @@
+set prompt
+##   DUEL - A Very High Level Debugging Langauge.
+##   Public domain code
+##   Written by Michael Golan mg@××××××××××××.edu
+##$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $
+##
+## test suite for duel, can be used with duelself or gdb
+## 
+file tsuite
+b 60
+b 61
+r
+## check constants 
+dl (1..5)*(2,(double) 2/3)
+## declare array x, set it, search it
+dl int x[100] ; 
+dl x[0..99]= -1 ;
+dl x[i:=20..40]=2+i*i ;
+dl x[20..23,38..40]
+dl x[..100] >=? 33*33 <=? 35*35 
+dl x[..100]=> ((_>=33*33) & (_<= 35*35)) ==? 1
+dl (*(x+(7..9)))++
+dl y:= &x[7] ;
+dl y[0..2]
+dl x+7 == y
+dl (x[..99]>?0)@(_>100)
+dl printf("%d\n",1..10);
+dl printf("x is: "); printf("%d, ",x[0..99]>? 0); printf("\n");fflush(out);
+dl int j ; for(j=0 ; j<100 ; j++) if(x[j]>37*37) printf("x[%d]=%d\n",j,x[j]);fflush(out);
+dl printf("%d\n",1..5);
+## check void type
+dl void *p
+dl p = &p 
+dl p,*p
+## errors
+dl 1e+++3
+dl i=4 ;
+dl x=6 ;
+dl x++ ;
+dl --i ;
+## cleanup
+dl alias
+dl clear
+## access some variables
+dl s
+dl s[4..8]
+dl s[6..]@0
+dl l:=#/s[0..]@0
+dl s[l-2..l]
+dl gint 
+dl gint++
+dl gint++
+dl --gint 
+dl gint 
+dl main.s 
+dl ++main.s
+dl main ==? main
+dl main == main
+dl frames_no
+dl frame(0).s
+dl frame(0).(gint+0)
+dl sizeof(gint)
+dl sizeof(T uint)
+dl sizeof(T uint*)
+dl sizeof(T emp)
+dl sizeof(emp)
+dl sizeof(emp[0])
+dl (uint)-1
+dl (uint*)(gint=gint-9)
+dl *(uint*)&gint
+dl T uint myuint ; myuint = -1 
+## some errors 
+dl frame(0).gint
+dl frame(0).(gint)
+dl frame(0).ha
+dl sizeof(uint)
+dl sizeof gint
+dl main == printf
+dl main+1
+dl main > printf
+dl printf+3
+dl T int x
+dl uint y
+dl T uint z = 5
+## finally, do some serious checks using the bugs in the programs
+dl emp[4]
+dl emp[k:=..100].a !=? k
+dl (emp[k:=..100].a !=? k)[[0]] ; emp[{k}]
+dl emp[k:=..100].if(a!=k) _
+dl emp[k:=..100].b !=? k*k 
+dl emp[k:=..100].if(b!=k*k) _,{k}*{k}
+dl emp[k:=..100]=>if(_.b!=k*k) _,{k}*{k}
+dl char s[80];
+dl ..100 => (sprintf(s,"emp%3.3d",_) ; emp[_].name[0..]@0#j !=? s[j])
+dl ..100 => (sprintf(s,"emp%3.3d",_) ; mystrcmp(emp[_].name,s)!=?0)
+dl ..100 => (sprintf(s,"emp%3.3d",_) ; emp[_].name=>if(mystrcmp(_,s))_)
+## now, lets try some pointers and --> stuff!
+dl root-->left[[..8]]->code
+dl root-->(left,right)[[..30]]->code
+dl #/root-->(left,right)
+dl root->(left,right) => #/_-->(left,right)
+dl root->(left->left,left->right,right->left,right->right)=> #/_-->(left,right)
+## this cause very long symbolic vals, core dump/bad results before duel 1.10.3
+dl #/(root+0000000000000000000000000000000000000000000000000000)-->(left,right)
+## compute min, max, check for dups, no-show
+dl root-->left[[#/root-->left-1]]->code
+dl root-->right[[#/root-->right-1]]->code
+dl int codes[11000] ; codes[..11000]=0 ; codes[root-->(left,right)->code]++ ; 
+dl codes[..11000] >? 1 
+dl (codes[..11000] ==? 0 )[[..10]]
+dl (..11000 => if(!codes[_]) _)[[..10]]
+## check consistency
+dl root-->(left,right)->((left!=?0)->code >=? code, (right!=?0)->code <=? code)
+dl root-->(left,right)->((left!=?0)->code>=code, (right!=?0)->code<=code)==?1
+dl (1000..=>if(&&/( 2,3.._-1 =>__%_)) _)[[..10]]
+## enums
+dl ELA
+dl (T us) 1
+dl us=1 ; us
+dl MIKI..ELA
+## more errors
+dl emp[0]=us
+dl emp=us
+dl us=emp
+## the end
+
--- gdb/duel/tsuite.gdb.out
+++ gdb/duel/tsuite.gdb.out
@@ -0,0 +1,293 @@
+GDB is free software and you are welcome to distribute copies of it
+ under certain conditions; type "show copying" to see the conditions.
+There is absolutely no warranty for GDB; type "show warranty" for details.
+GDB 4.8, Copyright 1993 Free Software Foundation, Inc.
+(gdb)         Reading symbols from tsuite...done.
+ Breakpoint 1 at 0x400518: file tsuite.c, line 60.
+ Note: breakpoint 1 also set at pc 0x400518.
+Breakpoint 2 at 0x400518: file tsuite.c, line 61.
+ Starting program: /tmp_mnt/n/fs/grad2/mg/duel/tsuite/tsuite 
+
+Breakpoint 1, main () at tsuite.c:61
+61	    printf("trivial tsuite program\n");
+  DUEL 1.10.4, public domain debugging language. "dl" for help
+1*2 = 2
+1*(2/3) = 0.66666667
+2*2 = 4
+2*(2/3) = 1.33333333
+3*2 = 6
+3*(2/3) = 2.0
+4*2 = 8
+4*(2/3) = 2.66666667
+5*2 = 10
+5*(2/3) = 3.33333333
+     x[20] = 402
+x[21] = 443
+x[22] = 486
+x[23] = 531
+x[38] = 1446
+x[39] = 1523
+x[40] = 1602
+ x[33] = 1091
+x[34] = 1158
+ (x[33]>=33*33)&(x[33]<=35*35) = 1
+(x[34]>=33*33)&(x[34]<=35*35) = 1
+ (*(x+7))++ = -1
+(*(x+8))++ = -1
+(*(x+9))++ = -1
+  y[0] = 0
+y[1] = 0
+y[2] = 0
+ x+7==y = 1
+   1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+x is: 402, 443, 486, 531, 578, 627, 678, 731, 786, 843, 902, 963, 1026, 1091, 1158, 1227, 1298, 1371, 1446, 1523, 1602, 
+ x[37]=1371
+x[38]=1446
+x[39]=1523
+x[40]=1602
+    &p = @10020020
+ p = @10020020
+*p = void @10020020
+  1e+++3
+^ Invalid float constant.
+ Error:   i=4 ;
+         -^-- operand x is not an lvalue for operator 'x=y'
+operand ``i'' 	-- type: int 
+		-- value: 40
+ Error:   x=6 ;
+         -^-- bad operand x type for operator 'x=y'
+operand ``x'' 	-- type: int [100] 
+		-- value: array @1001f000
+ Error:   x++ ;
+         -^-- operand x of '++' is not integral
+operand ``x'' 	-- type: int [100] 
+		-- value: array @1001f000
+ Error:   --i ;
+         ^-- operand of '--' must be an lvalue
+operand ``i'' 	-- type: int 
+		-- value: 40
+  Aliases table:
+p:  p = @10020020
+j:  j = 100
+y:  &x[7] = @1001f01c
+i:  40
+x:  x = array @1001f000
+ Aliases table cleared
+  s = "main string"
+ s[4] = ' '
+s[5] = 's'
+s[6] = 't'
+s[7] = 'r'
+s[8] = 'i'
+ s[6] = 't'
+s[7] = 'r'
+s[8] = 'i'
+s[9] = 'n'
+s[10] = 'g'
+ #/(s[0] ...) = 11
+ s[9] = 'n'
+s[10] = 'g'
+s[11] = '\0'
+ gint = 0
+ gint++ = 0
+ gint++ = 1
+ gint = 1
+ gint = 1
+ main.s = "main string"
+ main.s = "ain string"
+ main = func @004001f0
+ main==main = 1
+ frames_no = 1
+ frame(0).s = "ain string"
+ frame(0).(gint+0) = 1
+ sizeof(gint) = 0x4
+ sizeof(unsigned int) = 0x4
+ sizeof(T) = 0x4
+ sizeof(T) = 0x4b0
+ sizeof(emp) = 0x4b0
+ sizeof(emp[0]) = 0xc
+ -1 = 0xffffffff
+ (gint-9) = @fffffff8 [ILLEGAL]
+ *&gint = 0xfffffff8
+ -1 = 0xffffffff
+  Error:   frame(0).gint
+         --------^-- field not found in operator '.'
+operand ``frame(0)'' 	-- type: int 
+		-- value: frame(0)
+ frame(0).(gint)
+---------------^ syntax error
+ Error:   frame(0).ha
+         --------^-- field not found in operator '.'
+operand ``frame(0)'' 	-- type: int 
+		-- value: frame(0)
+ Error:   sizeof(uint)
+         -------^-- variable 'uint' not found
+ sizeof gint
+-----------^ syntax error
+ Error:   main == printf
+         -----^-- incompatible types for op ==
+operand1 ``main'' 	-- type: ptr to func returning void 
+		-- value: @004001f0
+operand2 ``printf'' 	-- type: ptr to func returning int 
+		-- value: @00400ca0
+ Error:   main+1
+         ----^-- unknown pointer object size for '+' op
+operand ``main'' 	-- type: ptr to func returning void 
+		-- value: @004001f0
+ Error:   main > printf
+         -----^-- incompatible types for op >
+operand1 ``main'' 	-- type: ptr to func returning void 
+		-- value: @004001f0
+operand2 ``printf'' 	-- type: ptr to func returning int 
+		-- value: @00400ca0
+ Error:   printf+3
+         ------^-- unknown pointer object size for '+' op
+operand ``printf'' 	-- type: ptr to func returning int 
+		-- value: @00400ca0
+ T int x
+-----^ syntax error
+ uint y
+------^ syntax error
+ T uint z = 5
+----------^ syntax error
+  emp[4] = { a = 4, b = 16, name = "emp004" }
+ emp[53].a = 76
+ emp[53] = { a = 76, b = 2809, name = "emp053" }
+ emp[53] = { a = 76, b = 2809, name = "emp053" }
+ emp[36].b = 1295
+ emp[36] = { a = 36, b = 1295, name = "emp036" }
+emp[36].36*36 = 1296
+ emp[36] = { a = 36, b = 1295, name = "emp036" }
+36*36 = 1296
+  (emp[74].name[3]) = '5'
+ (mystrcmp(emp[74].name,s)) = 5
+ (emp[74].name) = "emp574"
+  root->code = 5000
+root->left->code = 986
+root-->left[[2]]->code = 835
+root-->left[[3]]->code = 684
+root-->left[[4]]->code = 533
+root-->left[[5]]->code = 383
+root-->left[[6]]->code = 232
+root-->left[[7]]->code = 81
+ root->code = 5000
+root->left->code = 986
+root-->left[[2]]->code = 835
+root-->left[[3]]->code = 684
+root-->left[[4]]->code = 533
+root-->left[[5]]->code = 383
+root-->left[[6]]->code = 232
+root-->left[[7]]->code = 81
+root-->left[[8]]->code = 12
+root-->left[[9]]->code = 2
+root-->left[[9]]->right->code = 5
+root-->left[[9]]->right->left->code = 4
+root-->left[[9]]-->right[[2]]->code = 11
+root-->left[[9]]-->right[[2]]->left->code = 8
+root-->left[[9]]-->right[[2]]-->left[[2]]->code = 7
+root-->left[[9]]-->right[[2]]->left->right->code = 10
+root-->left[[8]]->right->code = 24
+root-->left[[8]]->right->left->code = 15
+root-->left[[8]]->right-->left[[2]]->code = 14
+root-->left[[8]]->right->left->right->code = 17
+root-->left[[8]]->right->left->right->left->code = 16
+root-->left[[8]]->right->left-->right[[2]]->code = 23
+root-->left[[8]]->right->left-->right[[2]]->left->code = 20
+root-->left[[8]]->right->left-->right[[2]]-->left[[2]]->code = 19
+root-->left[[8]]->right->left-->right[[2]]->left->right->code = 22
+root-->left[[8]]->right->left-->right[[2]]->left->right->left->code = 21
+root-->left[[8]]-->right[[2]]->code = 36
+root-->left[[8]]-->right[[2]]->left->code = 27
+root-->left[[8]]-->right[[2]]->left->right->code = 35
+root-->left[[8]]-->right[[2]]->left->right->left->code = 32
+ #/(root ...) = 7144
+ #/(root->left ...) = 3249
+#/(root->right ...) = 3894
+ #/(root->(left->left) ...) = 641
+#/(root->(left->right) ...) = 2607
+#/(root->(right->left) ...) = 595
+#/(root->(right->right) ...) = 3298
+  #/((root+0000000000000000000000000000000000000000000000000000) ...) = 7144
+  root-->left[[9]]->code = 2
+ root-->right[[14]]->code = 10999
+  codes[2122] = 2
+codes[2308] = 2
+codes[5081] = 2
+codes[5267] = 2
+codes[8040] = 2
+codes[9026] = 2
+codes[9363] = 2
+ (codes[0]) = 0
+(codes[1]) = 0
+(codes[3]) = 0
+(codes[6]) = 0
+(codes[9]) = 0
+(codes[13]) = 0
+(codes[18]) = 0
+(codes[25]) = 0
+(codes[26]) = 0
+(codes[29]) = 0
+ 0
+1
+3
+6
+9
+13
+18
+25
+26
+29
+  root->left-->right[[2]]-->left[[6]]->right->left-->right[[5]]->left->right->left->(right->code) = 2122
+root->left-->right[[2]]-->left[[5]]-->right[[3]]->left->right->left->right->(left->code) = 2308
+root->right-->left[[6]]->right->left-->right[[5]]->left->right->left->(right->code) = 5081
+root->right-->left[[5]]-->right[[3]]->left->right->left->right->(left->code) = 5267
+root-->right[[4]]-->left[[6]]->right->left-->right[[5]]->left->right->left->(right->code) = 8040
+root-->right[[5]]-->left[[6]]->right->left-->right[[5]]->left->right->left->(right->code) = 9026
+root-->right[[5]]-->left[[4]]-->right[[3]]->left->right->left->right->(left->code) = 9363
+ root->left-->right[[2]]-->left[[6]]->right->left-->right[[5]]->left->right->left->(right->code<=code) = 1
+root->left-->right[[2]]-->left[[5]]-->right[[3]]->left->right->left->right->(left->code>=code) = 1
+root->right-->left[[6]]->right->left-->right[[5]]->left->right->left->(right->code<=code) = 1
+root->right-->left[[5]]-->right[[3]]->left->right->left->right->(left->code>=code) = 1
+root-->right[[4]]-->left[[6]]->right->left-->right[[5]]->left->right->left->(right->code<=code) = 1
+root-->right[[5]]-->left[[6]]->right->left-->right[[5]]->left->right->left->(right->code<=code) = 1
+root-->right[[5]]-->left[[4]]-->right[[3]]->left->right->left->right->(left->code>=code) = 1
+ 1009
+1013
+1019
+1021
+1031
+1033
+1039
+1049
+1051
+1061
+  ELA
+ 1 = DAVE
+ us = DAVE
+ 0
+1
+2
+  Error:   emp[0]=us
+         ------^-- incompatible types for op x=y
+operand1 ``emp[0]'' 	-- type: struct .F13 { int a ; int b ; char * name ; } ; 
+		-- value: struct @10001510
+operand2 ``us'' 	-- type: enum .F14 
+		-- value: DAVE
+ Error:   emp=us
+         ---^-- bad operand x type for operator 'x=y'
+operand ``emp'' 	-- type: array [100] of struct .F13 { int a ; int b ; char * name ; } ; 
+		-- value: array @10001510
+ Error:   us=emp
+         --^-- operand x of 'y=x' is not numeric
+operand ``emp'' 	-- type: array [100] of struct .F13 { int a ; int b ; char * name ; } ; 
+		-- value: array @10001510
+  
--- gdb/duel/tsuite.self
+++ gdb/duel/tsuite.self
@@ -0,0 +1,111 @@
+##   DUEL - A Very High Level Debugging Langauge.
+##   Public domain code
+##   Written by Michael Golan mg@××××××××××××.edu
+## $Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $
+
+##
+## test suite for duel, can be used with duelself or gdb
+## 
+
+## check constants 
+(1..5)*(2,(double) 2/3)
+
+## declare array x, set it, search it
+
+int x[100] ; 
+x[0..99]= -1 ;
+x[i:=20..40]=2+i*i ;
+x[20..23,38..40]
+x[..100] >=? 33*33 <=? 35*35 
+x[..100]=> ((_>=33*33) & (_<= 35*35)) ==? 1
+x
+x+5
+*(x+7..9)++
+*(x+(7..9))++
+(*(x+(7..9)))++
+y:= &x[7] ;
+y[0..2]
+x+7 == y
+(x[..99]>?0)@(_>500)
+
+printf("x is: "); printf("%d, ",x[0..99]>? 0); printf("\n");
+int j ; for(j=0 ; j<100 ; j++) if(x[j]>37*37) printf("x[%d]=%d\n",j,x[j]);
+
+printf("%d, ",1..5); printf("\n");
+
+## check void type
+void *p
+p = &p 
+p,*p
+
+## errors
+
+1e++4
+& &x
+i=4 ;
+x=6 ;
+x++ ;
+--i ;
+
+## cleanup
+
+alias
+clear
+
+## access some variables
+s
+s[3..7]
+s[5..]@0
+l:=#/s[0..]@0
+s[l-2..l]
+
+gint 
+gint++
+gint++
+--gint 
+gint 
+main.s 
+main.s++
+main.s++
+
+main
+printf
+main ==? main
+main == main
+
+frames_no
+frame(0).s
+
+## gint is a global, not local fro main in frame 0
+frame(0).gint
+## but when we eval (expr) under frame 0 scope, we find it ok.
+frame(0).(gint)
+
+T uint myuint ; myuint = -1 
+
+sizeof(int)
+sizeof(long)
+sizeof(int *)
+sizeof(signed char*)
+sizeof()
+sizeof(gint)
+sizeof gint 
+sizeof gint+1
+## some errors 
+
+main == main
+main == printf
+
+main+1
+malloc[4]
+printf+3
+
+T int x
+int x
+uint y
+T uint y = 5
+T uint y 
+
+## the end
+
+
--- gdb/duel/tsuite.self.out
+++ gdb/duel/tsuite.self.out
@@ -0,0 +1,263 @@
+dl> ##   DUEL - A Very High Level Debugging Langauge.
+dl> ##   Public domain code
+dl> ##   Written by Michael Golan mg@××××××××××××.edu
+dl> 
+dl> ##
+dl> ## test suite for duel, can be used with duelself or gdb
+dl> ## 
+dl> 
+dl> ## check constants 
+dl> (1..5)*(2,(double) 2/3)
+DUEL 1.10.4, public domain debugging language. "dl" for help
+1*2 = 2
+1*(2/3) = 0.66666667
+2*2 = 4
+2*(2/3) = 1.33333333
+3*2 = 6
+3*(2/3) = 2.0
+4*2 = 8
+4*(2/3) = 2.66666667
+5*2 = 10
+5*(2/3) = 3.33333333
+dl> 
+dl> ## declare array x, set it, search it
+dl> 
+dl> int x[100] ; 
+dl> x[0..99]= -1 ;
+dl> x[i:=20..40]=2+i*i ;
+dl> x[20..23,38..40]
+x[20] = 402
+x[21] = 443
+x[22] = 486
+x[23] = 531
+x[38] = 1446
+x[39] = 1523
+x[40] = 1602
+dl> x[..100] >=? 33*33 <=? 35*35 
+x[33] = 1091
+x[34] = 1158
+dl> x[..100]=> ((_>=33*33) & (_<= 35*35)) ==? 1
+(x[33]>=33*33)&(x[33]<=35*35) = 1
+(x[34]>=33*33)&(x[34]<=35*35) = 1
+dl> x
+x = array @10014000
+dl> x+5
+x+5 = @10014014
+dl> *(x+7..9)++
+Error:   *(x+7..9)++
+         -----^-- operand x of 'x..y' is not integral
+operand ``x+7'' 	-- type: int * 
+		-- value: @1001401c
+dl> *(x+(7..9))++
+Error:   *(x+(7..9))++
+         -----------^-- operand of '++' must be an lvalue
+operand ``(x+7)'' 	-- type: int * 
+		-- value: @1001401c
+dl> (*(x+(7..9)))++
+(*(x+7))++ = -1
+(*(x+8))++ = -1
+(*(x+9))++ = -1
+dl> y:= &x[7] ;
+dl> y[0..2]
+y[0] = 0
+y[1] = 0
+y[2] = 0
+dl> x+7 == y
+x+7==y = 1
+dl> (x[..99]>?0)@(_>500)
+(x[20]) = 402
+(x[21]) = 443
+(x[22]) = 486
+dl> 
+dl> printf("x is: "); printf("%d, ",x[0..99]>? 0); printf("\n");
+x is: 402, 443, 486, 531, 578, 627, 678, 731, 786, 843, 902, 963, 1026, 1091, 1158, 1227, 1298, 1371, 1446, 1523, 1602, 
+dl> int j ; for(j=0 ; j<100 ; j++) if(x[j]>37*37) printf("x[%d]=%d\n",j,x[j]);
+x[37]=1371
+x[38]=1446
+x[39]=1523
+x[40]=1602
+dl> 
+dl> printf("%d, ",1..5); printf("\n");
+1, 2, 3, 4, 5, 
+dl> 
+dl> ## check void type
+dl> void *p
+dl> p = &p 
+&p = @10012138
+dl> p,*p
+p = @10012138
+*p = void @10012138
+dl> 
+dl> ## errors
+dl> 
+dl> 1e++4
+1e++4
+^ Invalid float constant.
+dl> & &x
+Error:   & &x
+         ^-- operand x of '&x' is not a lvalue
+operand ``&x'' 	-- type: ptr to int [100] 
+		-- value: @10014000
+dl> i=4 ;
+Error:   i=4 ;
+         -^-- operand x is not an lvalue for operator 'x=y'
+operand ``i'' 	-- type: int 
+		-- value: 40
+dl> x=6 ;
+Error:   x=6 ;
+         -^-- bad operand x type for operator 'x=y'
+operand ``x'' 	-- type: int [100] 
+		-- value: array @10014000
+dl> x++ ;
+Error:   x++ ;
+         -^-- operand x of '++' is not integral
+operand ``x'' 	-- type: int [100] 
+		-- value: array @10014000
+dl> --i ;
+Error:   --i ;
+         ^-- operand of '--' must be an lvalue
+operand ``i'' 	-- type: int 
+		-- value: 40
+dl> 
+dl> ## cleanup
+dl> 
+dl> alias
+Aliases table:
+p:  p = @10012138
+j:  j = 100
+y:  &x[7] = @1001401c
+i:  40
+x:  x = array @10014000
+dl> clear
+Aliases table cleared
+dl> 
+dl> ## access some variables
+dl> s
+s = "main string"
+dl> s[3..7]
+s[3] = 'n'
+s[4] = ' '
+s[5] = 's'
+s[6] = 't'
+s[7] = 'r'
+dl> s[5..]@0
+s[5] = 's'
+s[6] = 't'
+s[7] = 'r'
+s[8] = 'i'
+s[9] = 'n'
+s[10] = 'g'
+dl> l:=#/s[0..]@0
+#/(s[0] ...) = 11
+dl> s[l-2..l]
+s[9] = 'n'
+s[10] = 'g'
+s[11] = '\0'
+dl> 
+dl> gint 
+gint = 0
+dl> gint++
+gint++ = 0
+dl> gint++
+gint++ = 1
+dl> --gint 
+gint = 1
+dl> gint 
+gint = 1
+dl> main.s 
+main.s = "main string"
+dl> main.s++
+main.s++ = "main string"
+dl> main.s++
+main.s++ = "ain string"
+dl> 
+dl> main
+main = func @00400918
+dl> printf
+printf = func @004112b0
+dl> main ==? main
+main = func @00400918
+dl> main == main
+main==main = 1
+dl> 
+dl> frames_no
+frames_no = 1
+dl> frame(0).s
+frame(0).s = "in string"
+dl> 
+dl> ## gint is a global, not local fro main in frame 0
+dl> frame(0).gint
+Error:   frame(0).gint
+         --------^-- field not found in operator '.'
+operand ``frame(0)'' 	-- type: int 
+		-- value: frame(0)
+dl> ## but when we eval (expr) under frame 0 scope, we find it ok.
+dl> frame(0).(gint)
+frame(0).(gint)
+---------------^ syntax error
+dl> 
+dl> T uint myuint ; myuint = -1 
+-1 = 0xffffffff
+dl> 
+dl> sizeof(int)
+sizeof(int) = 0x4
+dl> sizeof(long)
+sizeof(long) = 0x4
+dl> sizeof(int *)
+sizeof(T) = 0x4
+dl> sizeof(signed char*)
+sizeof(T) = 0x4
+dl> sizeof()
+sizeof()
+--------^ syntax error
+dl> sizeof(gint)
+sizeof(gint) = 0x4
+dl> sizeof gint 
+sizeof gint 
+-----------^ syntax error
+dl> sizeof gint+1
+sizeof gint+1
+-----------^ syntax error
+dl> ## some errors 
+dl> 
+dl> main == main
+main==main = 1
+dl> main == printf
+Error:   main == printf
+         -----^-- incompatible types for op ==
+operand1 ``main'' 	-- type: ptr to func returning void 
+		-- value: @00400918
+operand2 ``printf'' 	-- type: ptr to func returning int 
+		-- value: @004112b0
+dl> 
+dl> main+1
+Error:   main+1
+         ----^-- unknown pointer object size for '+' op
+operand ``main'' 	-- type: ptr to func returning void 
+		-- value: @00400918
+dl> malloc[4]
+Error:   malloc[4]
+         ------^-- unknown pointer object size for '+' op
+operand ``malloc'' 	-- type: ptr to func returning void * 
+		-- value: @00411310
+dl> printf+3
+Error:   printf+3
+         ------^-- unknown pointer object size for '+' op
+operand ``printf'' 	-- type: ptr to func returning int 
+		-- value: @004112b0
+dl> 
+dl> T int x
+T int x
+-----^ syntax error
+dl> int x
+dl> uint y
+uint y
+------^ syntax error
+dl> T uint y = 5
+T uint y = 5
+----------^ syntax error
+dl> T uint y 
+dl> 
+dl> ## the end
+dl> 
+dl> 
--- gdb/duel/types.c
+++ gdb/duel/types.c
@@ -0,0 +1,202 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code			           */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* this module contains the duel type system management
+ */
+
+/*
+ * $Log: 10_all_gdb-6.6-duel.patch,v $
+ * Revision 1.1  2007/12/29 21:06:06  vapier
+ * add DUEL support #199987 by Sergei Golubchik
+ *
+ * Revision 1.8  93/03/12  06:01:50  mg
+ * use tuint for uint etc
+ * 
+ * Revision 1.7  93/02/03  21:55:26  mg
+ * support "signed char"
+ * 
+ * Revision 1.6  93/01/12  21:54:25  mg
+ * cleanup and set for release
+ * 
+ * Revision 1.5  93/01/03  07:31:24  mg
+ * *** empty log message ***
+ * 
+ * Revision 1.4  92/10/19  15:09:28  mg
+ * support zero fields/enumerators because gdb have them sometimes.
+ * 
+ * Revision 1.3  92/10/14  02:07:00  mg
+ * misc
+ * 
+ * Revision 1.2  92/09/16  11:11:43  mg
+ * added builtin charptr type
+ * 
+ */
+
+#include "duel.h"
+
+FUNC tctype* duel_mkctype_ptr(tctype *t)
+{
+  tctype *n ;
+  n=(tctype *) duel_malloc(sizeof(tctype));
+  duel_bzero((char*) n,sizeof(tctype));
+  n->type_kind=CTK_PTR ;
+  n->size=sizeof(void*);
+  n->u.kid=t ;
+  return n ;
+}
+
+FUNC tctype* duel_mkctype_func(tctype *t)
+{
+  tctype *n ;
+  n=(tctype *) duel_malloc(sizeof(tctype));
+  duel_bzero((char*) n,sizeof(tctype));
+  n->size=0 ;
+  n->type_kind=CTK_FUNC ;
+  n->u.kid=t ;
+  return n ;
+}
+
+/* create a struct or union type. The fields are not set here, but
+ * filled individually with the next function
+ * note the having zero fields is supported. This shouldnt be legal in C
+ * but compilers allow pointer to sturct w/o every specifying the struct.
+ * this is especially true for gdb itself!
+ */
+
+FUNC tctype* duel_mkctype_struct(char *name,size_t size,int fields_no,
+				 bool is_union)
+{
+  tctype *n ;
+  n=(tctype *) duel_malloc(sizeof(tctype));
+  duel_bzero((char*) n,sizeof(tctype));
+  n->name=name ;
+  n->size=size ;
+  if(is_union) n->type_kind=CTK_UNION ;
+  else n->type_kind=CTK_STRUCT ;
+  n->u.f.fields_no=fields_no ;
+  if(fields_no==0) n->u.f.fields=NULL ;
+  else {
+    n->u.f.fields=(tctype_field *) duel_malloc(fields_no*sizeof(tctype_field));
+    duel_bzero((char*) n->u.f.fields,fields_no*sizeof(tctype_field));
+  }
+  return n ;
+}
+
+/* insert field (field_no) into sturct/union (t), with type fctype 
+ */
+PROC duel_mkctype_struct_field(tctype *t,int field_no,char *name,
+			       int bitpos,int bitlen, tctype *fctype)
+{
+   tctype_field *f ;
+   duel_assert(t->type_kind==CTK_STRUCT || t->type_kind==CTK_UNION);
+   duel_assert(field_no>=0 && field_no <= t->u.f.fields_no);
+   f= &t->u.f.fields[field_no] ;
+   f->name=name ;
+   f->bitpos=bitpos ;
+   f->bitlen=bitlen ;
+   f->ctype=fctype ;
+}
+
+/* create an enum type. The enumerators are not set here, but
+ * filled individually with the next function
+ * again like sturct, we support zero enums. I am not sure its needed,
+ * but better safe than sorry.
+ */
+
+FUNC tctype* duel_mkctype_enum(char *name,tctype_kind real_type_kind,
+			       size_t size,int enumerators_no)
+{
+  tctype *n ;
+  n=(tctype *) duel_malloc(sizeof(tctype));
+  duel_bzero((char*) n,sizeof(tctype));
+  n->name=name ;
+  n->size=size ;
+  n->type_kind=CTK_ENUM ;
+  n->u.e.real_type_kind=real_type_kind ;
+  n->u.e.enumerators_no=enumerators_no ;
+  if(enumerators_no==0) n->u.e.enumerators=NULL ;
+  else {
+      n->u.e.enumerators= (tctype_enumerator *) 
+                   duel_malloc(enumerators_no*sizeof(tctype_enumerator));
+      duel_bzero((char*) n->u.e.enumerators,
+	           enumerators_no*sizeof(tctype_enumerator));
+  }
+  return n ;
+}
+
+
+/* insert enumerator (enumerator_no_ into an enum type (t), with given name/val
+ */
+PROC duel_mkctype_enumerator(tctype *t,int enumerator_no,char *name,int val)
+{
+   tctype_enumerator *e ;
+   duel_assert(t->type_kind==CTK_ENUM);
+   duel_assert(enumerator_no>=0 && enumerator_no <= t->u.e.enumerators_no);
+   e= &t->u.e.enumerators[enumerator_no] ;
+   e->name=name ;
+   e->val=val ;
+}
+
+FUNC tctype* duel_mkctype_array(tctype *t,int size)
+{
+  tctype *n ;
+  if(t->size==0) duel_gen_error("array of a type of zero size is illegal",0);
+  if(size<=0) 	 duel_gen_error("array of size zero or negative is illegal",0);
+  n=(tctype *) duel_malloc(sizeof(tctype));
+  duel_bzero((char*) n,sizeof(tctype));
+  n->type_kind=CTK_ARRAY ;
+  n->size=size*t->size ;
+  n->u.kid=t ;
+  return n ;
+}
+
+
+LFUNC tctype* init_basic_ctype(tctype_kind tk,char *name,size_t size)
+{
+    tctype *p = duel_malloc(sizeof(tctype));
+    p->type_kind=tk ;
+    p->name=name ;
+    p->size=size ;
+    return p ;
+}
+
+PROC duel_init_basic_ctypes(void)
+{
+  ctype_void= init_basic_ctype(CTK_VOID, "void", 0);
+
+  ctype_char    =init_basic_ctype(CTK_CHAR,    "char", sizeof(char));
+  ctype_short   =init_basic_ctype(CTK_SHORT,   "short",sizeof(short));
+  ctype_int     =init_basic_ctype(CTK_INT,     "int",  sizeof(int));
+  ctype_long    =init_basic_ctype(CTK_LONG,    "long", sizeof(long));
+  ctype_longlong=init_basic_ctype(CTK_LONGLONG,"long long", sizeof(long long));
+
+  ctype_schar    =init_basic_ctype(CTK_SCHAR,  "signed char", sizeof(tschar));
+  ctype_uchar    =init_basic_ctype(CTK_UCHAR,  "unsigned char", sizeof(tuchar));
+  ctype_ushort   =init_basic_ctype(CTK_USHORT, "unsigned short",sizeof(tushort));
+  ctype_uint     =init_basic_ctype(CTK_UINT,   "unsigned int",  sizeof(tuint));
+  ctype_ulong    =init_basic_ctype(CTK_ULONG,  "unsigned long", sizeof(tulong));
+  ctype_ulonglong=init_basic_ctype(CTK_ULONG,  "unsigned long long", sizeof(tulonglong));
+
+  ctype_double=init_basic_ctype(CTK_DOUBLE, "double", sizeof(double));
+  ctype_float =init_basic_ctype(CTK_FLOAT,  "float",  sizeof(float));
+
+  ctype_voidptr=duel_mkctype_ptr(ctype_void);
+  ctype_charptr=duel_mkctype_ptr(ctype_char);
+  /* find and set the special types.
+   * support only a signed ptrdiff; size_t/ptrdiff must both be int or long
+   */
+  { ptrdiff_t p ; size_t s ;
+    p= -1 ; s= -1 ;
+    if(p>0)  duel_gen_error("bad ptrdiff_t - unsigned",0);
+  
+    if(sizeof(p)==sizeof(int)) 	     ctype_ptrdiff_t=ctype_int ;
+    else if(sizeof(p)==sizeof(long)) ctype_ptrdiff_t=ctype_long ;
+    else duel_gen_error("bad ptrdiff_t size",0);
+
+    if(sizeof(s)==sizeof(int)) 	ctype_size_t= (s<0)? ctype_int:ctype_uint ;
+    else 
+    if(sizeof(s)==sizeof(long)) ctype_size_t= (s<0)? ctype_long:ctype_ulong ;
+    else duel_gen_error("bad size_t size",0);
+   }
+}
+
+
--- gdb/duel/wishlist.doc
+++ gdb/duel/wishlist.doc
@@ -0,0 +1,160 @@
+
+ += -= etc operators
+ initialize variables e.g. int x=0 , maybe even scopes 
+ set declared var to zero.
+ allow x++ for aliases as a special case.
+ x->?y or x?->y to be like  (x!=?0)->y OR x?? or ??x  as (x!=?0)  
+  
+ +/ */ &/ |/ ^/   ==/ !=/ </ >/ <=/ >=/
+ src(location) as scope
+ istype(type,x)  to check type of x
+ ?x to check for x in current scope
+ conditional break points, watchpoints
+ better type checking of structs.
+ bitfield assignment
+ better builtin commands, help
+ output formatting, duel/xodus, more general out(v)
+ duel macros/functions
+ \x and \\x
+ check array bounds
+ x->>y  x->-y x>--y
+ check cycles in --> expansion
+  ..:+ ..:-
+ print types, do so better
+
+DUEL.PIPE - make it general purpose
+------------------------------------
+see duel.pipe for some details.
+should be made general purpose, so it is easy to modify/add functions.
+many basic functions can be writted - sort, uniq, matrix, vector,
+compress, etc.
+
+Checking for cycles in --> expansion
+------------------------------------
+One can easily add code to handle head-->(next!=?head), as well as
+head-->(next!=?_). If you don't know what these do, you should RTFM again :-)
+
+You can also keep all pointers that have been expanded already,
+hence detecting any kind of cycle. However, what to do in
+such cases is debatable. Some users would like to see
+cycles terminate expansion quietly, while others will want a fatal error
+to be produced. This could be handled by an operator like x-->?y which
+would indicate that cycles are ok and expansion should terminate quietly,
+while x-->y produce an error on cycles.
+
+Another idea is to have _cyc defined inside -->, to allow the user to
+do something about cycles, e.g.  head-->(if(!_cyc) next). There are
+several ways to manage _cyc: a boolean, or equal to head; true if
+this is already a cycle, or a function cyc(next), which return true if
+next would cycle, or return next unles it would cycle, etc.
+This last one seems to handle most cases:
+head-->(cyc(left),cyc(right))	- return tree, igoring cycles
+head-->(cyc(0),left,right) 	- like head->(left,right), but mention of cyc
+				  which by itself does nothing, cause general
+				  cycle detection as errors
+as above, but left!=?_		- detect general cycles, pointer to self ok
+
+While we adding cyc(), we can also add _depth to indicate current depth,
+e.g. head-->(if(_depth<6) (left,right)) -- expand only to depth 6
+and also acceess to the current path with _path(i), _path(0)=_ and 
+_path(_depth-1)=head
+head-->(cyc(0), if(! ||/_path(.._deapth)==left) left, ...)
+		which avoids cycles "in the path"
+
+If you an strong opinion on this subject, or a better idea, lemme know!
+
+Other expansions: x->>y x->-y x>--y
+------------------------------------
+x-->y applies DFS (Depth First Search). Another useful expansion would be
+BFS (Breath First Search). It is simple to implement - y's values should
+be put on a queue instead of a stack, and the code in place has been written
+with this in mind (eval.c).
+Others will probably want a post-order or in-order search instead of preorder
+search as done by x-->y. I am not sure this is important enough to merit
+new operators, but ->- for inorder and >-- for post order are reserved.
+These, too, should be easy to implement, but it is very unclear that the
+added complexity to the language is worth it. If you really need such
+operators, lemme know.
+
+Increment count for x..y   (x..y:+z and x..y:-z)
+------------------------------------------------
+The x..y operator could be extended to support an increment or decrement
+value. This would allow 1..n to be written as 1..n:+1 so when n==0 it
+will not produce the surprising 1,0 results. 
+However, 0..10:+2 could also be written as (0..5)*2, so it is unclear
+that such operators are really needed (maybe just x..+y, x..-y to force
+the direction).
+
+
+Duel functions / print procedures
+-------------------------------------
+the command:  dl define x expr
+will define x to be duel procedure for expression expr.
+x can then be used like an alias (indeed, it will probably be kept in
+the alias table with a special value). x evaluation returns multiple 
+values. 
+There is no need parameters, since emp.x would call "x" using the implicit
+parameter "_" set as emp. the expression for x is essentially put into
+the code for the execution. Having no parameters (except implicit ones)
+make it easier to document, use etc.
+
+Such functions (macros?) are most useful for output. e.g.
+dl define empout  val_type,a, u.if(val_type==0) code*6,name else code,z
+dl emp.empout
+will produce output for 
+  struct {
+   int val_type,code ;
+   char a;
+   union { char *name ; double z ; } u 
+   } emp ;
+
+the empout procedure can be defined just once, and used to output such
+unions as needed.
+
+The next step is to call such functions automatically for output and
+for expansion. We add syntax like  dl define out(type) expr
+
+then whenever an expression of the given type is to be printed, this
+code is evaluated instead, e.g.:
+dl define out(struct emp) ...
+dl emp   	## this calls the above out code for the output.
+
+We can also expand expressions by calling the right function, e.g.
+The operator "\" calls a function to expand a specific type:
+dl define \(struct list *)  (_-->next)
+dl if(\head#i == \head#j && i<j) \head[[i,j]]
+
+instead of writing this code (find non unique elements of linked list):
+   if(head-->next#i == head-->next#j && i<j) head-->next[[i,j]]
+
+Both printing and expansion occurs automatically based on TYPE.
+It is unclear if the an array is allowed to be expanded by a pointer
+type expansion or not (i.e. is \(int *) to expand "int x[40]").
+this might require an extension to types allowing \(int [n]) which matches
+any int array and set n for the specific bound. Types could be extended
+in a similar way, e.g. \(type **) _[0..]@0
+which expands any array of pointers (e.g. argv).
+This can quickly require scope-nesting for local aliases/variables.
+
+As before, it is unclear what of these is useful. Unless people depends on
+duel heavily, and write such "output/expansion" functions for the project,
+the features are useless (who is going to use this interactively?)
+
+Regular expressions for names. $xxx and `xxx`
+----------------------------------------------
+this allows things like emp.`value_*` to return all the value_something
+fields. it is really useful with structs, especially if a grep-style hat (^)
+is supported. Obviously extends to func.rexp, to show all locals, etc,
+which will make it possible to write a  stack-trace display in duel.
+
+exact semantics (e.g. what is matched and how) unclear.
+
+
+Nicer #/
+---------
+
+hash[..1024] => #/_-->next >? 2
+
+it is probably best if #/(exp) constructed (exp) as symbolic before it
+gets the values. or maybe, yes, best is #/(e) symbolic is #/(e1..en)
+where e1 is the first return symbolc, en the last.
--- gdb/duelgdb.c
+++ gdb/duelgdb.c
@@ -0,0 +1,694 @@
+/*   DUEL - A Very High Level Debugging Langauge.  */
+/*   Public domain code                            */
+/*   Written by Michael Golan mg@××××××××××××.edu  */
+/*$Header: /var/cvsroot/gentoo/src/patchsets/gdb/6.7.1/10_all_gdb-6.6-duel.patch,v 1.1 2007/12/29 21:06:06 vapier Exp $*/
+
+/* debugger dependent module, it contains all of duel's access to
+ * the outside world (debuggee, symbol table, etc)
+ */
+
+/*
+ * $Log: 10_all_gdb-6.6-duel.patch,v $
+ * Revision 1.1  2007/12/29 21:06:06  vapier
+ * add DUEL support #199987 by Sergei Golubchik
+ *
+ * Revision 1.30  08/11/14  23:14:00  serg
+ * ported to gdb 6.6.2, glibc 2.5
+ *
+ * Revision 1.20  93/03/20  10:35:48  mg
+ * fixed system("date")... didnt work on OS/2
+ *
+ * Revision 1.19  93/03/13  03:28:49  mg
+ * bug fixed frame(0).unknown_name caused a crash
+ * bug fixed duel didnt support enum of length zero but turns out gdb tables
+ * have such things (specifically, for some gdb internals!)
+ *
+ * Revision 1.18  93/03/12  05:43:22  mg
+ * Version 1.10 - tuint instead of uint etc, fixed gdb48 recognis. problem
+ *
+ * Revision 1.17  93/02/27  06:01:01  mg
+ * improved unsigned char default machines support,
+ * convert explicit uchar into "char" if they are the same.
+ *
+ * Revision 1.16  93/02/23  19:11:10  mg
+ * beauty changes + gdb4.8 support
+ *
+ * Revision 1.15  93/02/04  02:09:18  mg
+ * fixed enum enum names
+ *
+ * Revision 1.14  93/02/04  00:54:26  mg
+ * arr. fixed.
+ *
+ * Revision 1.13  93/02/03  21:54:14  mg
+ * create duel.out unless compiling with NO_DUEL_OUT
+ *
+ * Revision 1.12  93/02/03  21:46:33  mg
+ * fixed problems with null gdb type names.
+ * support "signed char"
+ *
+ * Revision 1.11  93/01/21  21:22:15  mg
+ * *** empty log message ***
+ *
+ * Revision 1.10  93/01/13  16:19:33  mg
+ * support mini symbol table lookup (malloc, printf on SUN didnt work)
+ *
+ * Revision 1.9  93/01/12  21:30:04  mg
+ * cleanup and set for release
+ *
+ * Revision 1.8  93/01/06  23:59:21  mg
+ * new memory alloc/release. moved target's malloc into duel code
+ * allow ^c to work, fixed help, fixed variable lookup for specific frame.
+ *
+ * Revision 1.7  93/01/03  07:27:11  mg
+ * support function calls!
+ *
+ * Revision 1.6  92/12/24  23:33:13  mg
+ * frames support
+ *
+ * Revision 1.5  92/10/19  15:06:29  mg
+ * made lcc happy
+ * no svalues
+ * new registers support and way of getting vars.
+ * these are temporary changes, new frames supports soon
+ *
+ * Revision 1.4  92/10/14  02:03:53  mg
+ * misc/gdb4.6/duel vars using malloc
+ *
+ * Revision 1.3  92/09/16  11:06:22  mg
+ * a lot more functions: get typedef/tags, alloc debuggee mem. +cosmetics
+ *
+ * Revision 1.2  92/09/15  05:37:28  mg
+ * fix enum size bug. added headers
+ *
+ */
+
+
+#include <stddef.h>   /* used for ptrdiff_t and size_t */
+#include <stdio.h>
+#include <string.h>
+#include <time.h>     /* for time/ctime stamping of duel.out */
+#include <assert.h>
+
+#include "defs.h"
+#include "symtab.h"
+#include "gdbtypes.h"
+#include "gdbcore.h"
+#include "frame.h"
+#include "target.h"
+#include "value.h"
+#include "symfile.h"
+#include "objfiles.h"
+#include "gdbcmd.h"
+#include "call-cmds.h"
+#include "infcall.h"
+
+#include "duel/global.h"
+#include "duel/proto.h"
+
+/* all output goes thru here */
+
+#include <stdarg.h>
+
+PROC duel_printf(char *fmt, ...)    /* like printf, but for duel output */
+{
+  va_list args;
+  va_start(args, fmt);
+  vprintf_filtered(fmt,args);
+  va_end(args);
+}
+
+PROC duel_flush(void)
+{ /* not yet. only really needed for redirections */
+}
+
+PROC duel_redirectable_output_start(char *s)
+{
+}
+
+PROC duel_redirectable_output_end(void)
+{
+}
+
+PROC duel_redirectable_output_abort(void)
+{
+}
+
+PROC duel_redirectable_output_init(void)
+{
+}
+
+/* all duel memory allocations go thru here */
+
+FUNC void* duel_malloc(size_t size)
+{
+  void *p ;
+  immediate_quit-- ;    /* disable ^C while xmalloc */
+  p=xmalloc(size);      /* gdb's malloc, incl zero return chk */
+  immediate_quit++ ;
+  QUIT ;                /* check if ^C while xmalloc called */
+  return p ;
+}
+
+PROC duel_free(void *p)
+{
+  immediate_quit-- ;
+  free(p);
+  immediate_quit++ ;
+  QUIT ;
+}
+
+/* fetch n bytes from the target at the given memory address.
+ * the address to fetch from is given by (from).
+ * the value is stored at the 'to' location, which points to space for
+ * n bytes in the debugger.
+ * if the address can not be accessed, false is returned (if all ok, ret true)
+ */
+
+FUNC bool duel_get_target_bytes(ttarget_ptr from,void *to,size_t n)
+{
+  return target_read_memory((CORE_ADDR)from,to,n)==0;
+}
+
+/* store n bytes to the debuggee. reverse parms from above */
+FUNC bool duel_put_target_bytes(ttarget_ptr to,void *from,size_t n)
+{
+   return target_write_memory((CORE_ADDR)to,from,n)==0;
+}
+
+/* fetch the value of a bitfield of a given structure.
+ * struct_at - a pointer to the structure
+ * bitpos    - the position of the field, in bits (as given in the type)
+ * bitlen    - the length of the field in bits
+ * to        - pointer to tuint  where value will be stored.
+ * tkind     - the type kind of the field (used to do sign extention if needed)
+ * note: I'm unaware of any compiler with bitfields that are not int/tuint.
+ */
+
+FUNC bool duel_get_target_bitfield(ttarget_ptr struct_at,int bitpos,
+                                    int bitlen,void *to,tctype_kind tkind)
+{
+  tuint bits ;
+  duel_assert(tkind==CTK_INT || tkind==CTK_UINT);
+  if(!duel_get_target_bytes(struct_at+bitpos/8,&bits,sizeof(bits)))
+      return FALSE;
+
+  /* now, move the field to the 'bottom' of bits, by shifting right */
+  bitpos%=8 ;                   /* fix it to a bit offset inside the 'bits' */
+  if (BITS_BIG_ENDIAN)             /* defined by gdb's src code */
+    bits >>= (sizeof(bits)*8-bitpos-bitlen) ;
+  else
+    bits >>= bitpos ;
+
+ /* finally chop down 'bits' to only bitlen significant bits,
+  * or sign-extend it if output field is 'int' and the sign is 1.
+  * ~0 is all ones, shift it to have bitlen zeros. Complement to get
+  * a bitlen string of 1's in the low-order bits. Common ugly hacks.
+  * Note: this code assume 2's complement
+  */
+
+  if(tkind==CTK_INT && (bits & 1<<(bitlen-1))) /* int field, negative sign */
+         bits|= ~0<<bitlen ;    /*sign extend */
+  else   bits&= ~(~0<<bitlen) ; /* clear all bits above the sign bit */
+  *(tuint*) to= bits ;
+
+  return TRUE ;
+}
+
+LFUNC struct type* duel_convert_type_to_gdb(tctype *ct);
+LFUNC tctype* duel_convert_type_from_gdb(struct type *gv);
+
+/* convert gdb value into duel's. Used to fetch const, registers, func ret val
+ * and convert a symbol into a reference.
+ * otherwise, duel access target's memory directly.
+ */
+
+LPROC duel_convert_value_from_gdb(struct value *gv, tvalue *dv)
+{
+  dv->ctype=duel_convert_type_from_gdb(value_type(gv));
+  if(VALUE_LVAL(gv) == lval_memory) {
+      dv->val_kind=VK_LVALUE ;
+      dv->u.lvalue= (ttarget_ptr) VALUE_ADDRESS(gv) ; /*address of variable*/
+  }
+  else
+  if(ctype_kind_scalar(dv->ctype) && (VALUE_LVAL(gv) == not_lval ||
+     VALUE_LVAL(gv) == lval_register)) {
+      dv->val_kind=VK_RVALUE ;
+      duel_bcopy(&dv->u,value_contents_raw(gv),dv->ctype->size);
+  }
+  else
+  duel_fatal("unsupported value type returned by gdb");
+}
+
+
+/* helper function converts duel values to gdb's values. used only to make
+ * function calls to the target, so current support is weak.
+ * gdb thinks long=int=pointers, so we go along with that.
+ * To support arbitrary types like struct/union, we can probably fake it
+ * by making a gdb lvalue. but i am not sure how/what
+ */
+
+LFUNC struct value *convert_duel_val_to_gdb_val(tvalue *v)
+{
+   struct value *gv ;
+   if(v->val_kind!=VK_RVALUE) return 0 ; /* cant handle lvals */
+   switch(v->ctype->type_kind) {
+/* duel standardize func parms, so this code is not required. if this
+ * function is used for more than func parms, as its name implies, we will
+ * need to do better than this.
+ * there is no gdb "builtin_type_signed_char", so we assume char
+   case CTK_CHAR:
+     gv=value_from_longest(builtin_type_char,v->u.rval_char);          break;
+   case CTK_SCHAR:
+     gv=value_from_longest(builtin_type_char,v->u.rval_schar);         break;
+   case CTK_UCHAR:
+     gv=value_from_longest(builtin_type_unsigned_char,v->u.rval_char); break;
+   case CTK_USHORT:
+     gv=value_from_longest(builtin_type_unsigned_short,v->u.rval_ushort);break;
+   case CTK_SHORT:
+     gv=value_from_longest(builtin_type_unsigned_short,v->u.rval_short);break;
+*/
+   case CTK_INT:
+     gv=value_from_longest(builtin_type_int, v->u.rval_int);            break;
+   case CTK_UINT:
+     gv=value_from_longest(builtin_type_unsigned_int, v->u.rval_uint) ; break ;
+   case CTK_LONG:
+     gv=value_from_longest(builtin_type_long, v->u.rval_long)         ; break ;
+   case CTK_ULONG:
+     gv=value_from_longest(builtin_type_unsigned_long,v->u.rval_ulong); break ;
+   case CTK_LONGLONG:
+     gv=value_from_longest(builtin_type_long_long, v->u.rval_longlong)     ; break ;
+   case CTK_ULONGLONG:
+     gv=value_from_longest(builtin_type_unsigned_long_long,v->u.rval_ulonglong); break ;
+   case CTK_FLOAT:
+     gv=value_from_double(builtin_type_float, v->u.rval_float) ; break ;
+   case CTK_DOUBLE:
+     gv=value_from_double(builtin_type_double, v->u.rval_double) ; break ;
+   case CTK_PTR:
+     gv=value_from_longest(lookup_pointer_type(builtin_type_void),
+                        (long) v->u.rval_ptr) ;break ;
+   default: duel_assert(0);
+   }
+   return gv ;
+}
+
+/* make a function call to the target.
+ * this is the only case where we convert duel tvalue into gdb's values.
+ * gdb thinks long=int=pointers, so we go along with that.
+ */
+
+PROC duel_target_func_call(tvalue *func, tvalue *parms[],
+                            int parms_no,tvalue *rval)
+{
+    struct value *gfunc, *grval, *gparms[20] ;
+    int i ;
+    struct type *gftype ;
+
+    duel_assert(func->val_kind==VK_LVALUE);
+    for(i=0 ; i<parms_no ; i++) {
+        gparms[i]=convert_duel_val_to_gdb_val(parms[i]) ;
+        if(gparms[i]==NULL)
+            duel_op_error("unsupported func call parm type",0,parms[i],0);
+    }
+    gftype =duel_convert_type_to_gdb(func->ctype);
+    if(!gftype) duel_op_error("unsupported func return parm type",0,func,0);
+    gftype = lookup_pointer_type(gftype);
+    if(!gftype)
+            duel_op_error("unsupproted func return type",0,func,0);
+
+    gfunc = value_from_longest(gftype,(LONGEST) func->u.lvalue);
+
+    grval=call_function_by_hand(gfunc,parms_no,gparms);
+    if(func->ctype->u.kid->type_kind==CTK_VOID) return ; /* no return val*/
+    duel_convert_value_from_gdb(grval,rval);
+}
+
+
+
+#define TYPE_HASH_SIZE (1024*128)
+#define type_hash_func(t) ( (((long)t&0xffff) + (((long)t>>16)&0xffff)) \
+                             % TYPE_HASH_SIZE )
+struct {
+    struct type *t ;    /* gdb type ptr */
+    tctype *ct ;        /* duel type ptr */
+} duel_thash[TYPE_HASH_SIZE] ;
+
+LPROC duel_add_hash(struct type *t, tctype *ct)
+{
+    int start,i=type_hash_func(t);
+    start=i ;
+    do {
+        if(duel_thash[i].t==0) {
+            duel_thash[i].t=t ;
+            duel_thash[i].ct=ct ;
+            return ;
+        }
+        if(duel_thash[i].t==t) {
+            if(duel_thash[i].ct==ct) return ;
+            duel_fatal("type hash table inconsistency ");
+        }
+        i= (i+1)%TYPE_HASH_SIZE ;
+    } while(i!=start);
+    duel_fatal("type hash table is full");
+}
+
+LFUNC tctype* duel_find_hash(struct type *t)
+{
+    int start,i=type_hash_func(t);
+    start=i ;
+    do {
+        if(duel_thash[i].t==0) break ;
+        if(duel_thash[i].t==t) return duel_thash[i].ct ;
+        i= (i+1)%TYPE_HASH_SIZE ;
+    } while(i!=start);
+    return NULL ;
+}
+
+/* a simple conversion back to gdb types, used only for target func calls */
+/* this is a hack and based on the assumption that the type was first
+ * converted FROM gdb to duel. (turn out to be false for int func from
+ * minimal symbols, so we do this as a special case.)
+ */
+LFUNC struct type* duel_convert_type_to_gdb(tctype *ct)
+{
+   int i ;
+   for(i=0 ; i<TYPE_HASH_SIZE ; i++)
+       if(duel_thash[i].ct==ct) return duel_thash[i].t ;
+
+   if(ct->type_kind==CTK_FUNC && ct->u.kid->type_kind==CTK_INT)
+	  return  lookup_function_type (builtin_type_int);
+   return NULL ;
+}
+
+#define INTTYPE_CHAR                    1
+#define INTTYPE_SHORT                   2
+#define INTTYPE_INT                     0
+#define INTTYPE_LONG                    4
+#define INTTYPE_SIGNED                  0
+#define INTTYPE_UNSIGNED               16
+
+struct { char *name; int len; int codetype; } name_to_codetype[]=
+{ {"char", 4, INTTYPE_CHAR },
+  {"short", 5, INTTYPE_SHORT },
+  {"int", 3, INTTYPE_INT },
+  {"long", 4, INTTYPE_LONG },
+  {"signed", 6, INTTYPE_SIGNED },
+  {"unsigned", 8, INTTYPE_UNSIGNED },
+  {0,0,0}
+};
+
+  /* given a gdb type t, return an equivalent duel type */
+
+LFUNC tctype* duel_convert_type_from_gdb(struct type *t)
+{
+  tctype *ct=duel_find_hash(t);
+  if(ct) return ct ;
+
+  if (duel_debug)
+    duel_printf("gdb type: {%d, %s}\n", TYPE_CODE(t), TYPE_NAME(t));
+
+  switch (TYPE_CODE (t)) {
+   case TYPE_CODE_BOOL:
+      if(strcmp(TYPE_NAME(t),"bool")==0) ct=ctype_uchar ; /* XXX HACK */
+      break;
+   case TYPE_CODE_INT: {
+      int i, type=0;
+      char *s=TYPE_NAME(t);
+      while (*s)
+        for (i=0; name_to_codetype[i].name; i++) {
+          if (strncmp(s,name_to_codetype[i].name,name_to_codetype[i].len) == 0) {
+            s+=name_to_codetype[i].len;
+            if (*s == ' ') s++;
+            type+= name_to_codetype[i].codetype;
+            break;
+          }
+        }
+      if(type == INTTYPE_CHAR) ct=ctype_char ;
+      else if(type == INTTYPE_CHAR + INTTYPE_UNSIGNED) ct=ctype_uchar ;
+      else if(type == INTTYPE_SHORT) ct=ctype_short ;
+      else if(type == INTTYPE_SHORT + INTTYPE_UNSIGNED) ct=ctype_ushort ;
+      else if(type == INTTYPE_INT) ct=ctype_int ;
+      else if(type == INTTYPE_UNSIGNED)   ct=ctype_uint ;
+      else if(type == INTTYPE_LONG) ct=ctype_long ;
+      else if(type == INTTYPE_UNSIGNED + INTTYPE_LONG)  ct=ctype_ulong ;
+      else if(type == INTTYPE_LONG + INTTYPE_LONG) ct=ctype_longlong ;
+      else if(type == INTTYPE_UNSIGNED + INTTYPE_LONG + INTTYPE_LONG)  ct=ctype_ulonglong ;
+      break;
+     }
+   case TYPE_CODE_FLT:
+      if(strcmp(TYPE_NAME(t),"float")==0)  ct=ctype_float ;
+      else
+      if(strcmp(TYPE_NAME(t),"double")==0) ct=ctype_double ;
+      break;
+   case TYPE_CODE_VOID:
+      if(strcmp(TYPE_NAME(t),"void")==0) ct=ctype_void ;
+      break;
+   case TYPE_CODE_PTR:
+   case TYPE_CODE_REF:
+      {
+       /* the pointer might get defined when converting the target, so
+        * check the hashing again (reason: self-referencing structs)
+        */
+        tctype *target=duel_convert_type_from_gdb(TYPE_TARGET_TYPE(t));
+        if((ct=duel_find_hash(t))==NULL) ct=duel_mkctype_ptr(target);
+      }
+      break ;
+   case TYPE_CODE_FUNC:
+      ct=duel_mkctype_func(duel_convert_type_from_gdb(TYPE_TARGET_TYPE(t)));
+      break ;
+   case TYPE_CODE_ARRAY:
+      { int n=TYPE_LENGTH(TYPE_TARGET_TYPE(t));
+        if(n!=0) n=TYPE_LENGTH(t)/n;
+        ct=duel_mkctype_array(
+               duel_convert_type_from_gdb(TYPE_TARGET_TYPE(t)),n);
+      }
+      break;
+   case TYPE_CODE_STRUCT:
+   case TYPE_CODE_UNION:
+      { int i,n=TYPE_NFIELDS(t);
+        char *name=TYPE_NAME(t);
+	if(name == NULL) name="" ; /* duel can't handle null ptr! */
+        if(strncmp(name,"struct ",7)==0) name+=7 ;
+        if(strncmp(name,"union ",6)==0) name+=6 ;
+        ct=duel_mkctype_struct(name,TYPE_LENGTH(t),n,
+                        TYPE_CODE(t)==TYPE_CODE_UNION);
+        duel_add_hash(t,ct);  /* so a pointer to myself is recognized */
+        for(i=0 ; i<n ; i++)
+           duel_mkctype_struct_field(ct,i,TYPE_FIELD_NAME(t,i),
+                TYPE_FIELD_BITPOS(t,i), TYPE_FIELD_BITSIZE(t,i),
+                duel_convert_type_from_gdb(TYPE_FIELD_TYPE(t,i)));
+      }
+   break ;
+   case TYPE_CODE_ENUM:
+        /* TYPE_LENGTH(t) tell how big it is. I assume signed integral types.
+         * it is unclear if gdb supports unsigned enums and how
+         * (e.g. enum { x=0,y=250 } stored in uchar
+         * FIELDS contain the tags, BITPOS is the assigned value.
+         */
+      { int i,n=TYPE_NFIELDS(t),len=TYPE_LENGTH(t);
+	char *name=TYPE_NAME(t);
+        tctype_kind k ;
+	if(name==NULL) name="" ;	/* duel can't handle null ptr */
+        if(strncmp(name,"enum ",5)==0) name+=5 ;
+        /* select 'real' stored type. note order important if short==int.
+         * long is not allowed as far as I know ANSI C (enums are conv. to int)
+	 * Amazingly, some internal gdb struct (sym) can have an enum of
+	 * size zero (enum language, gdb4.8). We allow this as int but warn.
+	 * gdb> p sizeof(sym->ginfo.lang_specific.language) gives zero
+         */
+	if(len==0) {
+	    duel_printf("Warning: enum %s is size zero. assumed int\n",name);
+	    len=sizeof(int);
+	}
+        if(len==sizeof(int))        k=CTK_INT ;
+        else if(len==sizeof(short)) k=CTK_SHORT ;
+        else if(len==sizeof(char))  k=CTK_CHAR ;
+        else duel_assert(0);
+
+        ct=duel_mkctype_enum(name,k,len,n);
+        for(i=0 ; i<n ; i++)
+           duel_mkctype_enumerator(ct,i,TYPE_FIELD_NAME(t,i),
+                TYPE_FIELD_BITPOS(t,i));
+      }
+   break ;
+   case TYPE_CODE_TYPEDEF:
+      ct=duel_convert_type_from_gdb(check_typedef(t));
+      break ;
+   case TYPE_CODE_UNDEF:
+      break;
+  }
+  if(ct==0) duel_fatal("unsupported C type returned by gdb");
+  duel_add_hash(t,ct);
+  return ct ;
+}
+
+/* optimize frame access so frame(100..0) doesnt start the search from 0
+ * everytime. similar to selected_frame etc, but we dont want to mess up
+ * gdb's own frame setup (for up/down/print etc)
+ * this optimization should have been part of gdb, not here.
+ * ie. duel_select_frame should be a simple fast gdb call.
+ * we dont optimze going to frame 7 from frame 5 etc, this isn't typical.
+ * set last/tot frames to -2 to assure recomputeations (-1 is not good enuf)
+ */
+
+static struct frame_info * last_frame ;       /* last frame pointer we used */
+static int  last_frame_no ;     /* last frame number we used */
+static int  tot_frames_no ;     /* tot number of frames */
+
+LFUNC struct frame_info * duel_select_frame(int frame_no)
+{
+    struct frame_info * frame ;
+    if(last_frame_no==frame_no)   frame=last_frame ;
+    else
+    if(last_frame_no==frame_no-1) frame=get_prev_frame(last_frame);
+    else
+    if(last_frame_no==frame_no+1) frame=get_next_frame(last_frame);
+    else {
+        int count=frame_no ;
+        frame=get_current_frame();
+        while (frame && --count >= 0)
+            frame = get_prev_frame (frame);
+    }
+    duel_assert(frame); /* callee should have checked frames no*/
+    last_frame = frame ;
+    last_frame_no = frame_no ;
+    return frame ;
+}
+
+FUNC bool duel_get_target_variable(char *name, int frame_no, tvalue *v)
+{
+  struct symbol *sym;
+  struct frame_info * frame ;
+  struct block *blk ;
+  int len ;
+  struct value *gv ;                    /* gdb value */
+
+  if(frame_no== -1) {           /* use the user selected frame and block */
+      frame = get_selected_frame("Error!") ;
+      blk = get_selected_block(0) ;
+  }
+  else {
+      frame=duel_select_frame(frame_no) ;
+      blk = get_frame_block(frame, 0);
+  }
+  sym = lookup_symbol (name, blk, VAR_DOMAIN,0,0);
+  if(!sym) {		/* look up the symbol that has no debug info*/
+     struct minimal_symbol *m ;
+     if(frame_no != -1) return FALSE ; /* only locals looked up- not found*/
+     m=lookup_minimal_symbol (name,NULL, 0); /* find printf, malloc etc */
+     if(m == NULL) return FALSE ;
+     v->val_kind=VK_LVALUE ;
+#ifdef SYMBOL_LANGUAGE
+     /* in gdb4.8 the mini table changed. I use the existance of the above
+      * #define symbol as hack to indicate gdb.4.8 */
+     v->u.lvalue=(ttarget_ptr) SYMBOL_VALUE_ADDRESS(m);
+#else
+     v->u.lvalue=(ttarget_ptr) m->address ;
+#endif
+	/* guess it is an int if it is a data type, an int func if text */
+     if(m->type == mst_data || m->type == mst_bss) v->ctype=ctype_int ;
+     else
+     if(m->type == mst_text) v->ctype=duel_mkctype_func(ctype_int);
+     else return FALSE ;
+     return TRUE ;
+  }
+  if(SYMBOL_CLASS(sym)==LOC_TYPEDEF) return FALSE ;
+  /* if frame specificed, allow only local variables to be found */
+  if(frame_no!= -1 && (SYMBOL_CLASS(sym)==LOC_STATIC ||
+   SYMBOL_CLASS(sym)==LOC_BLOCK || SYMBOL_CLASS(sym)==LOC_CONST)) return FALSE;
+  gv=read_var_value(sym,frame);
+  if(gv==0) return FALSE ; /* frame not found or illegal */
+  duel_convert_value_from_gdb(gv,v);
+  return TRUE ;
+}
+
+
+/* return the total number of frames on the stack */
+
+FUNC int duel_get_frames_number(void)
+{
+    int n ;
+    struct frame_info * frame ;
+    if(tot_frames_no!= -2) return tot_frames_no ;
+    frame=get_current_frame();
+    for(n=0 ; frame ; n++)
+        frame = get_prev_frame (frame);
+    return tot_frames_no=n ;
+}
+
+FUNC ttarget_ptr duel_get_function_for_frame(int frame_no)
+{
+   struct frame_info * frame=duel_select_frame(frame_no);
+   struct symbol *sym = get_frame_function(frame);
+   struct value *val = read_var_value(sym,frame);
+   duel_assert(val!=0 && VALUE_LVAL(val) == lval_memory);
+
+   return (ttarget_ptr) VALUE_ADDRESS(val) ;
+}
+
+FUNC tctype* duel_get_target_typedef(char *name)
+{
+  struct symbol *sym;
+  sym = lookup_symbol (name, get_selected_block(0), VAR_DOMAIN,0,0);
+  if(!sym || SYMBOL_CLASS(sym)!=LOC_TYPEDEF) {
+      sym = lookup_symbol (name, 0, VAR_DOMAIN, 0,0);
+      if(!sym || SYMBOL_CLASS(sym)!=LOC_TYPEDEF) return NULL ;
+  }
+  return duel_convert_type_from_gdb(SYMBOL_TYPE(sym));
+}
+
+FUNC tctype* duel_get_target_struct_tag(char *name)
+{
+  struct symbol *sym;
+  sym = lookup_symbol (name, get_selected_block(0), STRUCT_DOMAIN,0,0);
+  if(!sym || TYPE_CODE(SYMBOL_TYPE(sym))!=TYPE_CODE_STRUCT) {
+      sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0,0);
+      if(!sym || TYPE_CODE(SYMBOL_TYPE(sym))!=TYPE_CODE_STRUCT) return NULL ;
+  }
+  return duel_convert_type_from_gdb(SYMBOL_TYPE(sym));
+}
+
+FUNC tctype* duel_get_target_union_tag(char *name)
+{
+  struct symbol *sym;
+  sym = lookup_symbol (name, get_selected_block(0), STRUCT_DOMAIN,0,0);
+  if(!sym || TYPE_CODE(SYMBOL_TYPE(sym))!=TYPE_CODE_UNION) {
+      sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0,0);
+      if(!sym || TYPE_CODE(SYMBOL_TYPE(sym))!=TYPE_CODE_UNION) return NULL ;
+  }
+  return duel_convert_type_from_gdb(SYMBOL_TYPE(sym));
+}
+
+FUNC tctype* duel_get_target_enum_tag(char *name)
+{
+  struct symbol *sym;
+  sym = lookup_symbol (name, get_selected_block(0), STRUCT_DOMAIN,0,0);
+  if(!sym || TYPE_CODE(SYMBOL_TYPE(sym))!=TYPE_CODE_ENUM) {
+      sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0,0);
+      if(!sym || TYPE_CODE(SYMBOL_TYPE(sym))!=TYPE_CODE_ENUM) return NULL ;
+  }
+  return duel_convert_type_from_gdb(SYMBOL_TYPE(sym));
+}
+
+/*
+ * entry point from gdb.
+ * produce help in gdb's format, or call duel enter point.
+ * we allow ^c to quit immidiatly, and setup memory release cleanup.
+ */
+
+void duel_command(char *exp,int from_tty)
+{
+  last_frame_no = -2 ;  /* recompute frame location on each dl command */
+  tot_frames_no = -2 ;
+
+  make_cleanup(duel_cleanup, 0);       /* clear all allocated mem */
+  immediate_quit++ ;
+  duel_parse_and_eval(exp);
+  immediate_quit-- ;
+}
+
+void
+_initialize_duel()
+{
+  add_com ("duel", class_vars, duel_command,
+"Evaluate Duel expressions. Duel is a very high level debugging language.\n\
+\"dl help\" for help.\n");
+  add_com_alias ("dl", "duel", class_vars, 1);
+
+}



1.1                  src/patchsets/gdb/6.7.1/11_all_gdb-6.6-duel-integrate.patch

file : http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/gdb/6.7.1/11_all_gdb-6.6-duel-integrate.patch?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo/src/patchsets/gdb/6.7.1/11_all_gdb-6.6-duel-integrate.patch?rev=1.1&content-type=text/plain

Index: 11_all_gdb-6.6-duel-integrate.patch
===================================================================
--- gdb/Makefile.in
+++ gdb/Makefile.in
@@ -116,6 +116,9 @@
 # Where is the "-liberty" library?  Typically in ../libiberty.
 LIBIBERTY = ../libiberty/libiberty.a
 
+# Where is the DUEL library ? Always in duel/src
+DUEL=duel/duel.a
+
 # Where is the BFD library?  Typically in ../bfd.
 BFD_DIR = ../bfd
 BFD = $(BFD_DIR)/libbfd.a
@@ -383,9 +386,9 @@
 CLIBS = $(SIM) $(READLINE) $(OPCODES) $(BFD) $(INTL) $(LIBIBERTY) \
 	$(XM_CLIBS) $(TM_CLIBS) $(NAT_CLIBS) $(GDBTKLIBS) @LIBS@ \
 	$(LIBICONV) $(LIBEXPAT) \
-	$(LIBIBERTY) $(WIN32LIBS)
+	$(LIBIBERTY) $(WIN32LIBS) $(DUEL)
 CDEPS = $(XM_CDEPS) $(TM_CDEPS) $(NAT_CDEPS) $(SIM) $(BFD) $(READLINE_DEPS) \
-	$(OPCODES) $(INTL_DEPS) $(LIBIBERTY) $(CONFIG_DEPS)
+	$(OPCODES) $(INTL_DEPS) $(LIBIBERTY) $(CONFIG_DEPS) $(DUEL)
 
 ADD_FILES = $(XM_ADD_FILES) $(TM_ADD_FILES) $(NAT_ADD_FILES)
 ADD_DEPS = $(XM_ADD_FILES) $(TM_ADD_FILES) $(NAT_ADD_FILES)
@@ -561,7 +564,7 @@
 	ui-out.c utils.c ui-file.h ui-file.c \
 	user-regs.c \
 	valarith.c valops.c valprint.c value.c varobj.c vec.c \
-	wrapper.c \
+	wrapper.c duelgdb.c \
 	xml-tdesc.c xml-support.c
 
 LINTFILES = $(SFILES) $(YYFILES) $(CONFIG_SRCS) init.c
@@ -948,7 +951,7 @@
 	dwarf2expr.o dwarf2loc.o dwarf2-frame.o \
 	ada-lang.o c-lang.o f-lang.o objc-lang.o \
 	ui-out.o cli-out.o \
-	varobj.o vec.o wrapper.o \
+	varobj.o vec.o wrapper.o duelgdb.o \
 	jv-lang.o jv-valprint.o jv-typeprint.o \
 	m2-lang.o p-lang.o p-typeprint.o p-valprint.o \
 	scm-exp.o scm-lang.o scm-valprint.o \
@@ -971,7 +974,7 @@
 
 TSOBS = inflow.o
 
-SUBDIRS = @subdirs@
+SUBDIRS = @subdirs@ duel
 
 # For now, shortcut the "configure GDB for fewer languages" stuff.
 YYFILES = c-exp.c \
@@ -3238,4 +3241,7 @@
 	$(gdb_curses_h) $(gdb_assert_h)
 	$(CC) -c $(INTERNAL_CFLAGS) $(srcdir)/tui/tui-winsource.c
 
+$(DUEL):
+	$(MAKE) -C duel
+
 ### end of the gdb Makefile.in.



-- 
gentoo-commits@g.o mailing list