#include "simi.h"
#include "break.h"
#include "cmd.h"
+#include "newalloc.h"
/* default number of lines to list out */
-int listLines = 16;
+#define LISTLINES 10
+static int listlines = LISTLINES;
/* mainly used to retain a reference to the active module being
listed. May be used as a general context for other commands if
{" NO WARRANTY"};
#else
static char *copying=
-" GNU GENERAL PUBLIC LICENSE
- Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
- 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
- Preamble
-
- The licenses for most software are designed to take away your
-freedom to share and change it. By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users. This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it. (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.) You can apply it to
-your programs, too.
-
- When we speak of free software, we are referring to freedom, not
-price. Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
- To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
- For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have. You must make sure that they, too, receive or can get the
-source code. And you must show them these terms so they know their
-rights.
-
- We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
- Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software. If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
- Finally, any free program is threatened constantly by software
-patents. We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary. To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
- The precise terms and conditions for copying, distribution and
-modification follow.
-^L
- GNU GENERAL PUBLIC LICENSE
- TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
- 0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License. The \"Program\", below,
-refers to any such program or work, and a \"work based on the Program\"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language. (Hereinafter, translation is included without limitation in
-the term \"modification\".) Each licensee is addressed as \"you\".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope. The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
- 1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
- 2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
- a) You must cause the modified files to carry prominent notices
- stating that you changed the files and the date of any change.
-
- b) You must cause any work that you distribute or publish, that in
- whole or in part contains or is derived from the Program or any
- part thereof, to be licensed as a whole at no charge to all third
- parties under the terms of this License.
-
- c) If the modified program normally reads commands interactively
- when run, you must cause it, when started running for such
- interactive use in the most ordinary way, to print or display an
- announcement including an appropriate copyright notice and a
- notice that there is no warranty (or else, saying that you provide
- a warranty) and that users may redistribute the program under
- these conditions, and telling the user how to view a copy of this
- License. (Exception: if the Program itself is interactive but
- does not normally print such an announcement, your work based on
- the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole. If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works. But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
- 3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
- a) Accompany it with the complete corresponding machine-readable
- source code, which must be distributed under the terms of Sections
- 1 and 2 above on a medium customarily used for software interchange; or,
-
- b) Accompany it with a written offer, valid for at least three
- years, to give any third party, for a charge no more than your
- cost of physically performing source distribution, a complete
- machine-readable copy of the corresponding source code, to be
- distributed under the terms of Sections 1 and 2 above on a medium
- customarily used for software interchange; or,
-
- c) Accompany it with the information you received as to the offer
- to distribute corresponding source code. (This alternative is
- allowed only for noncommercial distribution and only if you
- received the program in object code or executable form with such
- an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it. For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable. However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-^L
- 4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License. Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
- 5. You are not required to accept this License, since you have not
-signed it. However, nothing else grants you permission to modify or
-distribute the Program or its derivative works. These actions are
-prohibited by law if you do not accept this License. Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
- 6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions. You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
- 7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License. If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all. For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices. Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
- 8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded. In such case, this License incorporates
-the limitation as if written in the body of this License.
-
- 9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time. Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number. If the Program
-specifies a version number of this License which applies to it and \"any
-later version\", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation. If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
- 10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission. For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this. Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-";
+" GNU GENERAL PUBLIC LICENSE\n"
+" Version 2, June 1991\n"
+"\n"
+" Copyright (C) 1989, 1991 Free Software Foundation, Inc.\n"
+" 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA\n"
+" Everyone is permitted to copy and distribute verbatim copies\n"
+" of this license document, but changing it is not allowed.\n"
+"\n"
+" Preamble\n"
+"\n"
+" The licenses for most software are designed to take away your\n"
+"freedom to share and change it. By contrast, the GNU General Public\n"
+"License is intended to guarantee your freedom to share and change free\n"
+"software--to make sure the software is free for all its users. This\n"
+"General Public License applies to most of the Free Software\n"
+"Foundation's software and to any other program whose authors commit to\n"
+"using it. (Some other Free Software Foundation software is covered by\n"
+"the GNU Library General Public License instead.) You can apply it to\n"
+"your programs, too.\n"
+"\n"
+" When we speak of free software, we are referring to freedom, not\n"
+"price. Our General Public Licenses are designed to make sure that you\n"
+"have the freedom to distribute copies of free software (and charge for\n"
+"this service if you wish), that you receive source code or can get it\n"
+"if you want it, that you can change the software or use pieces of it\n"
+"in new free programs; and that you know you can do these things.\n"
+"\n"
+" To protect your rights, we need to make restrictions that forbid\n"
+"anyone to deny you these rights or to ask you to surrender the rights.\n"
+"These restrictions translate to certain responsibilities for you if you\n"
+"distribute copies of the software, or if you modify it.\n"
+"\n"
+" For example, if you distribute copies of such a program, whether\n"
+"gratis or for a fee, you must give the recipients all the rights that\n"
+"you have. You must make sure that they, too, receive or can get the\n"
+"source code. And you must show them these terms so they know their\n"
+"rights.\n"
+"\n"
+" We protect your rights with two steps: (1) copyright the software, and\n"
+"(2) offer you this license which gives you legal permission to copy,\n"
+"distribute and/or modify the software.\n"
+"\n"
+" Also, for each author's protection and ours, we want to make certain\n"
+"that everyone understands that there is no warranty for this free\n"
+"software. If the software is modified by someone else and passed on, we\n"
+"want its recipients to know that what they have is not the original, so\n"
+"that any problems introduced by others will not reflect on the original\n"
+"authors' reputations.\n"
+"\n"
+" Finally, any free program is threatened constantly by software\n"
+"patents. We wish to avoid the danger that redistributors of a free\n"
+"program will individually obtain patent licenses, in effect making the\n"
+"program proprietary. To prevent this, we have made it clear that any\n"
+"patent must be licensed for everyone's free use or not licensed at all.\n"
+"\n"
+" The precise terms and conditions for copying, distribution and\n"
+"modification follow.\n"
+"^L\n"
+" GNU GENERAL PUBLIC LICENSE\n"
+" TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n"
+"\n"
+" 0. This License applies to any program or other work which contains\n"
+"a notice placed by the copyright holder saying it may be distributed\n"
+"under the terms of this General Public License. The \"Program\", below,\n"
+"refers to any such program or work, and a \"work based on the Program\"\n"
+"means either the Program or any derivative work under copyright law:\n"
+"that is to say, a work containing the Program or a portion of it,\n"
+"either verbatim or with modifications and/or translated into another\n"
+"language. (Hereinafter, translation is included without limitation in\n"
+"the term \"modification\".) Each licensee is addressed as \"you\".\n"
+"\n"
+"Activities other than copying, distribution and modification are not\n"
+"covered by this License; they are outside its scope. The act of\n"
+"running the Program is not restricted, and the output from the Program\n"
+"is covered only if its contents constitute a work based on the\n"
+"Program (independent of having been made by running the Program).\n"
+"Whether that is true depends on what the Program does.\n"
+"\n"
+" 1. You may copy and distribute verbatim copies of the Program's\n"
+"source code as you receive it, in any medium, provided that you\n"
+"conspicuously and appropriately publish on each copy an appropriate\n"
+"copyright notice and disclaimer of warranty; keep intact all the\n"
+"notices that refer to this License and to the absence of any warranty;\n"
+"and give any other recipients of the Program a copy of this License\n"
+"along with the Program.\n"
+"\n"
+"You may charge a fee for the physical act of transferring a copy, and\n"
+"you may at your option offer warranty protection in exchange for a fee.\n"
+"\n"
+" 2. You may modify your copy or copies of the Program or any portion\n"
+"of it, thus forming a work based on the Program, and copy and\n"
+"distribute such modifications or work under the terms of Section 1\n"
+"above, provided that you also meet all of these conditions:\n"
+"\n"
+" a) You must cause the modified files to carry prominent notices\n"
+" stating that you changed the files and the date of any change.\n"
+"\n"
+" b) You must cause any work that you distribute or publish, that in\n"
+" whole or in part contains or is derived from the Program or any\n"
+" part thereof, to be licensed as a whole at no charge to all third\n"
+" parties under the terms of this License.\n"
+"\n"
+" c) If the modified program normally reads commands interactively\n"
+" when run, you must cause it, when started running for such\n"
+" interactive use in the most ordinary way, to print or display an\n"
+" announcement including an appropriate copyright notice and a\n"
+" notice that there is no warranty (or else, saying that you provide\n"
+" a warranty) and that users may redistribute the program under\n"
+" these conditions, and telling the user how to view a copy of this\n"
+" License. (Exception: if the Program itself is interactive but\n"
+" does not normally print such an announcement, your work based on\n"
+" the Program is not required to print an announcement.)\n"
+"\n"
+"These requirements apply to the modified work as a whole. If\n"
+"identifiable sections of that work are not derived from the Program,\n"
+"and can be reasonably considered independent and separate works in\n"
+"themselves, then this License, and its terms, do not apply to those\n"
+"sections when you distribute them as separate works. But when you\n"
+"distribute the same sections as part of a whole which is a work based\n"
+"on the Program, the distribution of the whole must be on the terms of\n"
+"this License, whose permissions for other licensees extend to the\n"
+"entire whole, and thus to each and every part regardless of who wrote it.\n"
+"\n"
+"Thus, it is not the intent of this section to claim rights or contest\n"
+"your rights to work written entirely by you; rather, the intent is to\n"
+"exercise the right to control the distribution of derivative or\n"
+"collective works based on the Program.\n"
+"\n"
+"In addition, mere aggregation of another work not based on the Program\n"
+"with the Program (or with a work based on the Program) on a volume of\n"
+"a storage or distribution medium does not bring the other work under\n"
+"the scope of this License.\n"
+"\n"
+" 3. You may copy and distribute the Program (or a work based on it,\n"
+"under Section 2) in object code or executable form under the terms of\n"
+"Sections 1 and 2 above provided that you also do one of the following:\n"
+"\n"
+" a) Accompany it with the complete corresponding machine-readable\n"
+" source code, which must be distributed under the terms of Sections\n"
+" 1 and 2 above on a medium customarily used for software interchange; or,\n"
+"\n"
+" b) Accompany it with a written offer, valid for at least three\n"
+" years, to give any third party, for a charge no more than your\n"
+" cost of physically performing source distribution, a complete\n"
+" machine-readable copy of the corresponding source code, to be\n"
+" distributed under the terms of Sections 1 and 2 above on a medium\n"
+" customarily used for software interchange; or,\n"
+"\n"
+" c) Accompany it with the information you received as to the offer\n"
+" to distribute corresponding source code. (This alternative is\n"
+" allowed only for noncommercial distribution and only if you\n"
+" received the program in object code or executable form with such\n"
+" an offer, in accord with Subsection b above.)\n"
+"\n"
+"The source code for a work means the preferred form of the work for\n"
+"making modifications to it. For an executable work, complete source\n"
+"code means all the source code for all modules it contains, plus any\n"
+"associated interface definition files, plus the scripts used to\n"
+"control compilation and installation of the executable. However, as a\n"
+"special exception, the source code distributed need not include\n"
+"anything that is normally distributed (in either source or binary\n"
+"form) with the major components (compiler, kernel, and so on) of the\n"
+"operating system on which the executable runs, unless that component\n"
+"itself accompanies the executable.\n"
+"\n"
+"If distribution of executable or object code is made by offering\n"
+"access to copy from a designated place, then offering equivalent\n"
+"access to copy the source code from the same place counts as\n"
+"distribution of the source code, even though third parties are not\n"
+"compelled to copy the source along with the object code.\n"
+"^L\n"
+" 4. You may not copy, modify, sublicense, or distribute the Program\n"
+"except as expressly provided under this License. Any attempt\n"
+"otherwise to copy, modify, sublicense or distribute the Program is\n"
+"void, and will automatically terminate your rights under this License.\n"
+"However, parties who have received copies, or rights, from you under\n"
+"this License will not have their licenses terminated so long as such\n"
+"parties remain in full compliance.\n"
+"\n"
+" 5. You are not required to accept this License, since you have not\n"
+"signed it. However, nothing else grants you permission to modify or\n"
+"distribute the Program or its derivative works. These actions are\n"
+"prohibited by law if you do not accept this License. Therefore, by\n"
+"modifying or distributing the Program (or any work based on the\n"
+"Program), you indicate your acceptance of this License to do so, and\n"
+"all its terms and conditions for copying, distributing or modifying\n"
+"the Program or works based on it.\n"
+"\n"
+" 6. Each time you redistribute the Program (or any work based on the\n"
+"Program), the recipient automatically receives a license from the\n"
+"original licensor to copy, distribute or modify the Program subject to\n"
+"these terms and conditions. You may not impose any further\n"
+"restrictions on the recipients' exercise of the rights granted herein.\n"
+"You are not responsible for enforcing compliance by third parties to\n"
+"this License.\n"
+"\n"
+" 7. If, as a consequence of a court judgment or allegation of patent\n"
+"infringement or for any other reason (not limited to patent issues),\n"
+"conditions are imposed on you (whether by court order, agreement or\n"
+"otherwise) that contradict the conditions of this License, they do not\n"
+"excuse you from the conditions of this License. If you cannot\n"
+"distribute so as to satisfy simultaneously your obligations under this\n"
+"License and any other pertinent obligations, then as a consequence you\n"
+"may not distribute the Program at all. For example, if a patent\n"
+"license would not permit royalty-free redistribution of the Program by\n"
+"all those who receive copies directly or indirectly through you, then\n"
+"the only way you could satisfy both it and this License would be to\n"
+"refrain entirely from distribution of the Program.\n"
+"\n"
+"If any portion of this section is held invalid or unenforceable under\n"
+"any particular circumstance, the balance of the section is intended to\n"
+"apply and the section as a whole is intended to apply in other\n"
+"circumstances.\n"
+"\n"
+"It is not the purpose of this section to induce you to infringe any\n"
+"patents or other property right claims or to contest validity of any\n"
+"such claims; this section has the sole purpose of protecting the\n"
+"integrity of the free software distribution system, which is\n"
+"implemented by public license practices. Many people have made\n"
+"generous contributions to the wide range of software distributed\n"
+"through that system in reliance on consistent application of that\n"
+"system; it is up to the author/donor to decide if he or she is willing\n"
+"to distribute software through any other system and a licensee cannot\n"
+"impose that choice.\n"
+"\n"
+"This section is intended to make thoroughly clear what is believed to\n"
+"be a consequence of the rest of this License.\n"
+"\n"
+" 8. If the distribution and/or use of the Program is restricted in\n"
+"certain countries either by patents or by copyrighted interfaces, the\n"
+"original copyright holder who places the Program under this License\n"
+"may add an explicit geographical distribution limitation excluding\n"
+"those countries, so that distribution is permitted only in or among\n"
+"countries not thus excluded. In such case, this License incorporates\n"
+"the limitation as if written in the body of this License.\n"
+"\n"
+" 9. The Free Software Foundation may publish revised and/or new versions\n"
+"of the General Public License from time to time. Such new versions will\n"
+"be similar in spirit to the present version, but may differ in detail to\n"
+"address new problems or concerns.\n"
+"\n"
+"Each version is given a distinguishing version number. If the Program\n"
+"specifies a version number of this License which applies to it and \"any\n"
+"later version\", you have the option of following the terms and conditions\n"
+"either of that version or of any later version published by the Free\n"
+"Software Foundation. If the Program does not specify a version number of\n"
+"this License, you may choose any version ever published by the Free Software\n"
+"Foundation.\n"
+"\n"
+" 10. If you wish to incorporate parts of the Program into other free\n"
+"programs whose distribution conditions are different, write to the author\n"
+"to ask for permission. For software which is copyrighted by the Free\n"
+"Software Foundation, write to the Free Software Foundation; we sometimes\n"
+"make exceptions for this. Our decision will be guided by the two goals\n"
+"of preserving the free status of all derivatives of our free software and\n"
+"of promoting the sharing and reuse of software generally.\n";
+
static char *warranty=
-" NO WARRANTY
-
- 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
- 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-";
+" NO WARRANTY\n"
+"\n"
+" 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\n"
+"FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN\n"
+"OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\n"
+"PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\n"
+"OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n"
+"MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS\n"
+"TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE\n"
+"PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\n"
+"REPAIR OR CORRECTION.\n"
+"\n"
+" 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\n"
+"WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\n"
+"REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\n"
+"INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\n"
+"OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\n"
+"TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\n"
+"YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\n"
+"PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n"
+"POSSIBILITY OF SUCH DAMAGES.\n";
#endif
static void printTypeInfo(link *);
-static void printValAggregates (symbol *,link *,char,unsigned int);
+static void printValAggregates (symbol *,link *,char,unsigned int,int);
+static int printOrSetSymValue (symbol *sym, context *cctxt,
+ int flg, int dnum, int fmt,
+ char *rs, char *val, char cmp);
int srcMode = SRC_CMODE ;
-
+static set *dispsymbols = NULL ; /* set of displayable symbols */
+static int currentFrame = 0; /* actual displayed frame */
/*-----------------------------------------------------------------*/
/* funcWithName - returns function with name */
/*-----------------------------------------------------------------*/
return 0;
}
+/*-----------------------------------------------------------------*/
+/* symWithAddr - look for symbol with sfr / sbit address */
+/*-----------------------------------------------------------------*/
+DEFSETFUNC(symWithAddr)
+{
+ symbol *sym = item;
+ V_ARG(unsigned long,laddr);
+ V_ARG(int ,laddrspace);
+ V_ARG(symbol **,rsym);
+
+ if (*rsym)
+ return 0;
+
+ if ( sym->addr == laddr &&
+ sym->addrspace == laddrspace )
+ {
+ *rsym = sym;
+ return 1;
+ }
+
+ return 0;
+}
+
/*-----------------------------------------------------------------*/
/* setBPatModLine - set break point at the line specified for the */
/*-----------------------------------------------------------------*/
-static void setBPatModLine (module *mod, int line)
+static void setBPatModLine (module *mod, int line, char bpType )
{
int next_line;
next_line++ ) {
if (srcMode == SRC_CMODE) {
if (mod->cLines[next_line]->addr) {
- setBreakPoint (mod->cLines[next_line]->addr, CODE, USER,
+ setBreakPoint (mod->cLines[next_line]->addr, CODE, bpType,
userBpCB, mod->c_name, next_line);
return;
// break;
}
else {
if (mod->asmLines[next_line]->addr) {
- setBreakPoint (mod->asmLines[next_line]->addr, CODE, USER,
+ setBreakPoint (mod->asmLines[next_line]->addr, CODE, bpType,
userBpCB, mod->asm_name, next_line);
return;
// break;
return;
}
+/*-----------------------------------------------------------------*/
+/* moduleLineWithAddr - finds and returns a line with a given address */
+/*-----------------------------------------------------------------*/
+DEFSETFUNC(moduleLineWithAddr)
+{
+ module *mod = item;
+ int i;
+
+ V_ARG(unsigned int,addr);
+ V_ARG(module **,rmod);
+ V_ARG(int *,line);
+
+ if (*rmod)
+ return 0;
+
+ for (i=0; i < mod->nasmLines; i++ )
+ {
+ if ( mod->asmLines[i]->addr == addr)
+ {
+ *rmod = mod ;
+ if (line )
+ {
+ *line = 0;
+ for ( i=0; i < mod->ncLines; i++ )
+ {
+ if ( mod->cLines[i]->addr > addr)
+ break;
+ *line = i;
+ }
+ return 1;
+ }
+ }
+ }
+
+ return 0;
+}
+
/*-----------------------------------------------------------------*/
/* funcWithNameModule - returns functions with a name module combo */
/*-----------------------------------------------------------------*/
V_ARG(function **,funcp);
if (*funcp)
- return 0;
+ return 0;
if (strcmp(func->sym->name,fname) == 0 &&
strcmp(func->mod->c_name,mname) == 0) {
}
+/*-----------------------------------------------------------------*/
+/* lineNearAddr - for execution points returns the one with addr */
+/*-----------------------------------------------------------------*/
+DEFSETFUNC(lineNearAddr)
+{
+ exePoint *ep = item;
+ V_ARG(unsigned int,addr);
+ V_ARG(int *,line);
+ V_ARG(int *,block);
+ V_ARG(int *,level);
+
+ /* the line in which the address is */
+ if (ep->addr <= addr) {
+ *line = ep->line;
+ if (block)
+ *block = ep->block ;
+ if (level)
+ *level = ep->level ;
+ return 1;
+ }
+
+ return 0;
+
+}
+
/*-----------------------------------------------------------------*/
/* discoverContext - find out the current context of the bp */
/*-----------------------------------------------------------------*/
-context *discoverContext (unsigned addr)
+context *discoverContext (unsigned addr, function *func)
{
- function *func = NULL;
+ module *mod = NULL;
int line = 0;
/* find the function we are in */
- if (!applyToSet(functions,funcInAddr,addr,&func)) {
- fprintf(stderr, "Error?:discoverContext: cannot apply to set!\n");
- return NULL;
+ if (!func && !applyToSet(functions,funcInAddr,addr,&func)) {
+ if (!applyToSet(functions,funcWithName,"main",&func) ||
+ !applyToSet(modules,moduleLineWithAddr,addr,&mod,NULL))
+ {
+ fprintf(stderr, "Error?:discoverContext: cannot apply addr 0x%x\n",addr);
+ return NULL;
+ }
+ currCtxt->func = func;
+ currCtxt->addr = addr;
+ currCtxt->modName = mod->name;
+ currCtxt->cline = func->exitline;
}
-
- currCtxt->func = func;
- currCtxt->addr = func->laddr = addr;
- currCtxt->modName = func->modName;
-
- /* find the c line number */
- if(applyToSet(func->cfpoints,lineAtAddr,addr,
- &line,&currCtxt->block,&currCtxt->level))
- currCtxt->cline = func->lline = line;
else
- currCtxt->cline = func->exitline;
+ {
+ currCtxt->func = func;
+ currCtxt->addr = func->laddr = addr;
+ currCtxt->modName = func->modName;
+ /* find the c line number */
+ if(applyToSet(func->cfpoints,lineAtAddr,addr,
+ &line,&currCtxt->block,&currCtxt->level))
+ currCtxt->cline = func->lline = line;
+ else if(applyToSet(func->cfpoints,lineNearAddr,addr,
+ &line,&currCtxt->block,&currCtxt->level))
+ currCtxt->cline = func->lline = line;
+ else
+ currCtxt->cline = func->exitline;
+ }
/* find the asm line number */
line = 0;
if (applyToSet(func->afpoints,lineAtAddr,addr,
unsigned int addr ;
context *ctxt;
int rv;
- static int initial_break_flag = 0;
-
+ stopCommandList();
top:
+ if ( userinterrupt )
+ {
+ userinterrupt = 0;
+ return;
+ }
addr = simGoTillBp (gaddr);
/* got the pc for the break point now first
discover the program context i.e. module, function
linenumber of the source etc, etc etc */
- ctxt = discoverContext (addr);
+ currentFrame = 0;
+ ctxt = discoverContext (addr, NULL);
/* dispatch all the break point call back functions */
rv = dispatchCB (addr,ctxt);
-
ret:
/* the dispatch call back function will return
non-zero if an user break point has been hit
if not then we continue with the execution
of the program */
- if (!rv) {
- if (!initial_break_flag) {
- initial_break_flag = 1; // kludge to stop only at first run
- fprintf(stdout, "Stopping at entry. You can now list and set breakpoints\n");
- }
- else {
- gaddr = -1;
- goto top ;
- }
-
-// notes: kpb
-// I took this out, after running "run" it would just keep re-running
-// even after a lot of break points hit. For some reason above code
-// not triggering(dispatchCB). This seems to be by design, startup adds
-// a bunch of breakpoints-but they are not USER breakpoints. Perhaps the
-// debugger changed with its implementation of "go"("run"). It seems we
-// need to add a "next" or "step" followed by a "run"...
-// I added a "step" in simi.c when we want a resume function, this seems
-// to work.
-
-// still there is question of how do we stop it initially, since
-// it must be started before it can get a context. If so, we would
-// want it to just run up to an initial entry point you'd think...
-// I don't see why we can't set breakpoints before an initial run,
-// this does not seem right to me.
-
-// line #'s are a bit off too.
-
-#if 0
- gaddr = -1;
- goto top ;
-#endif
+ if (!rv)
+ {
+ if ( gaddr == 0 )
+ gaddr = -1;
+ if ( gaddr == -1 || doingSteps == 1 )
+ goto top ;
}
}
/*-----------------------------------------------------------------*/
-/* cmdSetUserBp - set break point at the user specified location */
+/* preparePrint - common parse function for */
+/* output, print and display */
/*-----------------------------------------------------------------*/
-int cmdSetUserBp (char *s, context *cctxt)
+static char *preparePrint(char *s, context *cctxt, int *fmt, symbol **sym)
+{
+ char *bp = s+strlen(s) -1;
+ char save_ch ;
+
+ *fmt = FMT_NON;
+ *sym = NULL;
+
+ while (isspace(*s)) s++;
+ if (!*s)
+ return (char *)0;
+
+ while (isspace(*bp)) bp--;
+ bp++ ;
+ *bp = '\0';
+
+ if ( *s == '/' )
+ {
+ /* format of printout */
+ switch ( *++s )
+ {
+ case 'x':
+ *fmt = FMT_HEX ;
+ break;
+ case 'o':
+ *fmt = FMT_OCT ;
+ break;
+ default:
+ case 'd':
+ *fmt = FMT_DEZ ;
+ break;
+ case 't':
+ *fmt = FMT_BIN ;
+ break;
+ }
+ s++;
+ while (isspace(*s)) s++;
+ }
+ for ( bp = s; *bp && ( isalnum( *bp ) || *bp == '_'); bp++ );
+ save_ch = *bp;
+ if ( *bp )
+ *bp = '\0';
+
+ *sym = symLookup(s,cctxt);
+ *bp = save_ch;
+
+ if ( ! *sym )
+ fprintf(stdout,"No symbol \"%s\" in current context.\n", s);
+ return bp;
+}
+
+static int printAsmLine( function *func, module *m, long saddr, long eaddr)
+{
+ int i,j,delta;
+ int symaddr;
+ int lastaddr = saddr+1;
+ char *symname;
+
+ if ( func )
+ {
+ symaddr = func->sym->addr;
+ symname = func->sym->name;
+ }
+ else
+ {
+ symaddr = saddr;
+ symname = "" ;
+ }
+ for (j=0,i=0; i < m->nasmLines; i++ )
+ {
+ if ( saddr >= 0 && m->asmLines[i]->addr < saddr)
+ {
+ continue;
+ }
+ if ( eaddr >= 0 && m->asmLines[i]->addr > eaddr)
+ {
+ continue;
+ }
+ if ( func &&
+ (m->asmLines[i]->addr < func->sym->addr ||
+ m->asmLines[i]->addr > func->sym->eaddr ))
+ {
+ continue;
+ }
+ delta = m->asmLines[i]->addr - symaddr;
+ if ( delta >= 0 )
+ {
+ j++;
+ lastaddr = m->asmLines[i]->addr;
+ printf("0x%08x <%s",lastaddr,symname);
+ if (delta > 0) printf("+%d",delta);
+ printf(">:\t%s",m->asmLines[i]->src);
+ }
+ }
+ return lastaddr;
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdDisasm - disassemble asm instruction */
+/*-----------------------------------------------------------------*/
+static int cmdDisasm (char *s, context *cctxt, int args)
+{
+ function *func = NULL;
+ long saddr = -1;
+ long eaddr = -1;
+ int found = 0;
+ module *modul;
+ /* white space skip */
+
+ if ( args > 0 )
+ {
+ while (*s && isspace(*s)) s++;
+
+ if ( isdigit(*s))
+ {
+ saddr = strtol(s,&s,0);
+ if ( args > 1 )
+ {
+ while (*s && isspace(*s)) s++;
+
+ if ( isdigit(*s))
+ eaddr = strtol(s,0,0);
+ }
+ else
+ eaddr = saddr+1;
+ }
+ }
+
+ if ( eaddr == -1 )
+ {
+ /* no start or only start so dump function */
+ if ( saddr == -1 )
+ {
+ func = cctxt->func;
+ }
+ else
+ {
+ applyToSet(functions,funcInAddr,saddr,&func);
+ }
+ if ( func )
+ {
+ printf("Dump of assembler code for function %s:\n",func->sym->name);
+ printAsmLine(func,func->mod,-1,-1);
+ printf("End of assembler dump.\n");
+ return 0;
+ }
+ else
+ {
+ if (applyToSet(modules,moduleLineWithAddr,saddr,&modul,NULL))
+ {
+ eaddr = saddr + 5;
+ printf("Dump of assembler code:\n");
+ printAsmLine(NULL,modul,saddr,eaddr);
+ printf("End of assembler dump.\n");
+ return 0;
+ }
+ }
+ }
+ else
+ {
+ if ( args > 1 )
+ printf("Dump of assembler code from 0x%08x to 0x%08x:\n",saddr,eaddr);
+ found = 0;
+ while ( saddr < eaddr )
+ {
+ func = NULL;
+ if (applyToSet(functions,funcInAddr,saddr,&func))
+ {
+ found = 1;
+ modul = func->mod;
+ }
+ else
+ {
+ if ( found )
+ break;
+ if (!applyToSet(modules,moduleLineWithAddr,saddr,&modul,NULL))
+ break;
+ }
+ saddr = printAsmLine(func,modul,saddr,eaddr) + 1;
+ }
+ if( saddr >= eaddr)
+ {
+ if ( args > 1 )
+ printf("End of assembler dump.\n");
+ return 0;
+ }
+
+ }
+ fprintf(stderr,"No function contains specified address.\n");
+ return 0;
+}
+/*-----------------------------------------------------------------*/
+/* cmdDisasm1 - disassemble one asm instruction */
+/*-----------------------------------------------------------------*/
+int cmdDisasm1 (char *s, context *cctxt)
+{
+ return cmdDisasm( s, cctxt, 1);
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdDisasmF - disassemble asm instructions */
+/*-----------------------------------------------------------------*/
+int cmdDisasmF(char *s, context *cctxt)
+{
+ return cmdDisasm( s, cctxt, 2);
+}
+
+static int commonSetUserBp(char *s, context *cctxt, char bpType)
{
char *bp ;
function *func = NULL;
c) filename:lineno - line number of the given file
e) filename:function- function X in file Y (useful for static functions)
f) function - function entry point
+ g) *addr - break point at address
*/
if (!cctxt) {
/* if current context is known */
if (cctxt->func) {
+ Dprintf(D_break, ("commonSetUserBp: a) cctxtaddr:%x \n",cctxt->addr));
if (srcMode == SRC_CMODE)
/* set the break point */
- setBreakPoint ( cctxt->addr , CODE , USER , userBpCB ,
+ setBreakPoint ( cctxt->addr , CODE , bpType , userBpCB ,
cctxt->func->mod->c_name, cctxt->cline);
else
- setBreakPoint ( cctxt->addr , CODE , USER , userBpCB ,
+ setBreakPoint ( cctxt->addr , CODE , bpType , userBpCB ,
cctxt->func->mod->asm_name, cctxt->asmline);
}
goto ret ;
}
-
+ /* case g) *addr */
+ if ( *s == '*' && isdigit(*(s+1)))
+ {
+ int line = 0;
+ long braddr = strtol(s+1,0,0);
+ if (!applyToSet(functions,funcInAddr,braddr,&func))
+ {
+ module *modul;
+ if (!applyToSet(modules,moduleLineWithAddr,braddr,&modul,&line))
+ {
+ fprintf(stderr,"Address 0x%08x not exists in code.\n",braddr);
+ }
+ else
+ {
+ Dprintf(D_break, ("commonSetUserBp: g) addr:%x \n",braddr));
+ setBreakPoint ( braddr , CODE , bpType , userBpCB ,
+ modul->c_name,line);
+ }
+ goto ret ;
+ }
+ else
+ {
+ int line = func->exitline;
+ if ( !applyToSet(func->cfpoints,lineAtAddr,braddr,
+ &line,NULL,NULL))
+ applyToSet(func->cfpoints,lineNearAddr,braddr,&line,NULL,NULL);
+ setBreakPoint ( braddr , CODE , bpType , userBpCB ,
+ func->mod->c_name,line);
+ }
+ goto ret ;
+ }
/* case b) lineno */
/* check if line number */
- if (isdigit(*s)) {
+ if ( !strchr(s,':') && isdigit(*s)) {
/* get the lineno */
- int line = atoi(s);
+ int line = atoi(s) -1;
+ Dprintf(D_break, ("commonSetUserBp: b) line:%d \n",line));
/* if current context not present then we must get the module
which has main & set the break point @ line number provided
if (!applyToSet(functions,funcWithName,"main"))
fprintf(stderr,"Function \"main\" not defined.\n");
else
- setBPatModLine(func->mod,line);
+ setBPatModLine(func->mod,line, bpType);
} else
- setBPatModLine(cctxt->func->mod,line);
+ setBPatModLine(cctxt->func->mod,line, bpType);
} else {
if (list_mod) {
- setBPatModLine(list_mod,line);
+ setBPatModLine(list_mod,line, bpType);
} else {
fprintf(stdout,"Sdcdb fails to have module symbol context at %d\n", __LINE__);
}
}
/* case c) filename:lineno */
- if (isdigit(*(bp +1))) {
-
- setBPatModLine (mod,atoi(bp+1));
+ if (isdigit(*(bp +1))) {
+ Dprintf(D_break, ("commonSetUserBp: c) line:%d \n",atoi(bp+1)));
+ setBPatModLine (mod,atoi(bp+1)-1,bpType);
goto ret;
}
if (!applyToSet(functions,funcWithNameModule,bp+1,s,&func))
fprintf(stderr,"Function \"%s\" not defined.\n",bp+1);
else
+ Dprintf(D_break, ("commonSetUserBp: d) \n"));
setBPatModLine (mod,
(srcMode == SRC_CMODE ?
func->entryline :
- func->aentryline));
+ func->aentryline),bpType);
goto ret;
}
/* case e) function */
+ Dprintf(D_break, ("commonSetUserBp: e) \n"));
if (!applyToSet(functions,funcWithName,s,&func))
fprintf(stderr,"Function \"%s\" not defined.\n",s);
else
setBPatModLine(func->mod,
(srcMode == SRC_CMODE ?
func->entryline :
- func->aentryline));
+ func->aentryline),bpType);
ret:
return 0;
}
+/*-----------------------------------------------------------------*/
+/* cmdSetTmpUserBp - settempory break point at the user specified location */
+/*-----------------------------------------------------------------*/
+int cmdSetTmpUserBp (char *s, context *cctxt)
+{
+ return commonSetUserBp(s, cctxt, TMPUSER );
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdSetUserBp - set break point at the user specified location */
+/*-----------------------------------------------------------------*/
+int cmdSetUserBp (char *s, context *cctxt)
+{
+ return commonSetUserBp(s, cctxt, USER );
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdJump - set program counter */
+/*-----------------------------------------------------------------*/
+int cmdJump (char *s, context *cctxt)
+{
+ char *bp ;
+ function *func = NULL;
+ if (STACK_EMPTY(callStack))
+ {
+ fprintf(stdout,"The program is not running.\n");
+ return 0;
+ }
+
+ /* white space skip */
+ while (*s && isspace(*s)) s++;
+
+ /* null terminate it after stripping trailing blanks*/
+ bp = s + strlen(s);
+ while (bp != s && isspace(*bp)) bp--;
+ *bp = '\0';
+ if (! *s )
+ {
+ fprintf(stdout,"No argument: need line or *addr.\n");
+ return 0;
+ }
+ if ( *s == '*' && isdigit(*(s+1)))
+ {
+ unsigned int addr = atoi(s);
+ if (cctxt && cctxt->func &&
+ cctxt->func->sym->addr <= addr &&
+ cctxt->func->sym->eaddr >= addr)
+ {
+ simSetPC(addr);
+ return 0;
+ }
+ fprintf(stdout,"Warning addr 0x%x outside actual function.\n",addr);
+ simSetPC(addr);
+ return 0;
+ }
+ if (isdigit(*s))
+ {
+ /* get the lineno */
+ int line = atoi(s) -1;
+ if (!cctxt || !cctxt->func || !cctxt->func->mod)
+ {
+ fprintf(stderr,"Function not defined.\n");
+ return 0;
+ }
+ if (line >= cctxt->func->entryline &&
+ line <= cctxt->func->exitline )
+ {
+ simSetPC(cctxt->func->mod->cLines[line]->addr);
+ return 0;
+ }
+ if (line >= cctxt->func->mod->ncLines )
+ {
+ fprintf(stderr,"line not in module.\n");
+ return 0;
+ }
+ fprintf(stdout,"Warning line %d outside actual function.\n",line+1);
+ simSetPC(cctxt->func->mod->cLines[line]->addr);
+ return 0;
+ }
+ if ((bp = strchr(s,':')))
+ {
+ int line;
+ module *mod = NULL;
+ *bp++ = '\0';
+ if (!applyToSet(modules,moduleWithCName,s,&mod))
+ {
+ fprintf (stderr,"No source file named %s.\n",s);
+ return 0;
+ }
+ if (!isdigit(*bp))
+ {
+ fprintf (stderr,"No line number.\n");
+ return 0;
+ }
+ line = atoi(bp) -1;
+ if (line >= mod->ncLines )
+ {
+ fprintf(stderr,"line not in module.\n");
+ return 0;
+ }
+ if ( mod != cctxt->func->mod ||
+ line < cctxt->func->entryline ||
+ line > cctxt->func->exitline )
+ {
+ fprintf(stdout,"Warning line %d outside actual function.\n",
+ line+1);
+ }
+ simSetPC(mod->cLines[line]->addr);
+ }
+ return 0;
+}
+
/*-----------------------------------------------------------------*/
/* cmdListAsm - list assembler source code */
/*-----------------------------------------------------------------*/
int cmdListAsm (char *s, context *cctxt)
{
- fprintf(stderr,"'listasm' command not yet implemented\n");
+ if ( cctxt && cctxt->func)
+ {
+ /* actual line */
+ if (printAsmLine(cctxt->func,cctxt->func->mod,
+ (long)cctxt->addr,(long)cctxt->addr))
+ return 0;
+ }
return 0;
}
(srcMode == SRC_CMODE ? "C" : "asm"));
return 0;
}
-
+
+ if (strncmp(s,"listsize ",9) == 0)
+ {
+ listlines = strtol(s+9,0,0);
+ if ( listlines < LISTLINES )
+ listlines = LISTLINES;
+ return 0;
+ }
+
+#ifdef SDCDB_DEBUG
+ if (strncmp(s,"debug ",6) == 0)
+ {
+ sdcdbDebug = strtol(s+6,0,0);
+ return 0;
+ }
+#endif
+ if (strncmp(s,"variable ",9) == 0)
+ {
+ symbol *sym ;
+ int fmt;
+ char *rs;
+ s += 9;
+ if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
+ return 0;
+ s = rs;
+ while (*s && *s != '=') s++;
+ *s++ = '\0';
+ while (isspace(*s)) *s++ = '\0';
+ if (*s)
+ {
+ printOrSetSymValue(sym,cctxt,0,0,0,rs,s,'\0');
+ return 0;
+ }
+ else
+ fprintf(stdout,"No new value for \"%s\".\n",s);
+ return 0;
+ }
+
+
fprintf(stderr,"'set %s' command not yet implemented\n",s);
return 0;
}
/*-----------------------------------------------------------------*/
int cmdContinue (char *s, context *cctxt)
{
- if (!cctxt || !cctxt->func) {
+ if (STACK_EMPTY(callStack)) {
fprintf(stdout,"The program is not being run.\n");
return 0;
}
fprintf(stdout,"Continuing.\n");
simGo(-1);
+ showfull = 1;
+ return 0;
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdIgnore - set ignorecount for breakpoint */
+/*-----------------------------------------------------------------*/
+int cmdIgnore (char *s, context *cctxt)
+{
+ int bpnum, cnt ;
+ while (isspace(*s)) s++;
+ if (!*s )
+ {
+ fprintf(stdout,"Argument required (breakpoint number).\n");
+ return 0;
+ }
+ bpnum = strtol(s,&s,10);
+ while (isspace(*s)) s++;
+ if (!*s )
+ {
+ fprintf(stdout,"Second argument (specified ignore-count) is missing.");
+ return 0;
+ }
+ cnt = strtol(s,0,10);
+ setUserbpIgnCount(bpnum,cnt);
+ return 0;
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdCondition - set condition for breakpoint */
+/*-----------------------------------------------------------------*/
+int cmdCondition (char *s, context *cctxt)
+{
+ int bpnum ;
+ while (isspace(*s)) s++;
+ if (!*s )
+ {
+ fprintf(stdout,"Argument required (breakpoint number).\n");
+ return 0;
+ }
+ bpnum = strtol(s,&s,10);
+ while (isspace(*s)) s++;
+ if (*s)
+ s = Safe_strdup(s);
+ else
+ s = NULL;
+ setUserbpCondition(bpnum,s);
+ return 0;
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdCommands - set commands for breakpoint */
+/*-----------------------------------------------------------------*/
+int cmdCommands (char *s, context *cctxt)
+{
+ int bpnum ;
+ char *cmds,*line;
+ while (isspace(*s)) s++;
+
+ if (!*s )
+ bpnum = getLastBreakptNumber();
+ else
+ bpnum = strtol(s,0,10);
+
+ cmds = NULL;
+ while ((line = getNextCmdLine()))
+ {
+ while (isspace(*line)) line++;
+ if (!strncmp(line,"end",3))
+ break;
+ if (! cmds )
+ {
+ cmds = Safe_strdup(line);
+ }
+ else
+ {
+ cmds = Safe_realloc( cmds, strlen(cmds) + 1 + strlen(line));
+ strcat(cmds,line);
+ }
+ }
+ setUserbpCommand(bpnum,cmds);
return 0;
}
return 0;
}
+/*-----------------------------------------------------------------*/
+/* cmdStepi - single step exactly one instruction */
+/*-----------------------------------------------------------------*/
+int cmdStepi (char *s, context *cctxt)
+{
+
+ if (STACK_EMPTY(callStack))
+ fprintf(stdout,"The program is not being run.\n");
+ else
+ {
+ doingSteps = 2;
+ simGo(2);
+ doingSteps = 0;
+ showfull = 1;
+ }
+ return 0;
+}
+
/*-----------------------------------------------------------------*/
/* cmdStep - single step thru C source file */
/*-----------------------------------------------------------------*/
{
function *func = NULL;
- if (!cctxt || !cctxt->func || !cctxt->func->mod)
- fprintf(stdout,"The program is not being run.\n");
+ if (STACK_EMPTY(callStack))
+ fprintf(stdout,"The program is not being run.\n");
else {
- /* if we are @ the end of a function then set
- break points at execution points of the
- function in the call stack... */
- if (cctxt->addr == cctxt->func->sym->eaddr) {
- if ((func = STACK_PEEK(callStack))) {
- if (srcMode == SRC_CMODE)
- applyToSet (func->cfpoints,setStepEPBp,STEP,
- func->mod->c_name);
- else
- applyToSet (func->afpoints,setStepEPBp,STEP,
- func->mod->asm_name);
- }
- } else {
- /* set breakpoints at all function entry points
- and all exepoints of this functions & for
- all functions one up in the call stack */
+ /* if we are @ the end of a function then set
+ break points at execution points of the
+ function in the call stack... */
+ if (cctxt->addr == cctxt->func->sym->eaddr) {
+ if ((func = STACK_PEEK(callStack))) {
+ if (srcMode == SRC_CMODE)
+ applyToSet (func->cfpoints,setStepEPBp,STEP,
+ func->mod->c_name);
+ else
+ applyToSet (func->afpoints,setStepEPBp,STEP,
+ func->mod->asm_name);
+ }
+ } else {
+ /* set breakpoints at all function entry points
+ and all exepoints of this functions & for
+ all functions one up in the call stack */
- /* all function entry points */
- applyToSet(functions,setStepBp);
+ /* all function entry points */
+ applyToSet(functions,setStepBp);
- if (srcMode == SRC_CMODE) {
- /* for all execution points in this function */
- applyToSet(cctxt->func->cfpoints,setStepEPBp,STEP,
- cctxt->func->mod->c_name);
+ if (srcMode == SRC_CMODE) {
+ /* for all execution points in this function */
+ applyToSet(cctxt->func->cfpoints,setStepEPBp,STEP,
+ cctxt->func->mod->c_name);
- /* set a break point @ the current function's
- exit */
- setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP ,
- stepBpCB, cctxt->func->mod->c_name,
- cctxt->func->exitline);
+ /* set a break point @ the current function's
+ exit */
+ setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP ,
+ stepBpCB, cctxt->func->mod->c_name,
+ cctxt->func->exitline);
- /* now break point @ callers execution points */
- if ((func = STACK_PPEEK(callStack))) {
- applyToSet (func->cfpoints,setStepEPBp,STEP,
- func->mod->c_name);
- /* set bp @ callers exit point */
- setBreakPoint (func->sym->eaddr, CODE, STEP ,
- stepBpCB, func->mod->c_name,
- func->exitline);
- }
- } else {
- /* for all execution points in this function */
- applyToSet(cctxt->func->afpoints,setStepEPBp,STEP,
- cctxt->func->mod->asm_name);
+ /* now break point @ callers execution points */
+ if ((func = STACK_PPEEK(callStack))) {
+ applyToSet (func->cfpoints,setStepEPBp,STEP,
+ func->mod->c_name);
+ /* set bp @ callers exit point */
+ setBreakPoint (func->sym->eaddr, CODE, STEP ,
+ stepBpCB, func->mod->c_name,
+ func->exitline);
+ }
+ } else {
+ /* for all execution points in this function */
+ applyToSet(cctxt->func->afpoints,setStepEPBp,STEP,
+ cctxt->func->mod->asm_name);
- /* set a break point @ the current function's
- exit */
- setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP ,
- stepBpCB, cctxt->func->mod->asm_name,
- cctxt->func->aexitline);
+ /* set a break point @ the current function's
+ exit */
+ setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP ,
+ stepBpCB, cctxt->func->mod->asm_name,
+ cctxt->func->aexitline);
- /* now break point @ callers execution points */
- if ((func = STACK_PPEEK(callStack))) {
+ /* now break point @ callers execution points */
+ if ((func = STACK_PPEEK(callStack))) {
- applyToSet (func->afpoints,setStepEPBp,STEP,
- func->mod->asm_name);
+ applyToSet (func->afpoints,setStepEPBp,STEP,
+ func->mod->asm_name);
- /* set bp @ callers exit point */
- setBreakPoint (func->sym->eaddr, CODE, STEP ,
- stepBpCB, func->mod->asm_name,
- func->aexitline);
- }
- }
- }
+ /* set bp @ callers exit point */
+ setBreakPoint (func->sym->eaddr, CODE, STEP ,
+ stepBpCB, func->mod->asm_name,
+ func->aexitline);
+ }
+ }
+ }
- simGo(-1);
+ doingSteps = 1;
+ simGo(2);
+ doingSteps = 0;
+ showfull = 1;
}
return 0;
}
+/*-----------------------------------------------------------------*/
+/* cmdNexti - next instruction but proceed function call */
+/*-----------------------------------------------------------------*/
+int cmdNexti (char *s, context *cctxt)
+{
+ if (STACK_EMPTY(callStack))
+ fprintf(stdout,"The program is not being run.\n");
+ else
+ {
+ doingSteps = 2;
+ simGo(1);
+ doingSteps = 0;
+ showfull = 1;
+ }
+ return 0;
+}
+
/*-----------------------------------------------------------------*/
/* cmdNext - next executable C statement file */
/*-----------------------------------------------------------------*/
/* next is almost the same as step except we don't
we don't set break point for all function entry
points */
- if (!cctxt || !cctxt->func || !cctxt->func->mod)
- fprintf(stdout,"The program is not being run.\n");
+ if (STACK_EMPTY(callStack))
+ fprintf(stdout,"The program is not being run.\n");
else {
-
- /* if we are @ the end of a function then set
- break points at execution points of the
- function in the call stack... */
- if (cctxt->addr == cctxt->func->sym->eaddr) {
- if ((func = STACK_PEEK(callStack))) {
- if (srcMode == SRC_CMODE)
- applyToSet (func->cfpoints,setStepEPBp,STEP,
- func->mod->c_name);
- else
- applyToSet (func->afpoints,setStepEPBp,STEP,
- func->mod->asm_name);
- }
- } else {
- if (srcMode == SRC_CMODE) {
- /* for all execution points in this function */
- applyToSet(cctxt->func->cfpoints,setNextEPBp,NEXT,
- cctxt->func->mod->c_name);
- /* set a break point @ the current function's
- exit */
- setBreakPoint (cctxt->func->sym->eaddr, CODE, NEXT ,
- nextBpCB, cctxt->func->mod->c_name,
- cctxt->func->exitline);
+ /* if we are @ the end of a function then set
+ break points at execution points of the
+ function in the call stack... */
+ if (cctxt->addr == cctxt->func->sym->eaddr) {
+ if ((func = STACK_PEEK(callStack))) {
+ if (srcMode == SRC_CMODE)
+ applyToSet (func->cfpoints,setStepEPBp,NEXT,
+ func->mod->c_name);
+ else
+ applyToSet (func->afpoints,setStepEPBp,NEXT,
+ func->mod->asm_name);
+ }
+ } else {
+ if (srcMode == SRC_CMODE) {
+ /* for all execution points in this function */
+ applyToSet(cctxt->func->cfpoints,setNextEPBp,NEXT,
+ cctxt->func->mod->c_name);
+ /* set a break point @ the current function's
+ exit */
+ setBreakPoint (cctxt->func->sym->eaddr, CODE, NEXT ,
+ nextBpCB, cctxt->func->mod->c_name,
+ cctxt->func->exitline);
- /* now break point @ callers execution points */
- if ((func = STACK_PPEEK(callStack))) {
- applyToSet (func->cfpoints,setNextEPBp,NEXT ,
- func->mod->c_name);
- /* set bp @ callers exit point */
- setBreakPoint (func->sym->eaddr, CODE, NEXT ,
- stepBpCB, func->mod->c_name,
- func->exitline);
- }
- } else {
- /* for all execution points in this function */
- applyToSet(cctxt->func->afpoints,setNextEPBp,NEXT,
- cctxt->func->mod->asm_name);
- /* set a break point @ the current function's
- exit */
- setBreakPoint (cctxt->func->sym->eaddr, CODE, NEXT ,
- nextBpCB, cctxt->func->mod->asm_name,
- cctxt->func->aexitline);
+ /* now break point @ callers execution points */
+ if ((func = STACK_PPEEK(callStack))) {
+ applyToSet (func->cfpoints,setNextEPBp,NEXT ,
+ func->mod->c_name);
+ /* set bp @ callers exit point */
+ setBreakPoint (func->sym->eaddr, CODE, NEXT ,
+ stepBpCB, func->mod->c_name,
+ func->exitline);
+ }
+ } else {
+ /* for all execution points in this function */
+ applyToSet(cctxt->func->afpoints,setNextEPBp,NEXT,
+ cctxt->func->mod->asm_name);
+ /* set a break point @ the current function's
+ exit */
+ setBreakPoint (cctxt->func->sym->eaddr, CODE, NEXT ,
+ nextBpCB, cctxt->func->mod->asm_name,
+ cctxt->func->aexitline);
- /* now break point @ callers execution points */
- if ((func = STACK_PPEEK(callStack))) {
- applyToSet (func->cfpoints,setNextEPBp,NEXT ,
- func->mod->asm_name);
- /* set bp @ callers exit point */
- setBreakPoint (func->sym->eaddr, CODE, NEXT ,
- stepBpCB, func->mod->asm_name,
- func->aexitline);
- }
- }
- simGo(-1);
- }
+ /* now break point @ callers execution points */
+ if ((func = STACK_PPEEK(callStack))) {
+ applyToSet (func->cfpoints,setNextEPBp,NEXT ,
+ func->mod->asm_name);
+ /* set bp @ callers exit point */
+ setBreakPoint (func->sym->eaddr, CODE, NEXT ,
+ stepBpCB, func->mod->asm_name,
+ func->aexitline);
+ }
+ }
+ }
+ doingSteps = 1;
+ simGo(1);
+ doingSteps = 0;
+ showfull = 1;
}
return 0;
}
int cmdRun (char *s, context *cctxt)
{
char buff[10];
- if (!cctxt || !cctxt->func || !cctxt->func->mod) {
+ if (STACK_EMPTY(callStack)) {
fprintf(stdout,"Starting program\n");
+ if ( ! simactive )
+ {
+ fprintf(stdout,"No executable file specified.\nUse the \"file\" command.\n");
+ return 0;
+ }
+ resetHitCount();
simGo(0);
} else {
fgets(buff,sizeof(buff),stdin);
if (toupper(buff[0]) == 'Y') {
simReset();
+ resetHitCount();
simGo(0);
}
}
-
+ showfull = 1;
return 0;
}
if (f == NULL)
break;
if (our_verbose) {
- printf(" %d) sym:%x, modName:%s, mod:%x\n", i,
- f->sym, f->modName, f->mod);
+ printf(" %d) sym:%x, fname:%s, modName:%s, mod:%x\n", i,
+ f->sym, f->sym->name, f->modName, f->mod);
printf(" entryline:%d, aentryline:%d, exitline:%d, aexitline:%d\n",
f->entryline, f->aentryline, f->exitline, f->aexitline);
printf(" cfpoints:%x, afpoints:%x, laddr:%x, lline:%d\n",
printf(" cLines:%x, asmLines:%x\n",
m->cLines, m->asmLines);
}
- if (our_verbose > 2) {
- i = 0;
- if (m->cLines) {
- cs = m->cLines[i++];
+ if (our_verbose >= 2) {
+ if (m->ncLines) {
printf(" [cLines] ");
- while (cs) {
- if (our_verbose)
+ if ( our_verbose)
+ for (i=0; i<m->ncLines; i++ ) {
+ cs = m->cLines[i];
printf(" (%d) addr:%x, block:%d, level:%d, src:%s\n",
i, cs->addr, cs->block, cs->level, cs->src);
- cs = m->cLines[i++];
}
if (!our_verbose)
printf("%d records", i);
}
- i = 0;
- if (m->asmLines) {
- as = m->asmLines[i++];
+ if (m->nasmLines) {
printf(" [asmLines] ");
- while (as) {
- if (our_verbose)
+ if ( our_verbose)
+ for (i=0; i<m->nasmLines; i++ ) {
+ as = m->asmLines[i];
printf(" (%d) addr:%x, block:%d, level:%d, src:%s\n",
i, as->addr, as->block, as->level, as->src);
- as = m->asmLines[i++];
}
if (!our_verbose)
printf("%d records", i);
}
+/*-----------------------------------------------------------------*/
+/* infoRegisters - print register information */
+/*-----------------------------------------------------------------*/
+static void infoRegisters( int all, context *ctxt)
+{
+ static unsigned int regaddrs[] = {0x81,0x82,0x83,0xd0,0xe0,0xf0,0};
+ unsigned long val;
+ int i,j,*r;
+
+ i = simGetValue (0xd0,'I',1);
+ fprintf(stdout,"PC : 0x%04X RegisterBank %d:\nR0-7:",ctxt->addr,(i>>3)&3);
+ for ( j = 0; j < 8 ; j++ )
+ {
+ val = simGetValue (j ,'R',1);
+ fprintf(stdout," 0x%02X",val);
+ }
+ fprintf(stdout,"\n");
+ val = simGetValue (0xe0,'I',1);
+ fprintf(stdout,"ACC : 0x%02X %d %c\n",val,val,(isprint(val) ? val : '.'));
+ val = simGetValue (0xf0,'I',1);
+ fprintf(stdout,"B : 0x%02X %d %c\n",val,val,(isprint(val) ? val : '.'));
+ val = simGetValue (0x82,'I',2);
+ fprintf(stdout,"DPTR: 0x%04X %d\n",val,val);
+ val = simGetValue (0x81,'I',1);
+ fprintf(stdout,"SP : 0x%02X\n",val);
+ fprintf(stdout,"PSW : 0x%02X | CY : %c | AC : %c | OV : %c | P : %c\n",
+ i,(i&0x80)?'1':'0',(i&0x40)?'1':'0',(i&4)?'1':'0',(i&1)?'1':'0');
+ if ( all )
+ {
+ fprintf(stdout,"Special Function Registers:\n");
+ r = regaddrs;
+ for ( i = 0x80 ; i < 0x100 ; i++ )
+ {
+ symbol *sym = NULL;
+ if ( *r && *r == i )
+ {
+ /* skip normal registers */
+ r++ ;
+ continue;
+ }
+ if (applyToSetFTrue(sfrsymbols,symWithAddr,i,'I',&sym))
+ {
+ val = simGetValue (sym->addr,sym->addrspace,sym->size);
+ fprintf(stdout,"%s : 0x%02x",sym->name,val);
+ if ( !(i & 0x07 ))
+ {
+ for ( j = 0 ; j < 8 ; j++ )
+ {
+ sym = NULL;
+ if (applyToSetFTrue(sfrsymbols,symWithAddr,i+j,'J',&sym))
+ {
+ //val = simGetValue (sym->addr,sym->addrspace,sym->size);
+ fprintf(stdout," %s=%c",sym->name,(val&1)? '1':'0');
+ }
+ val >>= 1;
+ }
+ }
+ fprintf(stdout,"\n");
+ }
+ }
+ }
+}
+
/*-----------------------------------------------------------------*/
/* infoStack - print call stack information */
/*-----------------------------------------------------------------*/
STACK_STARTWALK(callStack) ;
while ((func = STACK_WALK(callStack))) {
+ Dprintf(D_break, ("break: infoStack: %s %p (%p)\n",func->sym->name, w_callStack,p_callStack));
- fprintf(stdout,"#%d 0x%04x %s () at %s:%d\n",i++,
+ fprintf(stdout,"#%d 0x%08x in %s () at %s:%d\n",i++,
func->laddr,func->sym->name,
- func->mod->c_name,func->lline);
+ func->mod->c_name,func->lline+1);
}
+ if ( !i )
+ fprintf(stdout,"no stack.\n");
+}
+/*-----------------------------------------------------------------*/
+/* cmdWhere - where command */
+/*-----------------------------------------------------------------*/
+int cmdWhere(char *s, context *cctxt)
+{
+ infoStack(cctxt);
+ return 0;
}
+
+static int infomode = 0;
/*-----------------------------------------------------------------*/
/* cmdInfo - info command */
/*-----------------------------------------------------------------*/
while (isspace(*s)) s++;
/* list all break points */
- if (strcmp(s,"break") == 0) {
+ if (strncmp(s,"break",5) == 0) {
listUSERbp();
return 0;
}
return 0;
}
+ if (strncmp(s,"line",4) == 0) {
+ infomode=1;
+ cmdListSrc (s+4,cctxt);
+ return 0;
+ }
+ if (strncmp(s,"source",6) == 0)
+ {
+ module *m;
+ if ( s[6] == 's' )
+ {
+ int k = 0;
+ fprintf(stdout,"Source files for which symbols have been read in:\n\n");
+ for (m = setFirstItem(modules); m ; m = setNextItem(modules))
+ {
+ fprintf(stdout,"%s%s, %s",k ? ", ":"",m->cfullname, m->afullname);
+ k = 1;
+ }
+ fprintf(stdout,"\n");
+ }
+ else
+ {
+ if (!cctxt || !cctxt->func || !cctxt->func->mod)
+ {
+ fprintf(stdout,"No source file loaded\n");
+ return 0;
+ }
+ m = cctxt->func->mod;
+ fprintf(stdout,"Current source file is %s\n",m->c_name);
+ fprintf(stdout,"Located in %s\n",m->cfullname);
+ fprintf(stdout,"Contains %d lines.\nSource language is c.\n",
+ m->ncLines);
+ }
+ return 0;
+ }
+ if (strncmp(s,"functions",7) == 0)
+ {
+ function *f;
+ module *m = NULL;
+ fprintf(stdout,"All defined functions:\n");
+ for ( f = setFirstItem(functions); f ; f = setNextItem(functions))
+ {
+ if ( f->mod != m )
+ {
+ m = f->mod;
+ fprintf(stdout,"\nFile %s\n", m->c_name);
+ }
+ fprintf(stdout,"%s();\n",f->sym->name);
+ }
+ return 0;
+ }
/* info stack display call stack */
if (strcmp(s,"stack") == 0) {
infoStack(cctxt);
+ showfull = 1;
return 0;
}
/* info stack display call stack */
if (strcmp(s,"registers") == 0) {
- fprintf(stdout,"%s",simRegs());
- return 0;
+ infoRegisters(0,cctxt);
+ return 0;
+ }
+
+ /* info stack display call stack */
+ if (strcmp(s,"all-registers") == 0)
+ {
+ infoRegisters(1,cctxt);
+ return 0;
}
/* info stack display call stack */
return 0;
}
+ if (strcmp(s,"variables") == 0) {
+ /* dump out symbols we have read in */
+ fprintf(stdout,"Dumping symbols...\n");
+ infoSymbols(cctxt);
+ return 0;
+ }
+
fprintf(stdout,"Undefined info command: \"%s\". Try \"help\n",s);
return 0;
static int currline = 0;
int i =0 ;
int pline = 0;
- int llines = listLines;
+ int llines = listlines;
+ function *func = NULL;
+
while (*s && isspace(*s)) s++;
can be of the following formats
LINE - just line number
FILE:LINE - filename line number
+ FILE:LINE,LASTLINE + last line
FUNCTION - list a function
FILE:FUNCTION - function in file */
if (*s) {
/* case a) LINE */
if (isdigit(*s)) {
- sscanf(s,"%d",&pline);
if (!cctxt || !cctxt->func || !cctxt->func->mod) {
if (!list_mod) {
fprintf(stdout,"Sdcdb fails to have a proper context at %d.\n", __LINE__);
}
else
list_mod = cctxt->func->mod;
+ pline = strtol(s,&s,10) - 1;
+ if (s && (s = strchr(s,',')))
+ {
+ /* LINE,LASTLINE */
+ llines = strtol(s+1,0,10);
+ if ( llines > 0 )
+ llines -= pline+1;
+ else
+ llines = listlines;
+ }
}
else {
char *bp;
- function *func = NULL;
/* if ':' present then FILE:LINE || FILE:FUNCTION */
if ((bp = strchr(s,':'))) {
return 0;
}
}
- sscanf(bp,"%d",&pline);
+ pline = strtol(bp,&bp,10) - 1;
+ if (bp && (bp = strchr(bp,',')))
+ {
+ /* FILE:LINE,LASTLINE */
+ llines = strtol(bp+1,0,10);
+ if ( llines > 0 )
+ llines -= pline+1;
+ else
+ llines = listlines;
+ }
} else {
/* FILE:FUCTION */
if (!applyToSet(functions,funcWithNameModule,bp,s,&func)) {
}
else {
/* FUNCTION */
+ if (*s == '\'')
+ {
+ /* 'FUNCTION' */
+ s++ ;
+ if ((bp = strrchr(s,'\'')))
+ {
+ *bp = '\0';
+ }
+
+ }
if (!applyToSet(functions,funcWithName,s,&func)) {
fprintf(stderr,"Function \"%s\" not defined.\n",s);
return 0;
fprintf(stdout,"Sdcdb fails to have a valid module context at %d.\n", __LINE__);
return 0;
}
-
- if (llines > listLines) llines = listLines;
+ if ( pline < 0 )
+ return 0;
+ if ( infomode )
+ {
+ int firstaddr , lastaddr ;
+ if ( pline >= list_mod->ncLines )
+ pline = cctxt->cline;
+ firstaddr = lastaddr = list_mod->cLines[pline]->addr;
+ if (!func && cctxt && cctxt->func )
+ func = cctxt->func;
+ fprintf(stdout,"Line %d of \"%s\" starts at address 0x%08x <%s+%d>",
+ pline+1,
+ list_mod->c_name, lastaddr,
+ func ? func->sym->name : "?",
+ func ? lastaddr -func->sym->addr : 0);
+ llines = pline +1;
+ while ( pline < list_mod->ncLines )
+ {
+ pline++;
+ if ( list_mod->cLines[pline]->addr > lastaddr )
+ {
+ lastaddr = list_mod->cLines[pline]->addr -1;
+ break;
+ }
+ }
+ fprintf(stdout," and ends at 0x%08x <%s+%d>.\n",
+ lastaddr,
+ func ? func->sym->name : "?",
+ func ? lastaddr -func->sym->addr : 0);
+ infomode=0;
+ if ( func )
+ fprintf(stdout,"\032\032%s:%d:1:beg:0x%08x\n",
+ func->mod->cfullname,
+ llines,firstaddr);
+ else
+ showfull=1;
+ return 0;
+ }
for ( i = 0 ; i < llines ; i++ ) {
if (srcMode == SRC_CMODE) {
if ( (pline + i) >= list_mod->ncLines )
return 0;
}
+static unsigned long getValBasic(symbol *sym, link *type, char *val)
+{
+ char *s;
+ union
+ {
+ float f;
+ unsigned long val;
+ long sval;
+ struct {
+ unsigned short lo;
+ unsigned short hi;
+ } i;
+ unsigned char b[4];
+ }v;
+
+ if (IS_FLOAT(type))
+ v.f = strtod(val,NULL);
+ else
+ if (IS_PTR(type))
+ v.val = strtol(val,NULL,0);
+ else
+ {
+ if (IS_INTEGRAL(type))
+ {
+ link *etype;
+ if ( type->next )
+ etype = type->next;
+ else
+ etype = type;
+ if (IS_CHAR(etype))
+ {
+ if (( s = strchr(val,'\'')))
+ {
+ if ( s[1] == '\\' )
+ v.b[0] = strtol(s+2,NULL,8);
+ else
+ v.b[0] = s[1];
+ }
+ else
+ {
+ v.b[0] = strtol(val,NULL,0);
+ }
+ }
+ else
+ if (IS_INT(etype))
+ if (IS_LONG(etype))
+ v.val = strtol(val,NULL,0);
+ else
+ v.i.lo = strtol(val,NULL,0);
+ else
+ v.val = strtol(val,NULL,0);
+ }
+ else
+ v.val = strtol(val,NULL,0);
+ }
+ return v.val;
+}
+
+/*-----------------------------------------------------------------*/
+/* printFmtInteger - print value in bin,oct,dez or hex */
+/*-----------------------------------------------------------------*/
+static void printFmtInteger(char *deffmt,int fmt, long val,
+ int sign, int size)
+{
+ static char digits[] =
+ {
+ '0' , '1' , '2' , '3' , '4' , '5' ,
+ '6' , '7' , '8' , '9' , 'a' , 'b' ,
+ 'c' , 'd' , 'e' , 'f' , 'g' , 'h'
+ };
+ static int radixOfFormat[] = { 0 , 2, 8 ,10, 16 };
+ static int olenOfSize[] = { 0 , 3, 6 , 8, 11 };
+ char buf[40];
+ char negative = 0;
+ int charPos = 38;
+ int radix;
+
+ if ( fmt == FMT_NON || fmt == FMT_DEZ )
+ {
+ fprintf(stdout,deffmt,val);
+ return;
+ }
+ radix = radixOfFormat[fmt];
+
+ /*
+ if ( sign && val < 0 )
+ negative = 1;
+ */
+
+ if (!negative)
+ val = -val;
+
+ buf[39] = '\0';
+ while (val <= -radix)
+ {
+ buf[charPos--] = digits[-(val % radix)];
+ val = val / radix;
+ }
+ buf[charPos] = digits[-val];
+
+ switch ( fmt )
+ {
+ case FMT_OCT:
+ radix = olenOfSize[size];
+ break;
+ case FMT_HEX:
+ radix = size << 1;
+ break;
+ case FMT_BIN:
+ radix = size << 3;
+ break;
+ }
+
+ while (charPos > 39 - radix )
+ {
+ buf[--charPos] = '0';
+ }
+ switch ( fmt )
+ {
+ case FMT_OCT:
+ if ( buf[charPos] != '0' )
+ buf[--charPos] = '0';
+ break;
+ case FMT_HEX:
+ buf[--charPos] = 'x';
+ buf[--charPos] = '0';
+ break;
+ }
+ if (negative) {
+ buf[--charPos] = '-';
+ }
+ fputs(&buf[charPos],stdout);
+}
+
/*-----------------------------------------------------------------*/
/* printValBasic - print value of basic types */
/*-----------------------------------------------------------------*/
-static void printValBasic(symbol *sym,unsigned addr,char mem, int size)
+static void printValBasic(symbol *sym, link *type,
+ char mem, unsigned addr,int size, int fmt)
{
union {
float f;
unsigned long val;
long sval;
struct {
- short lo;
- short hi;
+ unsigned short lo;
+ unsigned short hi;
} i;
unsigned char b[4];
}v;
v.val = simGetValue(addr,mem,size);
/* if this a floating point number then */
- if (IS_FLOAT(sym->type))
+ if (IS_FLOAT(type))
fprintf(stdout,"%f",v.f);
else
- if (IS_PTR(sym->type))
- fprintf(stdout,"0x%x",v.val);
+ if (IS_PTR(type))
+ fprintf(stdout,"0x%*x",size<<1,v.val);
else
- if (IS_SPEC(sym->type) && IS_INTEGRAL(sym->type)) {
- if (IS_CHAR(sym->etype))
- fprintf(stdout,"'%c' %d 0x%x",v.val,v.val,v.val);
- else
- if (IS_INT(sym->etype))
- if (IS_LONG(sym->etype))
- if (SPEC_USIGN(sym->etype))
- fprintf(stdout,"%d 0x%x",v.val,v.val);
- else
- fprintf(stdout,"%d 0x%x",v.sval,v.sval);
- else
- fprintf(stdout,"%d 0x%x",v.i.lo,v.i.lo);
- else
- fprintf(stdout,"0x%x",v.val);
+ if (IS_INTEGRAL(type))
+ {
+ link *etype;
+ if ( type->next )
+ etype = type->next;
+ else
+ etype = type;
+ if (IS_CHAR(etype))
+ {
+ if ( isprint(v.val))
+ printFmtInteger((SPEC_USIGN(etype)?"0x%02x":"'%c'"),
+ fmt,(long)v.val,0,size);
+ else
+ printFmtInteger((SPEC_USIGN(etype)?"0x%02x":"'\\%o'"),
+ fmt,(long)v.val,0,size);
+ }
+ else
+ {
+ if (IS_INT(etype))
+ if (IS_LONG(etype))
+ if (SPEC_USIGN(etype))
+ printFmtInteger("%u",fmt,(long)v.val,0,size);
+ else
+ printFmtInteger("%d",fmt,(long)v.sval,1,size);
+ else
+ if (SPEC_USIGN(etype))
+ printFmtInteger("%u",fmt,(long)v.i.lo,0,size);
+ else
+ printFmtInteger("%d",fmt,(long)v.i.lo,1,size);
+ else
+ {
+ if (IS_BITVAR(etype))
+ fprintf(stdout,"%c",(v.val?'1':'0'));
+ else
+ fprintf(stdout,"0x%0*x",size<<1,v.val);
+ }
+ }
} else
- fprintf(stdout,"0x%x",v.val);
-
-
+ fprintf(stdout,"0x%0*x",size<<1,v.val);
}
/*-----------------------------------------------------------------*/
/* printValFunc - prints function values */
/*-----------------------------------------------------------------*/
-static void printValFunc (symbol *sym)
+static void printValFunc (symbol *sym, int fmt)
{
- fprintf(stdout,"print function not yet implemented\n");
+ fprintf(stdout,"print function not yet implemented");
}
/*-----------------------------------------------------------------*/
/* printArrayValue - will print the values of array elements */
/*-----------------------------------------------------------------*/
-static void printArrayValue (symbol *sym, char space, unsigned int addr)
+static void printArrayValue (symbol *sym, link *type,
+ char space, unsigned int addr, int fmt)
{
- link *elem_type = sym->type->next;
+ link *elem_type = type->next;
int i;
- fprintf(stdout," { ");
- for (i = 0 ; i < DCL_ELEM(sym->type) ; i++) {
+ fprintf(stdout,"{");
+ for (i = 0 ; i < DCL_ELEM(type) ; i++) {
if (IS_AGGREGATE(elem_type)) {
- printValAggregates(sym,elem_type,space,addr);
+ printValAggregates(sym,elem_type,space,addr,fmt);
} else {
- printValBasic(sym,addr,space,getSize(elem_type));
+ printValBasic(sym,elem_type,space,addr,getSize(elem_type),fmt);
}
addr += getSize(elem_type);
- if (i != DCL_ELEM(sym->type) -1)
+ if (i != DCL_ELEM(type) -1)
fprintf(stdout,",");
}
- fprintf(stdout,"}\n");
+ fprintf(stdout,"}");
}
/*-----------------------------------------------------------------*/
/* printStructValue - prints structures elements */
/*-----------------------------------------------------------------*/
-static void printStructValue (symbol *sym,link *type, char space, unsigned int addr)
+static void printStructValue (symbol *sym, link *type,
+ char space, unsigned int addr, int fmt)
{
symbol *fields = SPEC_STRUCT(type)->fields;
-
+ int first = 1;
fprintf(stdout," { ");
while (fields) {
- fprintf(stdout,"%s = ",fields->name);
- if (IS_AGGREGATE(fields->type)) {
- printValAggregates(fields,fields->type,space, addr);
+ fprintf(stdout,"%s%s = ",(first ? "": ", "),fields->name);
+ first = 0;
+ if (IS_AGGREGATE(fields->type)) {
+ printValAggregates(fields,fields->type,space, addr, fmt);
} else {
- printValBasic(fields,addr,space,getSize(fields->type));
+ printValBasic(fields,fields->type,space,addr,getSize(fields->type), fmt);
}
addr += getSize(fields->type);
fields = fields->next;
}
- fprintf(stdout,"}\n");
+ fprintf(stdout,"}");
}
/*-----------------------------------------------------------------*/
/* printValAggregates - print value of aggregates */
/*-----------------------------------------------------------------*/
-static void printValAggregates (symbol *sym, link *type,char space,unsigned int addr)
+static void printValAggregates (symbol *sym, link *type,
+ char space,unsigned int addr, int fmt)
{
if (IS_ARRAY(type)) {
- printArrayValue(sym, space, addr);
+ printArrayValue(sym, type, space, addr, fmt);
return ;
}
if (IS_STRUCT(type)) {
- printStructValue(sym,sym->type,space, addr);
+ printStructValue(sym, type, space, addr, fmt);
return;
}
}
/*-----------------------------------------------------------------*/
-/* printSymValue - print value of a symbol */
+/* printOrSetSymValue - print or set value of a symbol */
/*-----------------------------------------------------------------*/
-static void printSymValue (symbol *sym, context *cctxt)
+static int printOrSetSymValue (symbol *sym, context *cctxt,
+ int flg, int dnum, int fmt, char *rs,
+ char *val, char cmp )
{
+ static char fmtChar[] = " todx ";
static int stack = 1;
- unsigned long val;
+ symbol *fields;
+ link *type;
+ unsigned int addr;
+ int size, n;
+ char *s, *s2;
+ char save_ch, save_ch2;
+
/* if it is on stack then compute address & fall thru */
- if (sym->isonstack) {
- symbol *bp = symLookup("bp",cctxt);
- if (!bp) {
- fprintf(stdout,"cannot determine stack frame\n");
- return ;
- }
+ if (sym->isonstack)
+ {
+ symbol *bp = symLookup("bp",cctxt);
+ if (!bp)
+ {
+ fprintf(stdout,"cannot determine stack frame\n");
+ return 1;
+ }
- sym->addr = simGetValue(bp->addr,bp->addrspace,bp->size)
- + sym->offset ;
+ sym->addr = simGetValue(bp->addr,bp->addrspace,bp->size)
+ + sym->offset ;
}
/* get the value from the simulator and
print it */
- fprintf(stdout,"$%d = ",stack++);
+ switch (flg)
+ {
+ case 0:
+ default:
+ break;
+ case 1:
+ fprintf(stdout,"$%d = ",stack++);
+ break;
+ case 2:
+ fprintf(stdout,"%d: ", dnum);
+ if ( fmt != FMT_NON )
+ fprintf(stdout,"/%c ",fmtChar[fmt]);
+ fprintf(stdout,"%s%s = ",sym->name,rs);
+ break;
+ }
+
+ addr = sym->addr;
+ type = sym->type;
+ size = sym->size;
+
+ while ( *rs )
+ {
+ if ( *rs == '[' && IS_ARRAY(type))
+ {
+ s = rs+1;
+ while ( *rs && *rs != ']' ) rs++ ;
+ save_ch = *rs;
+ *rs = '\0' ;
+ if ( ! isdigit(*s ))
+ {
+ /* index seems a variable */
+ for ( s2 = s; *s2 && ( isalnum( *s2 ) || *s2 == '_'); s2++ );
+ save_ch2 = *s2;
+ if ( *s2 )
+ *s2 = '\0';
+ fields = symLookup(s,cctxt);
+ *s2 = save_ch2;
+ if ( ! fields )
+ {
+ fprintf(stdout,"Unknown variable \"%s\" for index.\n", s);
+ return 1;
+ }
+ /* arrays & structures first */
+ if (! IS_INTEGRAL(fields->type))
+ {
+ fprintf(stdout,"Wrong type of variable \"%s\" for index \n", s);
+ return 1;
+ }
+ n = simGetValue(fields->addr,fields->addrspace,getSize(fields->type));
+ }
+ else
+ {
+ n = strtol(s,0,0);
+ }
+ if ( n < 0 || n >= DCL_ELEM(type))
+ {
+ fprintf(stdout,"Wrong index %d.\n", n);
+ return 1;
+ }
+ type = type->next;
+ size = getSize(type);
+ addr += size * n;
+ *rs++ = save_ch;
+ }
+ else if ( *rs == '.' && IS_STRUCT(type))
+ {
+ s = rs+1;
+ /* search structure element */
+ for ( rs = s; *rs && ( isalnum( *rs ) || *rs == '_'); rs++ );
+ save_ch = *rs;
+ if ( *rs )
+ *rs = '\0';
+ for (fields = SPEC_STRUCT(type)->fields; fields; fields = fields->next)
+ {
+ if (!(strcmp(s,fields->name)))
+ break;
+ }
+ *rs = save_ch;
+ if ( ! fields )
+ {
+ fprintf(stdout,"Unknown field \"%s\" of structure\n", s);
+ return 1;
+ }
+ type = fields->type;
+ size = getSize(type);
+ addr += fields->offset;
+ }
+ else
+ break;
+ }
+
/* arrays & structures first */
- if (IS_AGGREGATE(sym->type))
- printValAggregates(sym,sym->type,sym->addrspace,sym->addr);
+ if (IS_AGGREGATE(type))
+ {
+ if ( val )
+ {
+ fprintf(stdout,"Cannot set/compare aggregate variable\n");
+ return 1;
+ }
+ else
+ printValAggregates(sym,type,sym->addrspace,addr,fmt);
+ }
else
/* functions */
- if (IS_FUNC(sym->type))
- printValFunc(sym);
- else {
- printValBasic(sym,sym->addr,sym->addrspace,sym->size);
- fprintf(stdout,"\n");
- //fprintf(stdout,"(BASIC %x,%c,%d)\n",sym->addr,sym->addrspace,sym->size);
- }
+ if (IS_FUNC(type))
+ {
+ if ( !val )
+ printValFunc(sym,fmt);
+ else
+ return 1;
+ }
+ else
+ {
+ if ( val )
+ {
+ unsigned long newval;
+ newval = getValBasic(sym,type,val);
+
+ if ( cmp )
+ {
+ unsigned long lval;
+ lval = simGetValue(addr,sym->addrspace,size);
+ switch ( cmp )
+ {
+ case '<' : return ( lval < newval ? 1:0 ); break;
+ case '>' : return ( lval > newval ? 1:0 ); break;
+ case 'l' : return ( lval <= newval ? 1:0 ); break;
+ case 'g' : return ( lval >= newval ? 1:0 ); break;
+ case '=' : return ( lval == newval ? 1:0 ); break;
+ case '!' : return ( lval != newval ? 1:0 ); break;
+ }
+ }
+ else
+ {
+ simSetValue(addr,sym->addrspace,size,newval);
+ return 1;
+ }
+ }
+ else
+ printValBasic(sym,type,sym->addrspace,addr,size,fmt);
+ }
+ if ( flg > 0 ) fprintf(stdout,"\n");
+ return 0;
}
/*-----------------------------------------------------------------*/
}
}
+/*-----------------------------------------------------------------*/
+/* conditionIsTrue - compare variable with constant value */
+/*-----------------------------------------------------------------*/
+int conditionIsTrue( char *s, context *cctxt)
+{
+ symbol *sym = NULL;
+ int fmt;
+ char *rs, *dup, cmp_char;
+ dup = s = Safe_strdup(s);
+ if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )) || !sym)
+ fmt = 1;
+ else if (!( s = strpbrk(rs,"<>=!")))
+ fmt = 1;
+ else
+ {
+ cmp_char = *s;
+ *s++ = '\0';
+ if ( *s == '=' )
+ {
+ /* if <= or >= an other char is used
+ * == or != not checked in switch
+ */
+ switch( cmp_char )
+ {
+ case '>': cmp_char = 'g' ; break;
+ case '<': cmp_char = 'l' ; break;
+ }
+ s++ ;
+ }
+ while (isspace(*s)) *s++ = '\0';
+ fmt = printOrSetSymValue(sym,cctxt,0,0,0,rs,s,cmp_char);
+ }
+ Safe_free(dup);
+ return fmt;
+}
+
/*-----------------------------------------------------------------*/
/* cmdPrint - print value of variable */
/*-----------------------------------------------------------------*/
int cmdPrint (char *s, context *cctxt)
{
symbol *sym ;
- char *bp = s+strlen(s) -1;
+ int fmt;
+ char *rs;
+ if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
+ return 0;
+
+ if ( sym )
+ {
+ printOrSetSymValue(sym,cctxt,1,0,fmt,rs,NULL,'\0');
+ }
+ return 0;
+}
- while (isspace(*s)) s++;
- if (!*s) return 0;
- while (isspace(*bp)) bp--;
- bp++ ;
- *bp = '\0';
+/*-----------------------------------------------------------------*/
+/* cmdOutput - print value of variable without number and newline */
+/*-----------------------------------------------------------------*/
+int cmdOutput (char *s, context *cctxt)
+{
+ symbol *sym ;
+ int fmt;
+ char *rs;
+ if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
+ return 0;
+
+ if ( sym )
+ {
+ printOrSetSymValue(sym,cctxt,0,0,fmt,rs,NULL,'\0');
+ }
+ return 0;
+}
- if ((sym = symLookup(s,cctxt))) {
- printSymValue(sym,cctxt);
- } else {
- fprintf(stdout,
- "No symbol \"%s\" in current context.\n",
- s);
+/** find display entry with this number */
+
+DEFSETFUNC(dsymWithNumber)
+{
+ dsymbol *dsym = item;
+ V_ARG(int , dnum);
+ V_ARG(dsymbol **,dsymp);
+
+ if ( dsym->dnum == dnum )
+ {
+ *dsymp = dsym;
+ return 1;
+ }
+ return 0;
+}
+
+/*-----------------------------------------------------------------*/
+/* displayAll - display all valid variables */
+/*-----------------------------------------------------------------*/
+void displayAll(context *cctxt)
+{
+ dsymbol *dsym;
+ symbol *sym;
+ if ( !dispsymbols )
+ return;
+ for (dsym = setFirstItem(dispsymbols);
+ dsym ;
+ dsym = setNextItem(dispsymbols))
+ {
+ if ( (sym = symLookup(dsym->name,cctxt)))
+ printOrSetSymValue(sym,cctxt,2,dsym->dnum,dsym->fmt,
+ dsym->rs,NULL,'\0');
+ }
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdDisplay - display value of variable */
+/*-----------------------------------------------------------------*/
+int cmdDisplay (char *s, context *cctxt)
+{
+ static int dnum = 1;
+ symbol *sym ;
+ int fmt;
+ char *rs;
+ if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
+ {
+ displayAll(cctxt);
+ return 0;
+ }
+
+ if ( sym )
+ {
+ dsymbol *dsym = (dsymbol *)Safe_calloc(1,sizeof(dsymbol));
+ dsym->dnum = dnum++ ;
+ dsym->name = sym->name;
+ dsym->fmt = fmt;
+ dsym->rs = gc_strdup(rs);
+ addSetHead(&dispsymbols,dsym);
+ }
+ return 0;
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdUnDisplay - undisplay value of variable */
+/*-----------------------------------------------------------------*/
+int cmdUnDisplay (char *s, context *cctxt)
+{
+ dsymbol *dsym;
+ int dnum;
+
+ while (isspace(*s)) s++;
+ if (!*s)
+ {
+ for (dsym = setFirstItem(dispsymbols);
+ dsym;
+ dsym = setNextItem(dispsymbols))
+ {
+ Safe_free(dsym->rs);
+ Safe_free(dsym);
+ }
+ deleteSet(&dispsymbols);
+ return 0;
+ }
+ while ( s && *s )
+ {
+ dnum = strtol(s,&s,10);
+ if (applyToSetFTrue(dispsymbols,dsymWithNumber,dnum,&dsym))
+ {
+ deleteSetItem(&dispsymbols,dsym);
+ Safe_free(dsym->rs);
+ Safe_free(dsym);
+ }
+ else
+ {
+ fprintf(stdout,"Arguments must be display numbers.\n");
+ }
}
return 0;
}
return 0;
}
-
/*-----------------------------------------------------------------*/
/* cmdSimulator - send command to simulator */
/*-----------------------------------------------------------------*/
return 0;
}
+void setMainContext()
+{
+ function *func = NULL;
+ currentFrame = 0;
+ if (!applyToSet(functions,funcWithName,"main",&func) &&
+ !applyToSet(functions,funcWithName,"_main",&func))
+ return;
+
+ discoverContext (func->sym->addr, func);
+}
+
+static void printFrame()
+{
+ int i;
+ function *func = NULL;
+ function *lastfunc = NULL;
+
+ if ( currentFrame < 0 )
+ {
+ currentFrame = 0;
+ fprintf(stdout,"Bottom (i.e., innermost) frame selected; you cannot go down.\n");
+ return;
+ }
+ STACK_STARTWALK(callStack) ;
+ for ( i = 0; i <= currentFrame ; i++ )
+ {
+ func = STACK_WALK(callStack);
+ if ( !func )
+ {
+ currentFrame = i-1;
+ fprintf(stdout,"Initial frame selected; you cannot go up.\n");
+ return;
+ }
+ }
+ fprintf(stdout,"#%d 0x%08x in %s () at %s:%d\n",
+ currentFrame,func->laddr,func->sym->name,func->mod->c_name,func->lline+1);
+ fprintf(stdout,"\032\032%s:%d:1:beg:0x%08x\n",
+ func->mod->cfullname,func->lline+1,func->laddr);
+
+ discoverContext (func->laddr, func);
+}
+
+
+/*-----------------------------------------------------------------*/
+/* cmdUp - Up command */
+/*-----------------------------------------------------------------*/
+int cmdUp(char *s, context *cctxt)
+{
+ while (isspace(*s)) s++;
+ if ( *s )
+ currentFrame += strtol(s,0,10);
+ else
+ currentFrame++ ;
+
+ printFrame();
+ return 0;
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdDown - down command */
+/*-----------------------------------------------------------------*/
+int cmdDown(char *s, context *cctxt)
+{
+ while (isspace(*s)) s++;
+ if ( *s )
+ currentFrame -= strtol(s,0,10);
+ else
+ currentFrame-- ;
+
+ printFrame();
+ return 0;
+}
/*-----------------------------------------------------------------*/
/* cmdFrame - Frame command */
/*-----------------------------------------------------------------*/
int cmdFrame (char *s, context *cctxt)
{
- function *func ;
-
- if ((func = STACK_PEEK(callStack))) {
- fprintf(stdout,"#0 %s () at %s:%d\n",
- func->sym->name,func->mod->c_name,cctxt->cline);
+ function *func = NULL;
+ int i, framenr = 0;
- if (cctxt->cline < func->mod->ncLines)
- fprintf(stdout,"%d\t%s",
- cctxt->cline,
- func->mod->cLines[cctxt->cline]->src);
- } else
- fprintf(stdout,"No stack.\n");
+ while (isspace(*s)) s++;
+ if ( *s )
+ currentFrame = strtol(s,0,10);
+ printFrame();
return 0;
}
/*-----------------------------------------------------------------*/
int cmdFinish (char *s, context *ctxt)
{
- if (!ctxt || ! ctxt->func) {
+ if (STACK_EMPTY(callStack)) {
fprintf(stdout,"The program is not running.\n");
return 0;
}
}
simGo(-1);
+ showfull = 1;
return 0;
}
projects / fw / sdcc / blobdiff