git.oblomov.eu Git - wine/blob - debugger/debugger.h

   1 /*
   2  * Debugger definitions
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  */
   6
   7 #ifndef __WINE_DEBUGGER_H
   8 #define __WINE_DEBUGGER_H
   9
  10 #include <sys/types.h> /* u_long ... */
  11 #include <assert.h>
  12 #include "windef.h"
  13 #include "winbase.h"
  14 #include "wine/exception.h"
  15
  16 #ifdef __i386__
  17 #define STEP_FLAG 0x00000100 /* single step flag */
  18 #define V86_FLAG  0x00020000
  19 #endif
  20
  21 #define SYM_FUNC         0x0
  22 #define SYM_DATA         0x1
  23 #define SYM_WIN32        0x2
  24 #define SYM_WINE         0x4
  25 #define SYM_INVALID      0x8
  26 #define SYM_TRAMPOLINE   0x10
  27 #define SYM_STEP_THROUGH 0x20
  28
  29 enum    debug_type {DT_BASIC, DT_CONST, DT_POINTER, DT_ARRAY, DT_STRUCT, DT_ENUM, DT_TYPEDEF, DT_FUNC, DT_BITFIELD};
  30
  31
  32 /*
  33  * Return values for DEBUG_CheckLinenoStatus.  Used to determine
  34  * what to do when the 'step' command is given.
  35  */
  36 #define FUNC_HAS_NO_LINES       (0)
  37 #define NOT_ON_LINENUMBER       (1)
  38 #define AT_LINENUMBER           (2)
  39 #define FUNC_IS_TRAMPOLINE      (3)
  40
  41 /*
  42  * For constants generated by the parser, we use this datatype
  43  */
  44 extern struct datatype * DEBUG_TypeShortUInt;
  45 extern struct datatype * DEBUG_TypeInt;
  46 extern struct datatype * DEBUG_TypeIntConst;
  47 extern struct datatype * DEBUG_TypeUSInt;
  48 extern struct datatype * DEBUG_TypeString;
  49
  50 typedef struct
  51 {
  52     DWORD               seg;  /* 0xffffffff means current default segment (cs or ds) */
  53     DWORD               off;
  54 } DBG_ADDR;
  55
  56 #define DV_TARGET       0xF00D
  57 #define DV_HOST         0x50DA
  58
  59 typedef struct
  60 {
  61    struct datatype*     type;
  62    int                  cookie; /* DV_??? */
  63    DBG_ADDR             addr;
  64 } DBG_VALUE;
  65
  66 struct list_id
  67 {
  68     char * sourcefile;
  69     int    line;
  70 };
  71
  72 struct  wine_lines {
  73   unsigned long         line_number;
  74   DBG_ADDR              pc_offset;
  75 };
  76
  77 struct symbol_info
  78 {
  79   struct name_hash * sym;
  80   struct list_id     list;
  81 };
  82
  83 typedef struct wine_lines WineLineNo;
  84
  85 /*
  86  * This structure holds information about stack variables, function
  87  * parameters, and register variables, which are all local to this
  88  * function.
  89  */
  90 struct  wine_locals {
  91   unsigned int          regno:8;        /* For register symbols */
  92   signed int            offset:24;      /* offset from esp/ebp to symbol */
  93   unsigned int          pc_start;       /* For RBRAC/LBRAC */
  94   unsigned int          pc_end;         /* For RBRAC/LBRAC */
  95   char                * name;           /* Name of symbol */
  96   struct datatype     * type;           /* Datatype of symbol */
  97 };
  98
  99 typedef struct wine_locals WineLocals;
 100
 101 enum exec_mode
 102 {
 103     EXEC_CONT,                  /* Continuous execution */
 104     EXEC_PASS,                  /* Continue, passing exception to app */
 105     EXEC_STEP_OVER,             /* Stepping over a call to next source line */
 106     EXEC_STEP_INSTR,            /* Step to next source line, stepping in if needed */
 107     EXEC_STEPI_OVER,            /* Stepping over a call */
 108     EXEC_STEPI_INSTR,           /* Single-stepping an instruction */
 109     EXEC_FINISH,                /* Step until we exit current frame */
 110     EXEC_STEP_OVER_TRAMPOLINE,  /* Step over trampoline.  Requires that
 111                                  * we dig the real return value off the stack
 112                                  * and set breakpoint there - not at the
 113                                  * instr just after the call.
 114                                  */
 115 };
 116
 117 #define DBG_BREAK       0
 118 #define DBG_WATCH       1
 119
 120 typedef struct
 121 {
 122     DBG_ADDR      addr;
 123     WORD          enabled : 1,
 124                   type : 1,
 125                   is32 : 1,
 126                   refcount : 13;
 127     WORD          skipcount;
 128     union {
 129        struct {
 130           BYTE          opcode;
 131           BOOL          (*func)(void);
 132        } b;
 133        struct {
 134           BYTE          rw : 1,
 135                         len : 2;
 136           BYTE          reg;
 137           DWORD         oldval;
 138        } w;
 139     } u;
 140     struct expr * condition;
 141 } DBG_BREAKPOINT;
 142
 143 typedef struct tagDBG_THREAD {
 144     struct tagDBG_PROCESS*      process;
 145     HANDLE                      handle;
 146     DWORD                       tid;
 147     LPVOID                      start;
 148     LPVOID                      teb;
 149     int                         wait_for_first_exception;
 150     int                         dbg_mode;
 151     enum exec_mode              dbg_exec_mode;
 152     int                         dbg_exec_count;
 153     DBG_BREAKPOINT              stepOverBP;
 154     struct tagDBG_THREAD*       next;
 155     struct tagDBG_THREAD*       prev;
 156 } DBG_THREAD;
 157
 158 typedef struct tagDBG_PROCESS {
 159     HANDLE                      handle;
 160     DWORD                       pid;
 161     DBG_THREAD*                 threads;
 162     int                         num_threads;
 163     unsigned                    continue_on_first_exception;
 164     struct tagDBG_MODULE*       modules;
 165     unsigned long               dbg_hdr_addr;
 166     /*
 167      * This is an index we use to keep track of the debug information
 168      * when we have multiple sources.  We use the same database to also
 169      * allow us to do an 'info shared' type of deal, and we use the index
 170      * to eliminate duplicates.
 171      */
 172     int                         next_index;
 173     struct tagDBG_PROCESS*      next;
 174     struct tagDBG_PROCESS*      prev;
 175 } DBG_PROCESS;
 176
 177 extern  DBG_PROCESS*    DEBUG_CurrProcess;
 178 extern  DBG_THREAD*     DEBUG_CurrThread;
 179 extern  DWORD           DEBUG_CurrTid;
 180 extern  DWORD           DEBUG_CurrPid;
 181 extern  CONTEXT         DEBUG_context;
 182
 183 #define DEBUG_READ_MEM(addr, buf, len) \
 184       (ReadProcessMemory(DEBUG_CurrProcess->handle, (addr), (buf), (len), NULL))
 185
 186 #define DEBUG_WRITE_MEM(addr, buf, len) \
 187       (WriteProcessMemory(DEBUG_CurrProcess->handle, (addr), (buf), (len), NULL))
 188
 189 #define DEBUG_READ_MEM_VERBOSE(addr, buf, len) \
 190       (DEBUG_READ_MEM((addr), (buf), (len)) || (DEBUG_InvalLinAddr( addr ),0))
 191
 192 #define DEBUG_WRITE_MEM_VERBOSE(addr, buf, len) \
 193       (DEBUG_WRITE_MEM((addr), (buf), (len)) || (DEBUG_InvalLinAddr( addr ),0))
 194
 195 typedef struct tagDBG_MODULE {
 196    struct tagDBG_MODULE*        next;
 197    void*                        load_addr;
 198    char*                        module_name;
 199    char                         status;
 200    char                         type;
 201    short int                    dbg_index;
 202    HMODULE                      handle;
 203    void*                        extra_info;
 204 } DBG_MODULE;
 205
 206 /* status field */
 207 #define DM_STATUS_NEW           0
 208 #define DM_STATUS_LOADED        1
 209 #define DM_STATUS_ERROR         2
 210
 211 /* type field */
 212 #define DM_TYPE_UNKNOWN         0
 213 #define DM_TYPE_ELF             1
 214 #define DM_TYPE_NE              2
 215 #define DM_TYPE_PE              3
 216
 217 typedef struct {
 218    DWORD                val;
 219    const char*          name;
 220    LPDWORD              pval;
 221    struct datatype*     type;
 222 } DBG_INTVAR;
 223
 224 #define OFFSET_OF(__c,__f)              ((int)(((char*)&(((__c*)0)->__f))-((char*)0)))
 225
 226   /* from winelib.so */
 227 extern void DEBUG_ExternalDebugger(void);
 228
 229   /* debugger/break.c */
 230 extern void DEBUG_SetBreakpoints( BOOL set );
 231 extern void DEBUG_AddBreakpoint( const DBG_VALUE *addr, BOOL (*func)(void) );
 232 extern void DEBUG_AddBreakpointFromId( const char *name, int lineno );
 233 extern void DEBUG_AddBreakpointFromLineno( int lineno );
 234 extern void DEBUG_AddWatchpoint( const DBG_VALUE *addr, int is_write );
 235 extern void DEBUG_AddWatchpointFromId( const char *name, int lineno );
 236 extern void DEBUG_DelBreakpoint( int num );
 237 extern void DEBUG_EnableBreakpoint( int num, BOOL enable );
 238 extern void DEBUG_InfoBreakpoints(void);
 239 extern BOOL DEBUG_HandleTrap(void);
 240 extern BOOL DEBUG_ShouldContinue( DWORD code, enum exec_mode mode, int * count );
 241 extern void DEBUG_SuspendExecution( void );
 242 extern enum exec_mode DEBUG_RestartExecution( enum exec_mode mode, int count );
 243 extern BOOL DEBUG_IsFctReturn(void);
 244 extern int  DEBUG_AddBPCondition(int bpnum, struct expr * exp);
 245
 246   /* debugger/db_disasm.c */
 247 extern void DEBUG_Disasm( DBG_ADDR *addr, int display );
 248
 249   /* debugger/dbg.y */
 250 extern BOOL DEBUG_Parser(void);
 251 extern void DEBUG_Exit( DWORD );
 252
 253   /* debugger/debug.l */
 254 extern void DEBUG_FlushSymbols(void);
 255
 256   /* debugger/display.c */
 257 extern int DEBUG_DoDisplay(void);
 258 extern int DEBUG_AddDisplay(struct expr * exp, int count, char format);
 259 extern int DEBUG_DoDisplay(void);
 260 extern int DEBUG_DelDisplay(int displaynum);
 261 extern int DEBUG_InfoDisplay(void);
 262
 263   /* debugger/editline.c */
 264 extern char * readline(const char *);
 265 extern void add_history(char *);
 266
 267   /* debugger/expr.c */
 268 extern void DEBUG_FreeExprMem(void);
 269 struct expr * DEBUG_IntVarExpr(const char* name);
 270 struct expr * DEBUG_SymbolExpr(const char * name);
 271 struct expr * DEBUG_ConstExpr(int val);
 272 struct expr * DEBUG_StringExpr(const char * str);
 273 struct expr * DEBUG_SegAddr(struct expr *, struct expr *);
 274 struct expr * DEBUG_USConstExpr(unsigned int val);
 275 struct expr * DEBUG_BinopExpr(int oper, struct expr *, struct expr *);
 276 struct expr * DEBUG_UnopExpr(int oper, struct expr *);
 277 struct expr * DEBUG_StructPExpr(struct expr *, const char * element);
 278 struct expr * DEBUG_StructExpr(struct expr *, const char * element);
 279 struct expr * DEBUG_ArrayExpr(struct expr *, struct expr * index);
 280 struct expr * DEBUG_CallExpr(const char *, int nargs, ...);
 281 struct expr * DEBUG_TypeCastExpr(struct datatype *, struct expr *);
 282 extern DBG_VALUE DEBUG_EvalExpr(struct expr *);
 283 extern int DEBUG_DelDisplay(int displaynum);
 284 extern struct expr * DEBUG_CloneExpr(const struct expr * exp);
 285 extern int DEBUG_FreeExpr(struct expr * exp);
 286 extern int DEBUG_DisplayExpr(const struct expr * exp);
 287
 288   /* debugger/hash.c */
 289 extern struct name_hash * DEBUG_AddSymbol( const char *name,
 290                                            const DBG_VALUE *addr,
 291                                            const char *sourcefile,
 292                                            int flags);
 293 extern BOOL DEBUG_GetSymbolValue( const char * name, const int lineno,
 294                                   DBG_VALUE *addr, int );
 295 extern BOOL DEBUG_SetSymbolValue( const char * name, const DBG_VALUE *addr );
 296 extern const char * DEBUG_FindNearestSymbol( const DBG_ADDR *addr, int flag,
 297                                              struct name_hash ** rtn,
 298                                              unsigned int ebp,
 299                                              struct list_id * source);
 300 extern void DEBUG_ReadSymbolTable( const char * filename );
 301 extern void DEBUG_AddLineNumber( struct name_hash * func, int line_num,
 302                                  unsigned long offset );
 303 extern struct wine_locals *
 304             DEBUG_AddLocal( struct name_hash * func, int regno,
 305                             int offset,
 306                             int pc_start,
 307                             int pc_end,
 308                             char * name);
 309 extern int DEBUG_CheckLinenoStatus(const DBG_ADDR *addr);
 310 extern void DEBUG_GetFuncInfo(struct list_id * ret, const char * file,
 311                               const char * func);
 312 extern int DEBUG_SetSymbolSize(struct name_hash * sym, unsigned int len);
 313 extern int DEBUG_SetSymbolBPOff(struct name_hash * sym, unsigned int len);
 314 extern int DEBUG_GetSymbolAddr(struct name_hash * sym, DBG_ADDR * addr);
 315 extern int DEBUG_cmp_sym(const void * p1, const void * p2);
 316 extern BOOL DEBUG_GetLineNumberAddr( struct name_hash *, const int lineno,
 317                                      DBG_ADDR *addr, int bp_flag );
 318
 319 extern int DEBUG_SetLocalSymbolType(struct wine_locals * sym,
 320                                     struct datatype * type);
 321 extern BOOL DEBUG_Normalize(struct name_hash * nh );
 322
 323   /* debugger/info.c */
 324 extern void DEBUG_PrintBasic( const DBG_VALUE* value, int count, char format );
 325 extern struct symbol_info DEBUG_PrintAddress( const DBG_ADDR *addr,
 326                                               int addrlen, int flag );
 327 extern void DEBUG_Help(void);
 328 extern void DEBUG_HelpInfo(void);
 329 extern struct symbol_info DEBUG_PrintAddressAndArgs( const DBG_ADDR *addr,
 330                                                      int addrlen,
 331                                                      unsigned int ebp,
 332                                                      int flag );
 333 extern void DEBUG_InfoClass(const char* clsName);
 334 extern void DEBUG_WalkClasses(void);
 335 extern void DEBUG_WalkModref(DWORD p);
 336 extern void DEBUG_DumpModule(DWORD mod);
 337 extern void DEBUG_WalkModules(void);
 338 extern void DEBUG_WalkProcess(void);
 339 extern void DEBUG_WalkThreads(void);
 340 extern void DEBUG_DumpQueue(DWORD q);
 341 extern void DEBUG_WalkQueues(void);
 342 extern void DEBUG_InfoSegments(DWORD s, int v);
 343 extern void DEBUG_InfoVirtual(void);
 344 extern void DEBUG_InfoWindow(HWND hWnd);
 345 extern void DEBUG_WalkWindows(HWND hWnd, int indent);
 346
 347   /* debugger/memory.c */
 348 extern int  DEBUG_ReadMemory( const DBG_VALUE* value );
 349 extern void DEBUG_WriteMemory( const DBG_VALUE* val, int value );
 350 extern void DEBUG_ExamineMemory( const DBG_VALUE *addr, int count, char format);
 351 extern void DEBUG_InvalAddr( const DBG_ADDR* addr );
 352 extern void DEBUG_InvalLinAddr( void* addr );
 353 extern DWORD DEBUG_ToLinear( const DBG_ADDR *address );
 354 extern void DEBUG_GetCurrentAddress( DBG_ADDR * );
 355 #ifdef __i386__
 356 extern void DEBUG_FixAddress( DBG_ADDR *address, DWORD def );
 357 extern BOOL DEBUG_FixSegment( DBG_ADDR* addr );
 358 extern int  DEBUG_GetSelectorType( WORD sel );
 359 extern int  DEBUG_IsSelectorSystem( WORD sel );
 360 #endif
 361
 362   /* debugger/module.c */
 363 extern int  DEBUG_LoadEntryPoints( const char * prefix );
 364 extern void DEBUG_LoadModule32( const char* name, HANDLE hFile, DWORD base );
 365 extern DBG_MODULE* DEBUG_AddModule(const char* name, int type,
 366                                    void* mod_addr, HMODULE hmod);
 367 extern DBG_MODULE* DEBUG_FindModuleByName(const char* name, int type);
 368 extern DBG_MODULE* DEBUG_FindModuleByHandle(HANDLE handle, int type);
 369 extern DBG_MODULE* DEBUG_GetProcessMainModule(DBG_PROCESS* process);
 370 extern DBG_MODULE* DEBUG_RegisterPEModule(HMODULE, u_long load_addr, const char* name);
 371 extern DBG_MODULE* DEBUG_RegisterELFModule(u_long load_addr, const char* name);
 372 extern void DEBUG_InfoShare(void);
 373
 374   /* debugger/msc.c */
 375 extern int DEBUG_RegisterMSCDebugInfo(DBG_MODULE* module, HANDLE hFile, void* nth, unsigned long nth_ofs);
 376 extern int DEBUG_RegisterStabsDebugInfo(DBG_MODULE* module, HANDLE hFile, void* nth, unsigned long nth_ofs);
 377 extern void DEBUG_InitCVDataTypes(void);
 378
 379   /* debugger/registers.c */
 380 extern void DEBUG_InfoRegisters(void);
 381 extern BOOL DEBUG_ValidateRegisters(void);
 382
 383   /* debugger/stack.c */
 384 extern void DEBUG_InfoStack(void);
 385 extern void DEBUG_BackTrace(BOOL noisy);
 386 extern int  DEBUG_InfoLocals(void);
 387 extern int  DEBUG_SetFrame(int newframe);
 388 extern int  DEBUG_GetCurrentFrame(struct name_hash ** name,
 389                                   unsigned int * eip,
 390                                   unsigned int * ebp);
 391
 392   /* debugger/stabs.c */
 393 extern int DEBUG_ReadExecutableDbgInfo(const char* exe_name);
 394 extern int DEBUG_ProcessElfObject(const char* filename, unsigned int load_offset);
 395 extern int DEBUG_ParseStabs(char * addr, unsigned int load_offset, unsigned int staboff,
 396                             int stablen, unsigned int strtaboff, int strtablen);
 397
 398   /* debugger/types.c */
 399 extern int DEBUG_nchar;
 400 extern void DEBUG_InitTypes(void);
 401 extern struct datatype * DEBUG_NewDataType(enum debug_type xtype,
 402                                            const char * typename);
 403 extern unsigned int DEBUG_TypeDerefPointer(const DBG_VALUE *value, struct datatype ** newtype);
 404 extern int DEBUG_AddStructElement(struct datatype * dt,
 405                                   char * name, struct datatype * type,
 406                                   int offset, int size);
 407 extern int DEBUG_SetStructSize(struct datatype * dt, int size);
 408 extern int DEBUG_SetPointerType(struct datatype * dt, struct datatype * dt2);
 409 extern int DEBUG_SetArrayParams(struct datatype * dt, int min, int max,
 410                                 struct datatype * dt2);
 411 extern void DEBUG_Print( const DBG_VALUE *addr, int count, char format, int level );
 412 extern unsigned int DEBUG_FindStructElement(DBG_VALUE * addr,
 413                                             const char * ele_name, int * tmpbuf);
 414 extern struct datatype * DEBUG_GetPointerType(struct datatype * dt);
 415 extern int DEBUG_GetObjectSize(struct datatype * dt);
 416 extern unsigned int DEBUG_ArrayIndex(const DBG_VALUE * addr, DBG_VALUE * result, int index);
 417 extern struct datatype * DEBUG_FindOrMakePointerType(struct datatype * reftype);
 418 extern long long int DEBUG_GetExprValue(const DBG_VALUE * addr, char ** format);
 419 extern int DEBUG_SetBitfieldParams(struct datatype * dt, int offset,
 420                                    int nbits, struct datatype * dt2);
 421 extern int DEBUG_CopyFieldlist(struct datatype * dt, struct datatype * dt2);
 422 extern enum debug_type DEBUG_GetType(struct datatype * dt);
 423 extern struct datatype * DEBUG_TypeCast(enum debug_type, const char *);
 424 extern int DEBUG_PrintTypeCast(const struct datatype *);
 425 extern int DEBUG_PrintType( const DBG_VALUE* addr );
 426
 427   /* debugger/source.c */
 428 extern void DEBUG_ShowDir(void);
 429 extern void DEBUG_AddPath(const char * path);
 430 extern void DEBUG_List(struct list_id * line1, struct list_id * line2,
 431                        int delta);
 432 extern void DEBUG_NukePath(void);
 433 extern void DEBUG_Disassemble( const DBG_VALUE *, const DBG_VALUE*, int offset );
 434
 435   /* debugger/winedbg.c */
 436 #define DBG_CHN_MESG    1
 437 #define DBG_CHN_ERR     2
 438 #define DBG_CHN_WARN    4
 439 #define DBG_CHN_FIXME   8
 440 #define DBG_CHN_TRACE   16
 441 extern void     DEBUG_Output(int chn, const char* buffer, int len);
 442 #ifdef __GNUC__
 443 extern int      DEBUG_Printf(int chn, const char* format, ...) __attribute__((format (printf,2,3)));
 444 #else
 445 extern int      DEBUG_Printf(int chn, const char* format, ...);
 446 #endif
 447 extern DBG_INTVAR*      DEBUG_GetIntVar(const char*);
 448 extern BOOL DEBUG_Attach(DWORD pid, BOOL cofe);
 449 extern void DEBUG_Run(const char* args);
 450 extern int curr_frame;
 451
 452 /* Choose your allocator! */
 453 #if 1
 454 /* this one is libc's fast one */
 455 extern void*    DEBUG_XMalloc(size_t size);
 456 extern void*    DEBUG_XReAlloc(void *ptr, size_t size);
 457 extern char*    DEBUG_XStrDup(const char *str);
 458
 459 #define DBG_alloc(x)            DEBUG_XMalloc(x)
 460 #define DBG_realloc(x,y)        DEBUG_XReAlloc(x,y)
 461 #define DBG_free(x)             free(x)
 462 #define DBG_strdup(x)           DEBUG_XStrDup(x)
 463 #else
 464 /* this one is slow (takes 5 minutes to load the debugger on my machine),
 465    but is pretty crash-proof (can step through malloc() without problems,
 466    malloc() arena (and other heaps) can be totally wasted and it'll still
 467    work, etc... if someone could make optimized routines so it wouldn't
 468    take so long to load, it could be made default) */
 469 #include "heap.h"
 470 #define DBG_alloc(x) HeapAlloc(dbg_heap,0,x)
 471 #define DBG_realloc(x,y) HeapRealloc(dbg_heap,0,x,y)
 472 #define DBG_free(x) HeapFree(dbg_heap,0,x)
 473 #define DBG_strdup(x) HEAP_strdupA(dbg_heap,0,x)
 474 #define DBG_need_heap
 475 extern HANDLE dbg_heap;
 476 #endif
 477
 478 #define DEBUG_STATUS_OFFSET             0x80003000
 479 #define DEBUG_STATUS_INTERNAL_ERROR     (DEBUG_STATUS_OFFSET+0)
 480 #define DEBUG_STATUS_NO_SYMBOL          (DEBUG_STATUS_OFFSET+1)
 481 #define DEBUG_STATUS_DIV_BY_ZERO        (DEBUG_STATUS_OFFSET+2)
 482 #define DEBUG_STATUS_BAD_TYPE           (DEBUG_STATUS_OFFSET+3)
 483
 484 extern DBG_INTVAR               DEBUG_IntVars[];
 485
 486 #define  DBG_IVARNAME(_var)     DEBUG_IV_##_var
 487 #define  DBG_IVARSTRUCT(_var)   DEBUG_IntVars[DBG_IVARNAME(_var)]
 488 #define  DBG_IVAR(_var)         (*(DBG_IVARSTRUCT(_var).pval))
 489 #define  INTERNAL_VAR(_var,_val,_ref,_typ) DBG_IVARNAME(_var),
 490 enum debug_int_var {
 491 #include "intvar.h"
 492    DBG_IV_LAST
 493 };
 494 #undef   INTERNAL_VAR
 495
 496 #endif  /* __WINE_DEBUGGER_H */