1 /*-------------------------------------------------------------------------
2 cmd.c - source file for debugger command execution
4 Written By - Sandeep Dutta . sandeep.dutta@usa.net (1999)
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 In other words, you are welcome to use, share and improve this program.
21 You are forbidden to forbid anyone else to use, share and improve
22 what you give them. Help stamp out software-hoarding!
23 -------------------------------------------------------------------------*/
32 /* default number of lines to list out */
34 static int listlines = LISTLINES;
36 /* mainly used to retain a reference to the active module being
37 listed. May be used as a general context for other commands if
38 no better context is available */
39 static module *list_mod = NULL;
41 EXTERN_STACK_DCL(callStack,function *,1024);
43 #if defined(__APPLE__) && defined(__MACH__)
45 {" GNU GENERAL PUBLIC LICENSE Version 2"};
46 static char *warranty=
50 " GNU GENERAL PUBLIC LICENSE\n"
51 " Version 2, June 1991\n"
53 " Copyright (C) 1989, 1991 Free Software Foundation, Inc.\n"
54 " 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA\n"
55 " Everyone is permitted to copy and distribute verbatim copies\n"
56 " of this license document, but changing it is not allowed.\n"
60 " The licenses for most software are designed to take away your\n"
61 "freedom to share and change it. By contrast, the GNU General Public\n"
62 "License is intended to guarantee your freedom to share and change free\n"
63 "software--to make sure the software is free for all its users. This\n"
64 "General Public License applies to most of the Free Software\n"
65 "Foundation's software and to any other program whose authors commit to\n"
66 "using it. (Some other Free Software Foundation software is covered by\n"
67 "the GNU Library General Public License instead.) You can apply it to\n"
68 "your programs, too.\n"
70 " When we speak of free software, we are referring to freedom, not\n"
71 "price. Our General Public Licenses are designed to make sure that you\n"
72 "have the freedom to distribute copies of free software (and charge for\n"
73 "this service if you wish), that you receive source code or can get it\n"
74 "if you want it, that you can change the software or use pieces of it\n"
75 "in new free programs; and that you know you can do these things.\n"
77 " To protect your rights, we need to make restrictions that forbid\n"
78 "anyone to deny you these rights or to ask you to surrender the rights.\n"
79 "These restrictions translate to certain responsibilities for you if you\n"
80 "distribute copies of the software, or if you modify it.\n"
82 " For example, if you distribute copies of such a program, whether\n"
83 "gratis or for a fee, you must give the recipients all the rights that\n"
84 "you have. You must make sure that they, too, receive or can get the\n"
85 "source code. And you must show them these terms so they know their\n"
88 " We protect your rights with two steps: (1) copyright the software, and\n"
89 "(2) offer you this license which gives you legal permission to copy,\n"
90 "distribute and/or modify the software.\n"
92 " Also, for each author's protection and ours, we want to make certain\n"
93 "that everyone understands that there is no warranty for this free\n"
94 "software. If the software is modified by someone else and passed on, we\n"
95 "want its recipients to know that what they have is not the original, so\n"
96 "that any problems introduced by others will not reflect on the original\n"
97 "authors' reputations.\n"
99 " Finally, any free program is threatened constantly by software\n"
100 "patents. We wish to avoid the danger that redistributors of a free\n"
101 "program will individually obtain patent licenses, in effect making the\n"
102 "program proprietary. To prevent this, we have made it clear that any\n"
103 "patent must be licensed for everyone's free use or not licensed at all.\n"
105 " The precise terms and conditions for copying, distribution and\n"
106 "modification follow.\n"
108 " GNU GENERAL PUBLIC LICENSE\n"
109 " TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n"
111 " 0. This License applies to any program or other work which contains\n"
112 "a notice placed by the copyright holder saying it may be distributed\n"
113 "under the terms of this General Public License. The \"Program\", below,\n"
114 "refers to any such program or work, and a \"work based on the Program\"\n"
115 "means either the Program or any derivative work under copyright law:\n"
116 "that is to say, a work containing the Program or a portion of it,\n"
117 "either verbatim or with modifications and/or translated into another\n"
118 "language. (Hereinafter, translation is included without limitation in\n"
119 "the term \"modification\".) Each licensee is addressed as \"you\".\n"
121 "Activities other than copying, distribution and modification are not\n"
122 "covered by this License; they are outside its scope. The act of\n"
123 "running the Program is not restricted, and the output from the Program\n"
124 "is covered only if its contents constitute a work based on the\n"
125 "Program (independent of having been made by running the Program).\n"
126 "Whether that is true depends on what the Program does.\n"
128 " 1. You may copy and distribute verbatim copies of the Program's\n"
129 "source code as you receive it, in any medium, provided that you\n"
130 "conspicuously and appropriately publish on each copy an appropriate\n"
131 "copyright notice and disclaimer of warranty; keep intact all the\n"
132 "notices that refer to this License and to the absence of any warranty;\n"
133 "and give any other recipients of the Program a copy of this License\n"
134 "along with the Program.\n"
136 "You may charge a fee for the physical act of transferring a copy, and\n"
137 "you may at your option offer warranty protection in exchange for a fee.\n"
139 " 2. You may modify your copy or copies of the Program or any portion\n"
140 "of it, thus forming a work based on the Program, and copy and\n"
141 "distribute such modifications or work under the terms of Section 1\n"
142 "above, provided that you also meet all of these conditions:\n"
144 " a) You must cause the modified files to carry prominent notices\n"
145 " stating that you changed the files and the date of any change.\n"
147 " b) You must cause any work that you distribute or publish, that in\n"
148 " whole or in part contains or is derived from the Program or any\n"
149 " part thereof, to be licensed as a whole at no charge to all third\n"
150 " parties under the terms of this License.\n"
152 " c) If the modified program normally reads commands interactively\n"
153 " when run, you must cause it, when started running for such\n"
154 " interactive use in the most ordinary way, to print or display an\n"
155 " announcement including an appropriate copyright notice and a\n"
156 " notice that there is no warranty (or else, saying that you provide\n"
157 " a warranty) and that users may redistribute the program under\n"
158 " these conditions, and telling the user how to view a copy of this\n"
159 " License. (Exception: if the Program itself is interactive but\n"
160 " does not normally print such an announcement, your work based on\n"
161 " the Program is not required to print an announcement.)\n"
163 "These requirements apply to the modified work as a whole. If\n"
164 "identifiable sections of that work are not derived from the Program,\n"
165 "and can be reasonably considered independent and separate works in\n"
166 "themselves, then this License, and its terms, do not apply to those\n"
167 "sections when you distribute them as separate works. But when you\n"
168 "distribute the same sections as part of a whole which is a work based\n"
169 "on the Program, the distribution of the whole must be on the terms of\n"
170 "this License, whose permissions for other licensees extend to the\n"
171 "entire whole, and thus to each and every part regardless of who wrote it.\n"
173 "Thus, it is not the intent of this section to claim rights or contest\n"
174 "your rights to work written entirely by you; rather, the intent is to\n"
175 "exercise the right to control the distribution of derivative or\n"
176 "collective works based on the Program.\n"
178 "In addition, mere aggregation of another work not based on the Program\n"
179 "with the Program (or with a work based on the Program) on a volume of\n"
180 "a storage or distribution medium does not bring the other work under\n"
181 "the scope of this License.\n"
183 " 3. You may copy and distribute the Program (or a work based on it,\n"
184 "under Section 2) in object code or executable form under the terms of\n"
185 "Sections 1 and 2 above provided that you also do one of the following:\n"
187 " a) Accompany it with the complete corresponding machine-readable\n"
188 " source code, which must be distributed under the terms of Sections\n"
189 " 1 and 2 above on a medium customarily used for software interchange; or,\n"
191 " b) Accompany it with a written offer, valid for at least three\n"
192 " years, to give any third party, for a charge no more than your\n"
193 " cost of physically performing source distribution, a complete\n"
194 " machine-readable copy of the corresponding source code, to be\n"
195 " distributed under the terms of Sections 1 and 2 above on a medium\n"
196 " customarily used for software interchange; or,\n"
198 " c) Accompany it with the information you received as to the offer\n"
199 " to distribute corresponding source code. (This alternative is\n"
200 " allowed only for noncommercial distribution and only if you\n"
201 " received the program in object code or executable form with such\n"
202 " an offer, in accord with Subsection b above.)\n"
204 "The source code for a work means the preferred form of the work for\n"
205 "making modifications to it. For an executable work, complete source\n"
206 "code means all the source code for all modules it contains, plus any\n"
207 "associated interface definition files, plus the scripts used to\n"
208 "control compilation and installation of the executable. However, as a\n"
209 "special exception, the source code distributed need not include\n"
210 "anything that is normally distributed (in either source or binary\n"
211 "form) with the major components (compiler, kernel, and so on) of the\n"
212 "operating system on which the executable runs, unless that component\n"
213 "itself accompanies the executable.\n"
215 "If distribution of executable or object code is made by offering\n"
216 "access to copy from a designated place, then offering equivalent\n"
217 "access to copy the source code from the same place counts as\n"
218 "distribution of the source code, even though third parties are not\n"
219 "compelled to copy the source along with the object code.\n"
221 " 4. You may not copy, modify, sublicense, or distribute the Program\n"
222 "except as expressly provided under this License. Any attempt\n"
223 "otherwise to copy, modify, sublicense or distribute the Program is\n"
224 "void, and will automatically terminate your rights under this License.\n"
225 "However, parties who have received copies, or rights, from you under\n"
226 "this License will not have their licenses terminated so long as such\n"
227 "parties remain in full compliance.\n"
229 " 5. You are not required to accept this License, since you have not\n"
230 "signed it. However, nothing else grants you permission to modify or\n"
231 "distribute the Program or its derivative works. These actions are\n"
232 "prohibited by law if you do not accept this License. Therefore, by\n"
233 "modifying or distributing the Program (or any work based on the\n"
234 "Program), you indicate your acceptance of this License to do so, and\n"
235 "all its terms and conditions for copying, distributing or modifying\n"
236 "the Program or works based on it.\n"
238 " 6. Each time you redistribute the Program (or any work based on the\n"
239 "Program), the recipient automatically receives a license from the\n"
240 "original licensor to copy, distribute or modify the Program subject to\n"
241 "these terms and conditions. You may not impose any further\n"
242 "restrictions on the recipients' exercise of the rights granted herein.\n"
243 "You are not responsible for enforcing compliance by third parties to\n"
246 " 7. If, as a consequence of a court judgment or allegation of patent\n"
247 "infringement or for any other reason (not limited to patent issues),\n"
248 "conditions are imposed on you (whether by court order, agreement or\n"
249 "otherwise) that contradict the conditions of this License, they do not\n"
250 "excuse you from the conditions of this License. If you cannot\n"
251 "distribute so as to satisfy simultaneously your obligations under this\n"
252 "License and any other pertinent obligations, then as a consequence you\n"
253 "may not distribute the Program at all. For example, if a patent\n"
254 "license would not permit royalty-free redistribution of the Program by\n"
255 "all those who receive copies directly or indirectly through you, then\n"
256 "the only way you could satisfy both it and this License would be to\n"
257 "refrain entirely from distribution of the Program.\n"
259 "If any portion of this section is held invalid or unenforceable under\n"
260 "any particular circumstance, the balance of the section is intended to\n"
261 "apply and the section as a whole is intended to apply in other\n"
264 "It is not the purpose of this section to induce you to infringe any\n"
265 "patents or other property right claims or to contest validity of any\n"
266 "such claims; this section has the sole purpose of protecting the\n"
267 "integrity of the free software distribution system, which is\n"
268 "implemented by public license practices. Many people have made\n"
269 "generous contributions to the wide range of software distributed\n"
270 "through that system in reliance on consistent application of that\n"
271 "system; it is up to the author/donor to decide if he or she is willing\n"
272 "to distribute software through any other system and a licensee cannot\n"
273 "impose that choice.\n"
275 "This section is intended to make thoroughly clear what is believed to\n"
276 "be a consequence of the rest of this License.\n"
278 " 8. If the distribution and/or use of the Program is restricted in\n"
279 "certain countries either by patents or by copyrighted interfaces, the\n"
280 "original copyright holder who places the Program under this License\n"
281 "may add an explicit geographical distribution limitation excluding\n"
282 "those countries, so that distribution is permitted only in or among\n"
283 "countries not thus excluded. In such case, this License incorporates\n"
284 "the limitation as if written in the body of this License.\n"
286 " 9. The Free Software Foundation may publish revised and/or new versions\n"
287 "of the General Public License from time to time. Such new versions will\n"
288 "be similar in spirit to the present version, but may differ in detail to\n"
289 "address new problems or concerns.\n"
291 "Each version is given a distinguishing version number. If the Program\n"
292 "specifies a version number of this License which applies to it and \"any\n"
293 "later version\", you have the option of following the terms and conditions\n"
294 "either of that version or of any later version published by the Free\n"
295 "Software Foundation. If the Program does not specify a version number of\n"
296 "this License, you may choose any version ever published by the Free Software\n"
299 " 10. If you wish to incorporate parts of the Program into other free\n"
300 "programs whose distribution conditions are different, write to the author\n"
301 "to ask for permission. For software which is copyrighted by the Free\n"
302 "Software Foundation, write to the Free Software Foundation; we sometimes\n"
303 "make exceptions for this. Our decision will be guided by the two goals\n"
304 "of preserving the free status of all derivatives of our free software and\n"
305 "of promoting the sharing and reuse of software generally.\n";
307 static char *warranty=
310 " 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\n"
311 "FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN\n"
312 "OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\n"
313 "PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\n"
314 "OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n"
315 "MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS\n"
316 "TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE\n"
317 "PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\n"
318 "REPAIR OR CORRECTION.\n"
320 " 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\n"
321 "WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\n"
322 "REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\n"
323 "INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\n"
324 "OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\n"
325 "TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\n"
326 "YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\n"
327 "PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n"
328 "POSSIBILITY OF SUCH DAMAGES.\n";
331 static void printTypeInfo(link *);
332 static void printValAggregates (symbol *,link *,char,unsigned int,int);
333 static int printOrSetSymValue (symbol *sym, context *cctxt,
334 int flg, int dnum, int fmt,
335 char *rs, char *val, char cmp);
337 int srcMode = SRC_CMODE ;
338 static set *dispsymbols = NULL ; /* set of displayable symbols */
339 static int currentFrame = 0; /* actual displayed frame */
340 /*-----------------------------------------------------------------*/
341 /* funcWithName - returns function with name */
342 /*-----------------------------------------------------------------*/
343 DEFSETFUNC(funcWithName)
345 function *func = item;
347 V_ARG(function **,funcp);
352 if (strcmp(func->sym->name,name) == 0) {
360 /*-----------------------------------------------------------------*/
361 /* symWithAddr - look for symbol with sfr / sbit address */
362 /*-----------------------------------------------------------------*/
363 DEFSETFUNC(symWithAddr)
366 V_ARG(unsigned long,laddr);
367 V_ARG(int ,laddrspace);
368 V_ARG(symbol **,rsym);
373 if ( sym->addr == laddr &&
374 sym->addrspace == laddrspace )
383 /*-----------------------------------------------------------------*/
384 /* setBPatModLine - set break point at the line specified for the */
385 /*-----------------------------------------------------------------*/
386 static void setBPatModLine (module *mod, int line, char bpType )
390 /* look for the first executable line after the line
391 specified & get the break point there */
392 if (srcMode == SRC_CMODE && line > mod->ncLines) {
393 fprintf(stderr,"No line %d in file \"%s\".\n",
398 if (srcMode == SRC_AMODE && line > mod->nasmLines) {
399 fprintf(stderr,"No line %d in file \"%s\".\n",
405 for ( ; next_line < (srcMode == SRC_CMODE ? mod->ncLines : mod->nasmLines ) ;
407 if (srcMode == SRC_CMODE) {
408 if (mod->cLines[next_line]->addr) {
409 setBreakPoint (mod->cLines[next_line]->addr, CODE, bpType,
410 userBpCB, mod->c_name, next_line);
416 if (mod->asmLines[next_line]->addr) {
417 setBreakPoint (mod->asmLines[next_line]->addr, CODE, bpType,
418 userBpCB, mod->asm_name, next_line);
425 fprintf(stderr,"No line %d or after in file \"%s\"..\n",
431 /*-----------------------------------------------------------------*/
432 /* clearBPatModLine - clr break point at the line specified */
433 /*-----------------------------------------------------------------*/
434 static void clearBPatModLine (module *mod, int line)
436 /* look for the first executable line after the line
437 specified & get the break point there */
438 if (srcMode == SRC_CMODE && line > mod->ncLines) {
439 fprintf(stderr,"No line %d in file \"%s\".\n",
444 if (srcMode == SRC_AMODE && line > mod->ncLines) {
445 fprintf(stderr,"No line %d in file \"%s\".\n",
450 for ( ; line < (srcMode == SRC_CMODE ? mod->ncLines : mod->nasmLines ) ;
452 if (srcMode == SRC_CMODE)
453 if (mod->cLines[line]->addr) {
454 clearUSERbp (mod->cLines[line]->addr);
458 if (mod->asmLines[line]->addr) {
459 clearUSERbp (mod->asmLines[line]->addr);
467 /*-----------------------------------------------------------------*/
468 /* moduleLineWithAddr - finds and returns a line with a given address */
469 /*-----------------------------------------------------------------*/
470 DEFSETFUNC(moduleLineWithAddr)
475 V_ARG(unsigned int,addr);
476 V_ARG(module **,rmod);
482 for (i=0; i < mod->nasmLines; i++ )
484 if ( mod->asmLines[i]->addr == addr)
490 for ( i=0; i < mod->ncLines; i++ )
492 if ( mod->cLines[i]->addr > addr)
504 /*-----------------------------------------------------------------*/
505 /* funcWithNameModule - returns functions with a name module combo */
506 /*-----------------------------------------------------------------*/
507 DEFSETFUNC(funcWithNameModule)
509 function *func = item;
512 V_ARG(function **,funcp);
517 if (strcmp(func->sym->name,fname) == 0 &&
518 strcmp(func->mod->c_name,mname) == 0) {
526 /*-----------------------------------------------------------------*/
527 /* funcInAddr - given an address returns the function */
528 /*-----------------------------------------------------------------*/
529 DEFSETFUNC(funcInAddr)
531 function *func = item;
532 V_ARG(unsigned int,addr);
533 V_ARG(function **,funcp);
538 /* in the address range */
539 if (func->sym->addr <= addr &&
540 func->sym->eaddr >= addr) {
549 /*-----------------------------------------------------------------*/
550 /* setStepBp - will set STEP Bp @ function entry points */
551 /*-----------------------------------------------------------------*/
552 DEFSETFUNC(setStepBp)
554 function *func = item;
556 if (func->sym && func->sym->addr ) {
558 /* set the entry break point */
559 setBreakPoint (func->sym->addr , CODE , STEP ,
560 stepBpCB ,func->mod->c_name , func->entryline);
568 /*-----------------------------------------------------------------*/
569 /* setStepEPBp - sets a given type of bp @ the execution point */
570 /*-----------------------------------------------------------------*/
571 DEFSETFUNC(setStepEPBp)
577 setBreakPoint (ep->addr, CODE, bptype,
578 stepBpCB, mname, ep->line);
582 /*-----------------------------------------------------------------*/
583 /* setNextEPBp - sets a given type of bp @ the execution point */
584 /*-----------------------------------------------------------------*/
585 DEFSETFUNC(setNextEPBp)
591 setBreakPoint (ep->addr, CODE, bptype,
592 nextBpCB, mname, ep->line);
596 /*-----------------------------------------------------------------*/
597 /* lineAtAddr - for execution points returns the one with addr */
598 /*-----------------------------------------------------------------*/
599 DEFSETFUNC(lineAtAddr)
602 V_ARG(unsigned int,addr);
607 /* address must be an exact match */
608 if (ep->addr == addr) {
621 /*-----------------------------------------------------------------*/
622 /* lineNearAddr - for execution points returns the one with addr */
623 /*-----------------------------------------------------------------*/
624 DEFSETFUNC(lineNearAddr)
627 V_ARG(unsigned int,addr);
632 /* the line in which the address is */
633 if (ep->addr <= addr) {
646 /*-----------------------------------------------------------------*/
647 /* discoverContext - find out the current context of the bp */
648 /*-----------------------------------------------------------------*/
649 context *discoverContext (unsigned addr, function *func)
654 /* find the function we are in */
655 if (!func && !applyToSet(functions,funcInAddr,addr,&func)) {
656 if (!applyToSet(functions,funcWithName,"main",&func) ||
657 !applyToSet(modules,moduleLineWithAddr,addr,&mod,NULL))
659 fprintf(stderr, "Error?:discoverContext: cannot apply addr 0x%x\n",addr);
662 currCtxt->func = func;
663 currCtxt->addr = addr;
664 currCtxt->modName = mod->name;
665 currCtxt->cline = func->exitline;
669 currCtxt->func = func;
670 currCtxt->addr = func->laddr = addr;
671 currCtxt->modName = func->modName;
673 /* find the c line number */
674 if(applyToSet(func->cfpoints,lineAtAddr,addr,
675 &line,&currCtxt->block,&currCtxt->level))
676 currCtxt->cline = func->lline = line;
677 else if(applyToSet(func->cfpoints,lineNearAddr,addr,
678 &line,&currCtxt->block,&currCtxt->level))
679 currCtxt->cline = func->lline = line;
681 currCtxt->cline = func->exitline;
683 /* find the asm line number */
685 if (applyToSet(func->afpoints,lineAtAddr,addr,
687 currCtxt->asmline = line;
689 currCtxt->asmline = -1;
695 /*-----------------------------------------------------------------*/
696 /* simGo - send 'go' cmd to simulator and wait till a break occurs */
697 /*-----------------------------------------------------------------*/
698 void simGo (unsigned int gaddr)
710 addr = simGoTillBp (gaddr);
712 /* got the pc for the break point now first
713 discover the program context i.e. module, function
714 linenumber of the source etc, etc etc */
716 ctxt = discoverContext (addr, NULL);
718 /* dispatch all the break point call back functions */
719 rv = dispatchCB (addr,ctxt);
722 /* the dispatch call back function will return
723 non-zero if an user break point has been hit
724 if not then we continue with the execution
730 if ( gaddr == -1 || doingSteps == 1 )
736 /*-----------------------------------------------------------------*/
737 /* preparePrint - common parse function for */
738 /* output, print and display */
739 /*-----------------------------------------------------------------*/
740 static char *preparePrint(char *s, context *cctxt, int *fmt, symbol **sym)
742 char *bp = s+strlen(s) -1;
748 while (isspace(*s)) s++;
752 while (isspace(*bp)) bp--;
758 /* format of printout */
776 while (isspace(*s)) s++;
778 for ( bp = s; *bp && ( isalnum( *bp ) || *bp == '_'); bp++ );
783 *sym = symLookup(s,cctxt);
787 fprintf(stdout,"No symbol \"%s\" in current context.\n", s);
791 static int printAsmLine( function *func, module *m, long saddr, long eaddr)
795 int lastaddr = saddr+1;
800 symaddr = func->sym->addr;
801 symname = func->sym->name;
808 for (j=0,i=0; i < m->nasmLines; i++ )
810 if ( saddr >= 0 && m->asmLines[i]->addr < saddr)
814 if ( eaddr >= 0 && m->asmLines[i]->addr > eaddr)
819 (m->asmLines[i]->addr < func->sym->addr ||
820 m->asmLines[i]->addr > func->sym->eaddr ))
824 delta = m->asmLines[i]->addr - symaddr;
828 lastaddr = m->asmLines[i]->addr;
829 printf("0x%08x <%s",lastaddr,symname);
830 if (delta > 0) printf("+%d",delta);
831 printf(">:\t%s",m->asmLines[i]->src);
837 /*-----------------------------------------------------------------*/
838 /* cmdDisasm - disassemble asm instruction */
839 /*-----------------------------------------------------------------*/
840 static int cmdDisasm (char *s, context *cctxt, int args)
842 function *func = NULL;
847 /* white space skip */
851 while (*s && isspace(*s)) s++;
855 saddr = strtol(s,&s,0);
858 while (*s && isspace(*s)) s++;
861 eaddr = strtol(s,0,0);
870 /* no start or only start so dump function */
877 applyToSet(functions,funcInAddr,saddr,&func);
881 printf("Dump of assembler code for function %s:\n",func->sym->name);
882 printAsmLine(func,func->mod,-1,-1);
883 printf("End of assembler dump.\n");
888 if (applyToSet(modules,moduleLineWithAddr,saddr,&modul,NULL))
891 printf("Dump of assembler code:\n");
892 printAsmLine(NULL,modul,saddr,eaddr);
893 printf("End of assembler dump.\n");
901 printf("Dump of assembler code from 0x%08x to 0x%08x:\n",saddr,eaddr);
903 while ( saddr < eaddr )
906 if (applyToSet(functions,funcInAddr,saddr,&func))
915 if (!applyToSet(modules,moduleLineWithAddr,saddr,&modul,NULL))
918 saddr = printAsmLine(func,modul,saddr,eaddr) + 1;
923 printf("End of assembler dump.\n");
928 fprintf(stderr,"No function contains specified address.\n");
931 /*-----------------------------------------------------------------*/
932 /* cmdDisasm1 - disassemble one asm instruction */
933 /*-----------------------------------------------------------------*/
934 int cmdDisasm1 (char *s, context *cctxt)
936 return cmdDisasm( s, cctxt, 1);
939 /*-----------------------------------------------------------------*/
940 /* cmdDisasmF - disassemble asm instructions */
941 /*-----------------------------------------------------------------*/
942 int cmdDisasmF(char *s, context *cctxt)
944 return cmdDisasm( s, cctxt, 2);
947 static int commonSetUserBp(char *s, context *cctxt, char bpType)
950 function *func = NULL;
952 /* user break point location specification can be of the following
954 a) <nothing> - break point at current location
955 b) lineno - number of the current module
956 c) filename:lineno - line number of the given file
957 e) filename:function- function X in file Y (useful for static functions)
958 f) function - function entry point
959 g) *addr - break point at address
963 fprintf(stdout,"No symbol table is loaded. Use the \"file\" command.\n");
966 /* white space skip */
967 while (*s && isspace(*s)) s++;
969 /* null terminate it after stripping trailing blanks*/
971 while (bp != s && isspace(*bp)) bp--;
974 /* case a) nothing */
975 /* if nothing given then current location : we know
976 the current execution location from the currentContext */
979 /* if current context is known */
981 if (srcMode == SRC_CMODE)
982 /* set the break point */
983 setBreakPoint ( cctxt->addr , CODE , bpType , userBpCB ,
984 cctxt->func->mod->c_name, cctxt->cline);
986 setBreakPoint ( cctxt->addr , CODE , bpType , userBpCB ,
987 cctxt->func->mod->asm_name, cctxt->asmline);
991 fprintf(stderr,"No default breakpoint address now.\n");
996 if ( *s == '*' && isdigit(*(s+1)))
999 long braddr = strtol(s+1,0,0);
1000 if (!applyToSet(functions,funcInAddr,braddr,&func))
1003 if (!applyToSet(modules,moduleLineWithAddr,braddr,&modul,&line))
1005 fprintf(stderr,"Address 0x%08x not exists in code.\n",braddr);
1009 setBreakPoint ( braddr , CODE , bpType , userBpCB ,
1010 modul->c_name,line);
1016 int line = func->exitline;
1017 if ( !applyToSet(func->cfpoints,lineAtAddr,braddr,
1019 applyToSet(func->cfpoints,lineNearAddr,braddr,&line,NULL,NULL);
1020 setBreakPoint ( braddr , CODE , bpType , userBpCB ,
1021 func->mod->c_name,line);
1025 /* case b) lineno */
1026 /* check if line number */
1028 /* get the lineno */
1029 int line = atoi(s) -1;
1031 /* if current context not present then we must get the module
1032 which has main & set the break point @ line number provided
1033 of that module : if current context known then set the bp
1034 at the line number given for the current module
1037 if (!cctxt->func->mod) {
1038 if (!applyToSet(functions,funcWithName,"main"))
1039 fprintf(stderr,"Function \"main\" not defined.\n");
1041 setBPatModLine(func->mod,line, bpType);
1043 setBPatModLine(cctxt->func->mod,line, bpType);
1046 setBPatModLine(list_mod,line, bpType);
1048 fprintf(stdout,"Sdcdb fails to have module symbol context at %d\n", __LINE__);
1055 if ((bp = strchr(s,':'))) {
1060 if (srcMode == SRC_CMODE) {
1061 if (!applyToSet(modules,moduleWithCName,s,&mod)) {
1062 fprintf (stderr,"No source file named %s.\n",s);
1066 if (!applyToSet(modules,moduleWithAsmName,s,&mod)) {
1067 fprintf (stderr,"No source file named %s.\n",s);
1072 /* case c) filename:lineno */
1073 if (isdigit(*(bp +1))) {
1075 setBPatModLine (mod,atoi(bp+1)-1,bpType);
1079 /* case d) filename:function */
1080 if (!applyToSet(functions,funcWithNameModule,bp+1,s,&func))
1081 fprintf(stderr,"Function \"%s\" not defined.\n",bp+1);
1083 setBPatModLine (mod,
1084 (srcMode == SRC_CMODE ?
1086 func->aentryline),bpType);
1091 /* case e) function */
1092 if (!applyToSet(functions,funcWithName,s,&func))
1093 fprintf(stderr,"Function \"%s\" not defined.\n",s);
1095 setBPatModLine(func->mod,
1096 (srcMode == SRC_CMODE ?
1098 func->aentryline),bpType);
1104 /*-----------------------------------------------------------------*/
1105 /* cmdSetTmpUserBp - settempory break point at the user specified location */
1106 /*-----------------------------------------------------------------*/
1107 int cmdSetTmpUserBp (char *s, context *cctxt)
1109 return commonSetUserBp(s, cctxt, TMPUSER );
1112 /*-----------------------------------------------------------------*/
1113 /* cmdSetUserBp - set break point at the user specified location */
1114 /*-----------------------------------------------------------------*/
1115 int cmdSetUserBp (char *s, context *cctxt)
1117 return commonSetUserBp(s, cctxt, USER );
1120 /*-----------------------------------------------------------------*/
1121 /* cmdJump - set program counter */
1122 /*-----------------------------------------------------------------*/
1123 int cmdJump (char *s, context *cctxt)
1126 function *func = NULL;
1127 if (STACK_EMPTY(callStack))
1129 fprintf(stdout,"The program is not running.\n");
1133 /* white space skip */
1134 while (*s && isspace(*s)) s++;
1136 /* null terminate it after stripping trailing blanks*/
1138 while (bp != s && isspace(*bp)) bp--;
1142 fprintf(stdout,"No argument: need line or *addr.\n");
1145 if ( *s == '*' && isdigit(*(s+1)))
1147 unsigned int addr = atoi(s);
1148 if (cctxt && cctxt->func &&
1149 cctxt->func->sym->addr <= addr &&
1150 cctxt->func->sym->eaddr >= addr)
1155 fprintf(stdout,"Warning addr 0x%x outside actual function.\n",addr);
1161 /* get the lineno */
1162 int line = atoi(s) -1;
1163 if (!cctxt || !cctxt->func || !cctxt->func->mod)
1165 fprintf(stderr,"Function not defined.\n");
1168 if (line >= cctxt->func->entryline &&
1169 line <= cctxt->func->exitline )
1171 simSetPC(cctxt->func->mod->cLines[line]->addr);
1174 if (line >= cctxt->func->mod->ncLines )
1176 fprintf(stderr,"line not in module.\n");
1179 fprintf(stdout,"Warning line %d outside actual function.\n",line+1);
1180 simSetPC(cctxt->func->mod->cLines[line]->addr);
1183 if ((bp = strchr(s,':')))
1188 if (!applyToSet(modules,moduleWithCName,s,&mod))
1190 fprintf (stderr,"No source file named %s.\n",s);
1195 fprintf (stderr,"No line number.\n");
1199 if (line >= mod->ncLines )
1201 fprintf(stderr,"line not in module.\n");
1204 if ( mod != cctxt->func->mod ||
1205 line < cctxt->func->entryline ||
1206 line > cctxt->func->exitline )
1208 fprintf(stdout,"Warning line %d outside actual function.\n",
1211 simSetPC(mod->cLines[line]->addr);
1216 /*-----------------------------------------------------------------*/
1217 /* cmdListAsm - list assembler source code */
1218 /*-----------------------------------------------------------------*/
1219 int cmdListAsm (char *s, context *cctxt)
1221 if ( cctxt && cctxt->func)
1224 if (printAsmLine(cctxt->func,cctxt->func->mod,
1225 (long)cctxt->addr,(long)cctxt->addr))
1231 /*-----------------------------------------------------------------*/
1232 /* cmdSetOption - set debugger options */
1233 /*-----------------------------------------------------------------*/
1234 int cmdSetOption (char *s, context *cctxt)
1236 while (*s && isspace(*s)) s++;
1237 if (strncmp(s,"srcmode",7) == 0 ) {
1238 if (srcMode == SRC_CMODE)
1239 srcMode = SRC_AMODE;
1241 srcMode = SRC_CMODE;
1242 fprintf(stderr,"source mode set to '%s'\n",
1243 (srcMode == SRC_CMODE ? "C" : "asm"));
1247 if (strncmp(s,"listsize ",9) == 0)
1249 listlines = strtol(s+9,0,0);
1250 if ( listlines < LISTLINES )
1251 listlines = LISTLINES;
1256 if (strncmp(s,"debug ",6) == 0)
1258 sdcdbDebug = strtol(s+6,0,0);
1262 if (strncmp(s,"variable ",9) == 0)
1268 if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
1271 while (*s && *s != '=') s++;
1273 while (isspace(*s)) *s++ = '\0';
1276 printOrSetSymValue(sym,cctxt,0,0,0,rs,s,'\0');
1280 fprintf(stdout,"No new value for \"%s\".\n",s);
1285 fprintf(stderr,"'set %s' command not yet implemented\n",s);
1289 /*-----------------------------------------------------------------*/
1290 /* cmdContinue - continue till next break point */
1291 /*-----------------------------------------------------------------*/
1292 int cmdContinue (char *s, context *cctxt)
1294 if (STACK_EMPTY(callStack)) {
1295 fprintf(stdout,"The program is not being run.\n");
1299 fprintf(stdout,"Continuing.\n");
1305 /*-----------------------------------------------------------------*/
1306 /* cmdIgnore - set ignorecount for breakpoint */
1307 /*-----------------------------------------------------------------*/
1308 int cmdIgnore (char *s, context *cctxt)
1311 while (isspace(*s)) s++;
1314 fprintf(stdout,"Argument required (breakpoint number).\n");
1317 bpnum = strtol(s,&s,10);
1318 while (isspace(*s)) s++;
1321 fprintf(stdout,"Second argument (specified ignore-count) is missing.");
1324 cnt = strtol(s,0,10);
1325 setUserbpIgnCount(bpnum,cnt);
1329 /*-----------------------------------------------------------------*/
1330 /* cmdCondition - set condition for breakpoint */
1331 /*-----------------------------------------------------------------*/
1332 int cmdCondition (char *s, context *cctxt)
1335 while (isspace(*s)) s++;
1338 fprintf(stdout,"Argument required (breakpoint number).\n");
1341 bpnum = strtol(s,&s,10);
1342 while (isspace(*s)) s++;
1347 setUserbpCondition(bpnum,s);
1351 /*-----------------------------------------------------------------*/
1352 /* cmdCommands - set commands for breakpoint */
1353 /*-----------------------------------------------------------------*/
1354 int cmdCommands (char *s, context *cctxt)
1358 while (isspace(*s)) s++;
1361 bpnum = getLastBreakptNumber();
1363 bpnum = strtol(s,0,10);
1366 while ((line = getNextCmdLine()))
1368 while (isspace(*line)) line++;
1369 if (!strncmp(line,"end",3))
1373 cmds = Safe_strdup(line);
1377 cmds = Safe_realloc( cmds, strlen(cmds) + 1 + strlen(line));
1381 setUserbpCommand(bpnum,cmds);
1385 /*-----------------------------------------------------------------*/
1386 /* cmdDelUserBp - delete user break point */
1387 /*-----------------------------------------------------------------*/
1388 int cmdDelUserBp (char *s, context *cctxt)
1391 while (isspace(*s)) s++;
1394 if (userBpPresent) {
1396 fprintf (stdout,"Delete all breakpoints? (y or n) ");
1398 fgets(buffer,sizeof(buffer),stdin);
1399 if (toupper(buffer[0]) == 'Y')
1405 /* determine the break point number */
1406 if (sscanf(s,"%d",&bpnum) == 1)
1407 deleteUSERbp(bpnum);
1412 /*-----------------------------------------------------------------*/
1413 /* cmdStepi - single step exactly one instruction */
1414 /*-----------------------------------------------------------------*/
1415 int cmdStepi (char *s, context *cctxt)
1418 if (STACK_EMPTY(callStack))
1419 fprintf(stdout,"The program is not being run.\n");
1430 /*-----------------------------------------------------------------*/
1431 /* cmdStep - single step thru C source file */
1432 /*-----------------------------------------------------------------*/
1433 int cmdStep (char *s, context *cctxt)
1435 function *func = NULL;
1437 if (STACK_EMPTY(callStack))
1438 fprintf(stdout,"The program is not being run.\n");
1440 /* if we are @ the end of a function then set
1441 break points at execution points of the
1442 function in the call stack... */
1443 if (cctxt->addr == cctxt->func->sym->eaddr) {
1444 if ((func = STACK_PEEK(callStack))) {
1445 if (srcMode == SRC_CMODE)
1446 applyToSet (func->cfpoints,setStepEPBp,STEP,
1449 applyToSet (func->afpoints,setStepEPBp,STEP,
1450 func->mod->asm_name);
1453 /* set breakpoints at all function entry points
1454 and all exepoints of this functions & for
1455 all functions one up in the call stack */
1457 /* all function entry points */
1458 applyToSet(functions,setStepBp);
1460 if (srcMode == SRC_CMODE) {
1461 /* for all execution points in this function */
1462 applyToSet(cctxt->func->cfpoints,setStepEPBp,STEP,
1463 cctxt->func->mod->c_name);
1465 /* set a break point @ the current function's
1467 setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP ,
1468 stepBpCB, cctxt->func->mod->c_name,
1469 cctxt->func->exitline);
1471 /* now break point @ callers execution points */
1472 if ((func = STACK_PPEEK(callStack))) {
1473 applyToSet (func->cfpoints,setStepEPBp,STEP,
1475 /* set bp @ callers exit point */
1476 setBreakPoint (func->sym->eaddr, CODE, STEP ,
1477 stepBpCB, func->mod->c_name,
1481 /* for all execution points in this function */
1482 applyToSet(cctxt->func->afpoints,setStepEPBp,STEP,
1483 cctxt->func->mod->asm_name);
1485 /* set a break point @ the current function's
1487 setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP ,
1488 stepBpCB, cctxt->func->mod->asm_name,
1489 cctxt->func->aexitline);
1491 /* now break point @ callers execution points */
1492 if ((func = STACK_PPEEK(callStack))) {
1494 applyToSet (func->afpoints,setStepEPBp,STEP,
1495 func->mod->asm_name);
1497 /* set bp @ callers exit point */
1498 setBreakPoint (func->sym->eaddr, CODE, STEP ,
1499 stepBpCB, func->mod->asm_name,
1513 /*-----------------------------------------------------------------*/
1514 /* cmdNexti - next instruction but proceed function call */
1515 /*-----------------------------------------------------------------*/
1516 int cmdNexti (char *s, context *cctxt)
1518 if (STACK_EMPTY(callStack))
1519 fprintf(stdout,"The program is not being run.\n");
1530 /*-----------------------------------------------------------------*/
1531 /* cmdNext - next executable C statement file */
1532 /*-----------------------------------------------------------------*/
1533 int cmdNext (char *s, context *cctxt)
1535 function *func = NULL;
1536 /* next is almost the same as step except we don't
1537 we don't set break point for all function entry
1539 if (STACK_EMPTY(callStack))
1540 fprintf(stdout,"The program is not being run.\n");
1542 /* if we are @ the end of a function then set
1543 break points at execution points of the
1544 function in the call stack... */
1545 if (cctxt->addr == cctxt->func->sym->eaddr) {
1546 if ((func = STACK_PEEK(callStack))) {
1547 if (srcMode == SRC_CMODE)
1548 applyToSet (func->cfpoints,setStepEPBp,NEXT,
1551 applyToSet (func->afpoints,setStepEPBp,NEXT,
1552 func->mod->asm_name);
1555 if (srcMode == SRC_CMODE) {
1556 /* for all execution points in this function */
1557 applyToSet(cctxt->func->cfpoints,setNextEPBp,NEXT,
1558 cctxt->func->mod->c_name);
1559 /* set a break point @ the current function's
1561 setBreakPoint (cctxt->func->sym->eaddr, CODE, NEXT ,
1562 nextBpCB, cctxt->func->mod->c_name,
1563 cctxt->func->exitline);
1565 /* now break point @ callers execution points */
1566 if ((func = STACK_PPEEK(callStack))) {
1567 applyToSet (func->cfpoints,setNextEPBp,NEXT ,
1569 /* set bp @ callers exit point */
1570 setBreakPoint (func->sym->eaddr, CODE, NEXT ,
1571 stepBpCB, func->mod->c_name,
1575 /* for all execution points in this function */
1576 applyToSet(cctxt->func->afpoints,setNextEPBp,NEXT,
1577 cctxt->func->mod->asm_name);
1578 /* set a break point @ the current function's
1580 setBreakPoint (cctxt->func->sym->eaddr, CODE, NEXT ,
1581 nextBpCB, cctxt->func->mod->asm_name,
1582 cctxt->func->aexitline);
1584 /* now break point @ callers execution points */
1585 if ((func = STACK_PPEEK(callStack))) {
1586 applyToSet (func->cfpoints,setNextEPBp,NEXT ,
1587 func->mod->asm_name);
1588 /* set bp @ callers exit point */
1589 setBreakPoint (func->sym->eaddr, CODE, NEXT ,
1590 stepBpCB, func->mod->asm_name,
1603 /*-----------------------------------------------------------------*/
1604 /* cmdRun - run till next break point */
1605 /*-----------------------------------------------------------------*/
1606 int cmdRun (char *s, context *cctxt)
1609 if (STACK_EMPTY(callStack)) {
1610 fprintf(stdout,"Starting program\n");
1613 fprintf(stdout,"No executable file specified.\nUse the \"file\" command.\n");
1621 "The program being debugged has been started already.\n");
1622 fprintf(stdout,"Start it from the beginning? (y or n) ");
1625 fgets(buff,sizeof(buff),stdin);
1626 if (toupper(buff[0]) == 'Y') {
1636 /*-----------------------------------------------------------------
1637 cmdListSymbols - list symbols
1638 |-----------------------------------------------------------------*/
1639 int cmdListSymbols (char *s, context *cctxt)
1641 int our_verbose = 0;
1645 if (strstr(s, "v1")) {
1647 } else if (strstr(s, "v2")) {
1651 printf("[symbols]\n");
1652 sy = setFirstItem(symbols);
1657 if (our_verbose <= 1)
1658 printf("<%s>", sy->name);
1660 if (our_verbose > 1) {
1661 printf(" %d) name:%s, size:%d, level:%d block:%d\n", i,
1662 sy->name, sy->size, sy->level, sy->block);
1663 printf(" isonstack:%d, isfunc:%d, offset:%d addr:%d\n",
1664 sy->isonstack, sy->isfunc, sy->offset, sy->addr);
1665 printf(" eaddr:%d, addr_type:%c, type:%x etype:%x\n",
1666 sy->eaddr, sy->addr_type, sy->type, sy->etype);
1667 printf(" scopetype:%c, sname:%s, rname:%s addrspace:%c\n",
1668 sy->scopetype, sy->sname, sy->rname, sy->addrspace);
1669 printf(" next:%x\n", sy->next);
1672 sy = setNextItem(symbols);
1674 printf(" %d symbols\n", i);
1678 /*-----------------------------------------------------------------
1679 cmdListFunctions - list functions.
1680 |-----------------------------------------------------------------*/
1681 int cmdListFunctions (char *s, context *cctxt)
1685 int our_verbose = 0;
1687 if (strstr(s, "v1")) {
1689 } else if (strstr(s, "v2")) {
1693 printf("[functions]\n");
1694 f = setFirstItem(functions);
1700 printf(" %d) sym:%x, fname:%s, modName:%s, mod:%x\n", i,
1701 f->sym, f->sym->name, f->modName, f->mod);
1702 printf(" entryline:%d, aentryline:%d, exitline:%d, aexitline:%d\n",
1703 f->entryline, f->aentryline, f->exitline, f->aexitline);
1704 printf(" cfpoints:%x, afpoints:%x, laddr:%x, lline:%d\n",
1705 f->cfpoints, f->afpoints, f->laddr, f->lline);
1708 printf("<%s>", f->modName);
1711 f = setNextItem(functions);
1713 printf(" %d functions\n", i);
1717 /*-----------------------------------------------------------------
1718 cmdListModules - list functions.
1719 |-----------------------------------------------------------------*/
1720 int cmdListModules (char *s, context *cctxt)
1725 int our_verbose = 0;
1727 if (strstr(s, "v1")) {
1729 } else if (strstr(s, "v2")) {
1733 printf("[modules]\n");
1734 m = setFirstItem(modules);
1740 if (our_verbose >= 0) {
1741 printf(" %d) cfullname:%s, afullname:%s, name:%s\n", ++mi,
1742 m->cfullname, m->afullname, m->name);
1743 printf(" c_name:%s, asm_name:%s, ncLines:%d, nasmLines:%d\n",
1744 m->c_name, m->asm_name, m->ncLines, m->nasmLines);
1745 printf(" cLines:%x, asmLines:%x\n",
1746 m->cLines, m->asmLines);
1748 if (our_verbose >= 2) {
1750 printf(" [cLines] ");
1752 for (i=0; i<m->ncLines; i++ ) {
1754 printf(" (%d) addr:%x, block:%d, level:%d, src:%s\n",
1755 i, cs->addr, cs->block, cs->level, cs->src);
1758 printf("%d records", i);
1761 printf(" [asmLines] ");
1763 for (i=0; i<m->nasmLines; i++ ) {
1764 as = m->asmLines[i];
1765 printf(" (%d) addr:%x, block:%d, level:%d, src:%s\n",
1766 i, as->addr, as->block, as->level, as->src);
1769 printf("%d records", i);
1774 m = setNextItem(modules);
1779 /*-----------------------------------------------------------------
1780 infoSymbols - This is really just a tool to dump all these
1781 huge program structures out into human readable form.
1782 |-----------------------------------------------------------------*/
1783 static void infoSymbols(context *ctxt)
1785 int our_verbose = 0;
1787 printf("[context:%x] func:%x modName:%s addr:%x\n",
1788 ctxt, ctxt->func, ctxt->modName, ctxt->addr);
1790 printf(" cline:%d asmline:%d block:%d level:%d\n",
1791 ctxt->cline, ctxt->asmline, ctxt->level);
1793 printf("[globals] currCtxt:%x, modules:%x, functions:%x symbols:%x\n",
1794 currCtxt, modules, functions, symbols);
1795 printf(" nStructs:%d, structs:%x, ssdirl:%s\n",
1796 nStructs, structs, ssdirl);
1798 /**************** modules *******************/
1803 printf("[modules]\n");
1804 m = setFirstItem(modules);
1809 printf(" %d) cfullname:%s, afullname:%s, name:%s\n", ++mi,
1810 m->cfullname, m->afullname, m->name);
1811 printf(" c_name:%s, asm_name:%s, ncLines:%d, nasmLines:%d\n",
1812 m->c_name, m->asm_name, m->ncLines, m->nasmLines);
1813 printf(" cLines:%x, asmLines:%x\n",
1814 m->cLines, m->asmLines);
1817 cs = m->cLines[i++];
1818 printf(" [cLines] ");
1821 printf(" (%d) addr:%x, block:%d, level:%d, src:%s\n",
1822 i, cs->addr, cs->block, cs->level, cs->src);
1823 cs = m->cLines[i++];
1826 printf("%d records", i);
1830 as = m->asmLines[i++];
1831 printf(" [asmLines] ");
1834 printf(" (%d) addr:%x, block:%d, level:%d, src:%s\n",
1835 i, as->addr, as->block, as->level, as->src);
1836 as = m->asmLines[i++];
1839 printf("%d records", i);
1843 m = setNextItem(modules);
1847 /**************** functions *******************/
1851 printf("[functions]\n");
1852 f = setFirstItem(functions);
1858 printf(" %d) sym:%x, modName:%s, mod:%x\n", i,
1859 f->sym, f->modName, f->mod);
1860 printf(" entryline:%d, aentryline:%d, exitline:%d, aexitline:%d\n",
1861 f->entryline, f->aentryline, f->exitline, f->aexitline);
1862 printf(" cfpoints:%x, afpoints:%x, laddr:%x, lline:%d\n",
1863 f->cfpoints, f->afpoints, f->laddr, f->lline);
1866 f = setNextItem(functions);
1869 printf(" %d functions\n", i);
1872 /**************** symbols *******************/
1876 printf("[symbols]\n");
1877 s = setFirstItem(symbols);
1883 printf(" %d) name:%s, size:%d, level:%d block:%d\n", i,
1884 s->name, s->size, s->level, s->block);
1885 printf(" isonstack:%d, isfunc:%d, offset:%d addr:%d\n",
1886 s->isonstack, s->isfunc, s->offset, s->addr);
1887 printf(" eaddr:%d, addr_type:%c, type:%x etype:%x\n",
1888 s->eaddr, s->addr_type, s->type, s->etype);
1889 printf(" scopetype:%c, sname:%s, rname:%s addrspace:%c\n",
1890 s->scopetype, s->sname, s->rname, s->addrspace);
1891 printf(" next:%x\n", s->next);
1894 s = setNextItem(symbols);
1897 printf(" %d symbols\n", i);
1902 /*-----------------------------------------------------------------*/
1903 /* infoRegisters - print register information */
1904 /*-----------------------------------------------------------------*/
1905 static void infoRegisters( int all, context *ctxt)
1907 static unsigned int regaddrs[] = {0x81,0x82,0x83,0xd0,0xe0,0xf0,0};
1911 i = simGetValue (0xd0,'I',1);
1912 fprintf(stdout,"PC : 0x%04X RegisterBank %d:\nR0-7:",ctxt->addr,(i>>3)&3);
1913 for ( j = 0; j < 8 ; j++ )
1915 val = simGetValue (j ,'R',1);
1916 fprintf(stdout," 0x%02X",val);
1918 fprintf(stdout,"\n");
1919 val = simGetValue (0xe0,'I',1);
1920 fprintf(stdout,"ACC : 0x%02X %d %c\n",val,val,(isprint(val) ? val : '.'));
1921 val = simGetValue (0xf0,'I',1);
1922 fprintf(stdout,"B : 0x%02X %d %c\n",val,val,(isprint(val) ? val : '.'));
1923 val = simGetValue (0x82,'I',2);
1924 fprintf(stdout,"DPTR: 0x%04X %d\n",val,val);
1925 val = simGetValue (0x81,'I',1);
1926 fprintf(stdout,"SP : 0x%02X\n",val);
1927 fprintf(stdout,"PSW : 0x%02X | CY : %c | AC : %c | OV : %c | P : %c\n",
1928 i,(i&0x80)?'1':'0',(i&0x40)?'1':'0',(i&4)?'1':'0',(i&1)?'1':'0');
1931 fprintf(stdout,"Special Function Registers:\n");
1933 for ( i = 0x80 ; i < 0x100 ; i++ )
1936 if ( *r && *r == i )
1938 /* skip normal registers */
1942 if (applyToSetFTrue(sfrsymbols,symWithAddr,i,'I',&sym))
1944 val = simGetValue (sym->addr,sym->addrspace,sym->size);
1945 fprintf(stdout,"%s : 0x%02x",sym->name,val);
1948 for ( j = 0 ; j < 8 ; j++ )
1951 if (applyToSetFTrue(sfrsymbols,symWithAddr,i+j,'J',&sym))
1953 //val = simGetValue (sym->addr,sym->addrspace,sym->size);
1954 fprintf(stdout," %s=%c",sym->name,(val&1)? '1':'0');
1959 fprintf(stdout,"\n");
1965 /*-----------------------------------------------------------------*/
1966 /* infoStack - print call stack information */
1967 /*-----------------------------------------------------------------*/
1968 static void infoStack(context *ctxt)
1973 STACK_STARTWALK(callStack) ;
1974 while ((func = STACK_WALK(callStack))) {
1975 Dprintf(D_break, ("break: infoStack: %s %p (%p)\n",func->sym->name, w_callStack,p_callStack));
1977 fprintf(stdout,"#%d 0x%08x in %s () at %s:%d\n",i++,
1978 func->laddr,func->sym->name,
1979 func->mod->c_name,func->lline+1);
1982 fprintf(stdout,"no stack.\n");
1985 /*-----------------------------------------------------------------*/
1986 /* cmdWhere - where command */
1987 /*-----------------------------------------------------------------*/
1988 int cmdWhere(char *s, context *cctxt)
1995 static int infomode = 0;
1996 /*-----------------------------------------------------------------*/
1997 /* cmdInfo - info command */
1998 /*-----------------------------------------------------------------*/
1999 int cmdInfo (char *s, context *cctxt)
2001 while (isspace(*s)) s++;
2003 /* list all break points */
2004 if (strncmp(s,"break",5) == 0) {
2009 /* info frame same as frame */
2010 if (strcmp(s,"frame") == 0) {
2015 if (strncmp(s,"line",4) == 0) {
2017 cmdListSrc (s+4,cctxt);
2020 if (strncmp(s,"source",6) == 0)
2026 fprintf(stdout,"Source files for which symbols have been read in:\n\n");
2027 for (m = setFirstItem(modules); m ; m = setNextItem(modules))
2029 fprintf(stdout,"%s%s, %s",k ? ", ":"",m->cfullname, m->afullname);
2032 fprintf(stdout,"\n");
2036 if (!cctxt || !cctxt->func || !cctxt->func->mod)
2038 fprintf(stdout,"No source file loaded\n");
2041 m = cctxt->func->mod;
2042 fprintf(stdout,"Current source file is %s\n",m->c_name);
2043 fprintf(stdout,"Located in %s\n",m->cfullname);
2044 fprintf(stdout,"Contains %d lines.\nSource language is c.\n",
2049 if (strncmp(s,"functions",7) == 0)
2053 fprintf(stdout,"All defined functions:\n");
2054 for ( f = setFirstItem(functions); f ; f = setNextItem(functions))
2059 fprintf(stdout,"\nFile %s\n", m->c_name);
2061 fprintf(stdout,"%s();\n",f->sym->name);
2065 /* info stack display call stack */
2066 if (strcmp(s,"stack") == 0) {
2072 /* info stack display call stack */
2073 if (strcmp(s,"registers") == 0) {
2074 infoRegisters(0,cctxt);
2078 /* info stack display call stack */
2079 if (strcmp(s,"all-registers") == 0)
2081 infoRegisters(1,cctxt);
2085 /* info stack display call stack */
2086 if (strcmp(s,"symbols") == 0) {
2087 /* dump out symbols we have read in */
2088 fprintf(stdout,"Dumping symbols...\n");
2093 if (strcmp(s,"variables") == 0) {
2094 /* dump out symbols we have read in */
2095 fprintf(stdout,"Dumping symbols...\n");
2100 fprintf(stdout,"Undefined info command: \"%s\". Try \"help\n",s);
2105 /*-----------------------------------------------------------------*/
2106 /* cmdQuit - quit debugging */
2107 /*-----------------------------------------------------------------*/
2108 int cmdQuit (char *s, context *cctxt)
2115 /*-----------------------------------------------------------------*/
2116 /* cmdListSrc - list src */
2117 /*-----------------------------------------------------------------*/
2118 int cmdListSrc (char *s, context *cctxt)
2120 static int currline = 0;
2123 int llines = listlines;
2124 function *func = NULL;
2127 while (*s && isspace(*s)) s++;
2129 /* if the user has spcified line numer then the line number
2130 can be of the following formats
2131 LINE - just line number
2132 FILE:LINE - filename line number
2133 FILE:LINE,LASTLINE + last line
2134 FUNCTION - list a function
2135 FILE:FUNCTION - function in file */
2140 if (!cctxt || !cctxt->func || !cctxt->func->mod) {
2142 fprintf(stdout,"Sdcdb fails to have a proper context at %d.\n", __LINE__);
2147 list_mod = cctxt->func->mod;
2148 pline = strtol(s,&s,10) - 1;
2149 if (s && (s = strchr(s,',')))
2152 llines = strtol(s+1,0,10);
2162 /* if ':' present then FILE:LINE || FILE:FUNCTION */
2163 if ((bp = strchr(s,':'))) {
2168 list_mod=NULL; /* bug fix 2-09-02, moduleWithCName expects mod to be null */
2169 if (srcMode == SRC_CMODE) {
2170 if (!applyToSet(modules,moduleWithCName,s,&list_mod)) {
2171 fprintf (stderr,"No c source file named %s.\n",s);
2175 if (!applyToSet(modules,moduleWithAsmName,s,&list_mod)) {
2176 fprintf (stderr,"No source file named %s.\n",s);
2180 pline = strtol(bp,&bp,10) - 1;
2181 if (bp && (bp = strchr(bp,',')))
2183 /* FILE:LINE,LASTLINE */
2184 llines = strtol(bp+1,0,10);
2192 if (!applyToSet(functions,funcWithNameModule,bp,s,&func)) {
2193 fprintf(stdout,"Function \"%s\" not defined.\n",bp);
2196 list_mod = func->mod;
2197 if (srcMode == SRC_CMODE) {
2198 pline = func->entryline;
2199 llines = func->exitline - func->entryline + 1;
2201 pline = func->aentryline;
2202 llines = func->aexitline - func->aentryline + 1;
2212 if ((bp = strrchr(s,'\'')))
2218 if (!applyToSet(functions,funcWithName,s,&func)) {
2219 fprintf(stderr,"Function \"%s\" not defined.\n",s);
2223 list_mod = func->mod;
2224 if (srcMode == SRC_CMODE) {
2225 pline = func->entryline;
2226 llines = func->exitline - func->entryline + 1;
2228 pline = func->aentryline;
2229 llines = func->aexitline - func->aentryline + 1;
2235 /* if no line specified & we had listed
2236 before then continue from that listing */
2240 if (!cctxt || !cctxt->func || !cctxt->func->mod) {
2241 fprintf(stdout,"Missing context at %d. Try list filename:lineno\n", __LINE__);
2244 list_mod = cctxt->func->mod;
2245 if (srcMode == SRC_CMODE)
2246 pline = cctxt->cline;
2248 pline = cctxt->asmline;
2253 fprintf(stdout,"Sdcdb fails to have a valid module context at %d.\n", __LINE__);
2261 int firstaddr , lastaddr ;
2262 if ( pline >= list_mod->ncLines )
2263 pline = cctxt->cline;
2264 firstaddr = lastaddr = list_mod->cLines[pline]->addr;
2265 if (!func && cctxt && cctxt->func )
2267 fprintf(stdout,"Line %d of \"%s\" starts at address 0x%08x <%s+%d>",
2269 list_mod->c_name, lastaddr,
2270 func ? func->sym->name : "?",
2271 func ? lastaddr -func->sym->addr : 0);
2273 while ( pline < list_mod->ncLines )
2276 if ( list_mod->cLines[pline]->addr > lastaddr )
2278 lastaddr = list_mod->cLines[pline]->addr -1;
2282 fprintf(stdout," and ends at 0x%08x <%s+%d>.\n",
2284 func ? func->sym->name : "?",
2285 func ? lastaddr -func->sym->addr : 0);
2288 fprintf(stdout,"\032\032%s:%d:1:beg:0x%08x\n",
2289 func->mod->cfullname,
2295 for ( i = 0 ; i < llines ; i++ ) {
2296 if (srcMode == SRC_CMODE) {
2297 if ( (pline + i) >= list_mod->ncLines )
2299 fprintf(stdout,"%d\t%s",pline + i,
2300 list_mod->cLines[pline +i]->src);
2302 if ( (pline + i) >= list_mod->nasmLines )
2304 fprintf(stdout,"%d\t%s",pline + i,
2305 list_mod->asmLines[pline +i]->src);
2308 currline = pline + i ;
2312 static unsigned long getValBasic(symbol *sym, link *type, char *val)
2328 v.f = strtof(val,NULL);
2331 v.val = strtol(val,NULL,0);
2334 if (IS_INTEGRAL(type))
2343 if (( s = strchr(val,'\'')))
2346 v.b[0] = strtol(s+2,NULL,8);
2352 v.b[0] = strtol(val,NULL,0);
2358 v.val = strtol(val,NULL,0);
2360 v.i.lo = strtol(val,NULL,0);
2362 v.val = strtol(val,NULL,0);
2365 v.val = strtol(val,NULL,0);
2370 /*-----------------------------------------------------------------*/
2371 /* printFmtInteger - print value in bin,oct,dez or hex */
2372 /*-----------------------------------------------------------------*/
2373 static void printFmtInteger(char *deffmt,int fmt, long val,
2376 static char digits[] =
2378 '0' , '1' , '2' , '3' , '4' , '5' ,
2379 '6' , '7' , '8' , '9' , 'a' , 'b' ,
2380 'c' , 'd' , 'e' , 'f' , 'g' , 'h'
2382 static int radixOfFormat[] = { 0 , 2, 8 ,10, 16 };
2383 static int olenOfSize[] = { 0 , 3, 6 , 8, 11 };
2389 if ( fmt == FMT_NON || fmt == FMT_DEZ )
2391 fprintf(stdout,deffmt,val);
2394 radix = radixOfFormat[fmt];
2397 if ( sign && val < 0 )
2405 while (val <= -radix)
2407 buf[charPos--] = digits[-(val % radix)];
2410 buf[charPos] = digits[-val];
2415 radix = olenOfSize[size];
2425 while (charPos > 39 - radix )
2427 buf[--charPos] = '0';
2432 if ( buf[charPos] != '0' )
2433 buf[--charPos] = '0';
2436 buf[--charPos] = 'x';
2437 buf[--charPos] = '0';
2441 buf[--charPos] = '-';
2443 fputs(&buf[charPos],stdout);
2446 /*-----------------------------------------------------------------*/
2447 /* printValBasic - print value of basic types */
2448 /*-----------------------------------------------------------------*/
2449 static void printValBasic(symbol *sym, link *type,
2450 char mem, unsigned addr,int size, int fmt)
2466 v.val = simGetValue(addr,mem,size);
2467 /* if this a floating point number then */
2469 fprintf(stdout,"%f",v.f);
2472 fprintf(stdout,"0x%*x",size<<1,v.val);
2474 if (IS_INTEGRAL(type))
2483 if ( isprint(v.val))
2484 printFmtInteger((SPEC_USIGN(etype)?"0x%02x":"'%c'"),
2485 fmt,(long)v.val,0,size);
2487 printFmtInteger((SPEC_USIGN(etype)?"0x%02x":"'\\%o'"),
2488 fmt,(long)v.val,0,size);
2494 if (SPEC_USIGN(etype))
2495 printFmtInteger("%u",fmt,(long)v.val,0,size);
2497 printFmtInteger("%d",fmt,(long)v.sval,1,size);
2499 if (SPEC_USIGN(etype))
2500 printFmtInteger("%u",fmt,(long)v.i.lo,0,size);
2502 printFmtInteger("%d",fmt,(long)v.i.lo,1,size);
2505 if (IS_BITVAR(etype))
2506 fprintf(stdout,"%c",(v.val?'1':'0'));
2508 fprintf(stdout,"0x%0*x",size<<1,v.val);
2512 fprintf(stdout,"0x%0*x",size<<1,v.val);
2515 /*-----------------------------------------------------------------*/
2516 /* printValFunc - prints function values */
2517 /*-----------------------------------------------------------------*/
2518 static void printValFunc (symbol *sym, int fmt)
2520 fprintf(stdout,"print function not yet implemented");
2523 /*-----------------------------------------------------------------*/
2524 /* printArrayValue - will print the values of array elements */
2525 /*-----------------------------------------------------------------*/
2526 static void printArrayValue (symbol *sym, link *type,
2527 char space, unsigned int addr, int fmt)
2529 link *elem_type = type->next;
2532 fprintf(stdout,"{");
2533 for (i = 0 ; i < DCL_ELEM(type) ; i++) {
2534 if (IS_AGGREGATE(elem_type)) {
2535 printValAggregates(sym,elem_type,space,addr,fmt);
2537 printValBasic(sym,elem_type,space,addr,getSize(elem_type),fmt);
2539 addr += getSize(elem_type);
2540 if (i != DCL_ELEM(type) -1)
2541 fprintf(stdout,",");
2544 fprintf(stdout,"}");
2547 /*-----------------------------------------------------------------*/
2548 /* printStructValue - prints structures elements */
2549 /*-----------------------------------------------------------------*/
2550 static void printStructValue (symbol *sym, link *type,
2551 char space, unsigned int addr, int fmt)
2553 symbol *fields = SPEC_STRUCT(type)->fields;
2555 fprintf(stdout," { ");
2557 fprintf(stdout,"%s%s = ",(first ? "": ", "),fields->name);
2559 if (IS_AGGREGATE(fields->type)) {
2560 printValAggregates(fields,fields->type,space, addr, fmt);
2562 printValBasic(fields,fields->type,space,addr,getSize(fields->type), fmt);
2564 addr += getSize(fields->type);
2565 fields = fields->next;
2567 fprintf(stdout,"}");
2570 /*-----------------------------------------------------------------*/
2571 /* printValAggregates - print value of aggregates */
2572 /*-----------------------------------------------------------------*/
2573 static void printValAggregates (symbol *sym, link *type,
2574 char space,unsigned int addr, int fmt)
2577 if (IS_ARRAY(type)) {
2578 printArrayValue(sym, type, space, addr, fmt);
2582 if (IS_STRUCT(type)) {
2583 printStructValue(sym, type, space, addr, fmt);
2588 /*-----------------------------------------------------------------*/
2589 /* printOrSetSymValue - print or set value of a symbol */
2590 /*-----------------------------------------------------------------*/
2591 static int printOrSetSymValue (symbol *sym, context *cctxt,
2592 int flg, int dnum, int fmt, char *rs,
2593 char *val, char cmp )
2595 static char fmtChar[] = " todx ";
2596 static int stack = 1;
2602 char save_ch, save_ch2;
2604 /* if it is on stack then compute address & fall thru */
2607 symbol *bp = symLookup("bp",cctxt);
2610 fprintf(stdout,"cannot determine stack frame\n");
2614 sym->addr = simGetValue(bp->addr,bp->addrspace,bp->size)
2618 /* get the value from the simulator and
2626 fprintf(stdout,"$%d = ",stack++);
2629 fprintf(stdout,"%d: ", dnum);
2630 if ( fmt != FMT_NON )
2631 fprintf(stdout,"/%c ",fmtChar[fmt]);
2632 fprintf(stdout,"%s%s = ",sym->name,rs);
2642 if ( *rs == '[' && IS_ARRAY(type))
2645 while ( *rs && *rs != ']' ) rs++ ;
2648 if ( ! isdigit(*s ))
2650 /* index seems a variable */
2651 for ( s2 = s; *s2 && ( isalnum( *s2 ) || *s2 == '_'); s2++ );
2655 fields = symLookup(s,cctxt);
2659 fprintf(stdout,"Unknown variable \"%s\" for index.\n", s);
2662 /* arrays & structures first */
2663 if (! IS_INTEGRAL(fields->type))
2665 fprintf(stdout,"Wrong type of variable \"%s\" for index \n", s);
2668 n = simGetValue(fields->addr,fields->addrspace,getSize(fields->type));
2674 if ( n < 0 || n >= DCL_ELEM(type))
2676 fprintf(stdout,"Wrong index %d.\n", n);
2680 size = getSize(type);
2684 else if ( *rs == '.' && IS_STRUCT(type))
2687 /* search structure element */
2688 for ( rs = s; *rs && ( isalnum( *rs ) || *rs == '_'); rs++ );
2692 for (fields = SPEC_STRUCT(type)->fields; fields; fields = fields->next)
2694 if (!(strcmp(s,fields->name)))
2700 fprintf(stdout,"Unknown field \"%s\" of structure\n", s);
2703 type = fields->type;
2704 size = getSize(type);
2705 addr += fields->offset;
2711 /* arrays & structures first */
2712 if (IS_AGGREGATE(type))
2716 fprintf(stdout,"Cannot set/compare aggregate variable\n");
2720 printValAggregates(sym,type,sym->addrspace,addr,fmt);
2727 printValFunc(sym,fmt);
2735 unsigned long newval;
2736 newval = getValBasic(sym,type,val);
2741 lval = simGetValue(addr,sym->addrspace,size);
2744 case '<' : return ( lval < newval ? 1:0 ); break;
2745 case '>' : return ( lval > newval ? 1:0 ); break;
2746 case 'l' : return ( lval <= newval ? 1:0 ); break;
2747 case 'g' : return ( lval >= newval ? 1:0 ); break;
2748 case '=' : return ( lval == newval ? 1:0 ); break;
2749 case '!' : return ( lval != newval ? 1:0 ); break;
2754 simSetValue(addr,sym->addrspace,size,newval);
2759 printValBasic(sym,type,sym->addrspace,addr,size,fmt);
2761 if ( flg > 0 ) fprintf(stdout,"\n");
2765 /*-----------------------------------------------------------------*/
2766 /* printStructInfo - print out structure information */
2767 /*-----------------------------------------------------------------*/
2768 static void printStructInfo (structdef *sdef)
2770 symbol *field = sdef->fields ;
2775 field = field->next;
2778 fprintf(stdout,"%s %s {\n",(i ? "struct" : "union" ), sdef->tag);
2779 field = sdef->fields;
2781 printTypeInfo (field->type);
2782 fprintf(stdout," %s ;\n",field->name);
2783 field = field->next ;
2786 fprintf(stdout,"}\n");
2790 /*-----------------------------------------------------------------*/
2791 /* printTypeInfo - print out the type information */
2792 /*-----------------------------------------------------------------*/
2793 static void printTypeInfo(link *p)
2799 switch (DCL_TYPE(p)) {
2801 printTypeInfo (p->next);
2802 fprintf(stdout,"()");
2805 printTypeInfo (p->next);
2806 fprintf(stdout,"[%d]",DCL_ELEM(p));
2812 printTypeInfo (p->next);
2813 fprintf(stdout,"(_near *)");
2817 printTypeInfo (p->next);
2818 fprintf(stdout,"(_xdata *)");
2822 printTypeInfo( p->next);
2823 fprintf(stdout,"(_code *)");
2827 printTypeInfo( p->next);
2828 fprintf(stdout,"(_generic *)");
2832 switch (SPEC_NOUN(p)) { /* depending on the specifier type */
2834 (IS_LONG(p) ? fputs("long ",stdout) :
2835 ( IS_SHORT(p) ? fputs("short ",stdout) :
2836 fputs("int ",stdout))) ;
2839 fputs("float ",stdout);
2843 fputs ("char ",stdout);
2847 fputs("void ",stdout);
2851 printStructInfo (SPEC_STRUCT(p));
2855 fputs("sbit ",stdout);
2859 fprintf(stdout,": %d" ,SPEC_BLEN(p));
2865 /*-----------------------------------------------------------------*/
2866 /* conditionIsTrue - compare variable with constant value */
2867 /*-----------------------------------------------------------------*/
2868 int conditionIsTrue( char *s, context *cctxt)
2872 char *rs, *dup, cmp_char;
2873 dup = s = Safe_strdup(s);
2874 if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )) || !sym)
2876 else if (!( s = strpbrk(rs,"<>=!")))
2884 /* if <= or >= an other char is used
2885 * == or != not checked in switch
2889 case '>': cmp_char = 'g' ; break;
2890 case '<': cmp_char = 'l' ; break;
2894 while (isspace(*s)) *s++ = '\0';
2895 fmt = printOrSetSymValue(sym,cctxt,0,0,0,rs,s,cmp_char);
2901 /*-----------------------------------------------------------------*/
2902 /* cmdPrint - print value of variable */
2903 /*-----------------------------------------------------------------*/
2904 int cmdPrint (char *s, context *cctxt)
2909 if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
2914 printOrSetSymValue(sym,cctxt,1,0,fmt,rs,NULL,'\0');
2919 /*-----------------------------------------------------------------*/
2920 /* cmdOutput - print value of variable without number and newline */
2921 /*-----------------------------------------------------------------*/
2922 int cmdOutput (char *s, context *cctxt)
2927 if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
2932 printOrSetSymValue(sym,cctxt,0,0,fmt,rs,NULL,'\0');
2937 /** find display entry with this number */
2939 DEFSETFUNC(dsymWithNumber)
2941 dsymbol *dsym = item;
2943 V_ARG(dsymbol **,dsymp);
2945 if ( dsym->dnum == dnum )
2953 /*-----------------------------------------------------------------*/
2954 /* displayAll - display all valid variables */
2955 /*-----------------------------------------------------------------*/
2956 void displayAll(context *cctxt)
2962 for (dsym = setFirstItem(dispsymbols);
2964 dsym = setNextItem(dispsymbols))
2966 if ( (sym = symLookup(dsym->name,cctxt)))
2967 printOrSetSymValue(sym,cctxt,2,dsym->dnum,dsym->fmt,
2968 dsym->rs,NULL,'\0');
2972 /*-----------------------------------------------------------------*/
2973 /* cmdDisplay - display value of variable */
2974 /*-----------------------------------------------------------------*/
2975 int cmdDisplay (char *s, context *cctxt)
2977 static int dnum = 1;
2981 if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
2989 dsymbol *dsym = (dsymbol *)Safe_calloc(1,sizeof(dsymbol));
2990 dsym->dnum = dnum++ ;
2991 dsym->name = sym->name;
2993 dsym->rs = gc_strdup(rs);
2994 addSetHead(&dispsymbols,dsym);
2999 /*-----------------------------------------------------------------*/
3000 /* cmdUnDisplay - undisplay value of variable */
3001 /*-----------------------------------------------------------------*/
3002 int cmdUnDisplay (char *s, context *cctxt)
3007 while (isspace(*s)) s++;
3010 for (dsym = setFirstItem(dispsymbols);
3012 dsym = setNextItem(dispsymbols))
3014 Safe_free(dsym->rs);
3017 deleteSet(&dispsymbols);
3022 dnum = strtol(s,&s,10);
3023 if (applyToSetFTrue(dispsymbols,dsymWithNumber,dnum,&dsym))
3025 deleteSetItem(&dispsymbols,dsym);
3026 Safe_free(dsym->rs);
3031 fprintf(stdout,"Arguments must be display numbers.\n");
3037 /*-----------------------------------------------------------------*/
3038 /* cmdPrintType - print type of a variable */
3039 /*-----------------------------------------------------------------*/
3040 int cmdPrintType (char *s, context *cctxt)
3043 char *bp = s+strlen(s) -1;
3045 while (isspace(*s)) s++;
3047 while (isspace(*bp)) bp--;
3051 if ((sym = symLookup(s,cctxt))) {
3052 printTypeInfo(sym->type);
3053 fprintf(stdout,"\n");
3056 "No symbol \"%s\" in current context.\n",
3062 /*-----------------------------------------------------------------*/
3063 /* cmdClrUserBp - clear user break point */
3064 /*-----------------------------------------------------------------*/
3065 int cmdClrUserBp (char *s, context *cctxt)
3068 function *func = NULL;
3070 /* clear break point location specification can be of the following
3072 a) <nothing> - break point at current location
3073 b) lineno - number of the current module
3074 c) filename:lineno - line number of the given file
3075 e) filename:function- function X in file Y (useful for static functions)
3076 f) function - function entry point
3080 fprintf(stdout,"No symbol table is loaded. Use the \"file\" command.\n");
3084 /* white space skip */
3085 while (*s && isspace(*s)) s++;
3087 /* null terminate it after stripping trailing blanks*/
3089 while (bp != s && isspace(*bp)) bp--;
3092 /* case a) nothing */
3093 /* if nothing given then current location : we know
3094 the current execution location from the currentContext */
3097 /* if current context is known */
3099 /* clear the break point @ current location */
3100 clearUSERbp (cctxt->addr);
3102 fprintf(stderr,"No default breakpoint address now.\n");
3107 /* case b) lineno */
3108 /* check if line number */
3110 /* get the lineno */
3113 /* if current context not present then we must get the module
3114 which has main & set the break point @ line number provided
3115 of that module : if current context known then set the bp
3116 at the line number given for the current module
3119 if (!cctxt->func->mod) {
3120 if (!applyToSet(functions,funcWithName,"main"))
3121 fprintf(stderr,"Function \"main\" not defined.\n");
3123 clearBPatModLine(func->mod,line);
3125 clearBPatModLine(cctxt->func->mod,line);
3131 if ((bp = strchr(s,':'))) {
3136 if (!applyToSet(modules,moduleWithCName,s,&mod)) {
3137 fprintf (stderr,"No source file named %s.\n",s);
3141 /* case c) filename:lineno */
3142 if (isdigit(*(bp +1))) {
3144 clearBPatModLine (mod,atoi(bp+1));
3148 /* case d) filename:function */
3149 if (!applyToSet(functions,funcWithNameModule,bp+1,s,&func))
3150 fprintf(stderr,"Function \"%s\" not defined.\n",bp+1);
3152 clearBPatModLine (mod,func->entryline);
3157 /* case e) function */
3158 if (!applyToSet(functions,funcWithName,s,&func))
3159 fprintf(stderr,"Function \"%s\" not defined.\n",s);
3161 clearBPatModLine(func->mod,func->entryline);
3167 /*-----------------------------------------------------------------*/
3168 /* cmdSimulator - send command to simulator */
3169 /*-----------------------------------------------------------------*/
3170 int cmdSimulator (char *s, context *cctxt)
3174 if (strlen(s) > 80) {
3175 printf("error 3A\n");
3179 strcat(tmpstr, "\n");
3181 waitForSim(200,NULL);
3182 fprintf(stdout,"%s",simResponse());
3186 void setMainContext()
3188 function *func = NULL;
3190 if (!applyToSet(functions,funcWithName,"main",&func) &&
3191 !applyToSet(functions,funcWithName,"_main",&func))
3194 discoverContext (func->sym->addr, func);
3197 static void printFrame()
3200 function *func = NULL;
3201 function *lastfunc = NULL;
3203 if ( currentFrame < 0 )
3206 fprintf(stdout,"Bottom (i.e., innermost) frame selected; you cannot go down.\n");
3209 STACK_STARTWALK(callStack) ;
3210 for ( i = 0; i <= currentFrame ; i++ )
3212 func = STACK_WALK(callStack);
3216 fprintf(stdout,"Initial frame selected; you cannot go up.\n");
3220 fprintf(stdout,"#%d 0x%08x in %s () at %s:%d\n",
3221 currentFrame,func->laddr,func->sym->name,func->mod->c_name,func->lline+1);
3222 fprintf(stdout,"\032\032%s:%d:1:beg:0x%08x\n",
3223 func->mod->cfullname,func->lline+1,func->laddr);
3225 discoverContext (func->laddr, func);
3229 /*-----------------------------------------------------------------*/
3230 /* cmdUp - Up command */
3231 /*-----------------------------------------------------------------*/
3232 int cmdUp(char *s, context *cctxt)
3234 while (isspace(*s)) s++;
3236 currentFrame += strtol(s,0,10);
3244 /*-----------------------------------------------------------------*/
3245 /* cmdDown - down command */
3246 /*-----------------------------------------------------------------*/
3247 int cmdDown(char *s, context *cctxt)
3249 while (isspace(*s)) s++;
3251 currentFrame -= strtol(s,0,10);
3258 /*-----------------------------------------------------------------*/
3259 /* cmdFrame - Frame command */
3260 /*-----------------------------------------------------------------*/
3261 int cmdFrame (char *s, context *cctxt)
3263 function *func = NULL;
3266 while (isspace(*s)) s++;
3268 currentFrame = strtol(s,0,10);
3273 /*-----------------------------------------------------------------*/
3274 /* cmdFinish - exec till end of current function */
3275 /*-----------------------------------------------------------------*/
3276 int cmdFinish (char *s, context *ctxt)
3278 if (STACK_EMPTY(callStack)) {
3279 fprintf(stdout,"The program is not running.\n");
3283 if (srcMode == SRC_CMODE) {
3284 setBreakPoint (ctxt->func->sym->eaddr, CODE, STEP,
3285 stepBpCB, ctxt->func->mod->c_name,
3286 ctxt->func->exitline);
3288 setBreakPoint (ctxt->func->sym->eaddr, CODE, STEP,
3289 stepBpCB, ctxt->func->mod->asm_name,
3290 ctxt->func->aexitline);
3300 /*-----------------------------------------------------------------*/
3301 /* cmdShow - show command */
3302 /*-----------------------------------------------------------------*/
3303 int cmdShow (char *s, context *cctxt)
3305 /* skip white space */
3306 while (*s && isspace(*s)) s++ ;
3308 if (strcmp(s,"copying") == 0) {
3309 fputs(copying,stdout);
3313 if (strcmp(s,"warranty") == 0) {
3314 fputs(warranty,stdout);