/* l2xiidbg.c  LTX2X interpreter debugging routines for interpreter code */
/*  Written by: Peter Wilson, CUA  [email protected]                */

#include <stdio.h>
#include "l2xicmon.h"
#include "l2xiscan.h"
#include "l2xisymt.h"
#include "l2xiexec.h"
#include "l2xiidbg.h"

/* EXTERNALS */

/* extern FILE *fcodeseg; */      /* code segment o/p file */

/* GLOBALS */

char dbuff[256];           /* a character buffer for internal use */
int dlindent = 2;            /* line indentation */
int PLEVEL = 0;            /* routine nesting level */
char dbuffer[256];         /* character buffer for external use */

/********************************************************************/
/* debug_print(s)    prints a debugging string                      */

debug_print(s)
char s[];
{
 if (DEBUG <= 0) return;

 fprintf(stderr, "%s", s);
 fflush(stderr);
 fprintf(ferr, "%s", s);
 fflush(ferr);
}                                                /* end debug_print */
/********************************************************************/



/********************************************************************/
/* log_print(s)    prints a string to the log(s)                    */

log_print(s)
char s[];
{

 fprintf(stderr, "%s", s);
 fflush(stderr);
 fprintf(ferr, "%s", s);
 fflush(ferr);
}                                                  /* end log_print */
/********************************************************************/



/********************************************************************/
/* entry_debug(s)     prints the name of a routine at entry         */

entry_debug(s)
char s[];               /* name of the routine */
{
 if (DEBUG < Dtrace) return;

 PLEVEL++;             /* increase the nesting level */
 sprintf(dbuff, "%*s Entering: %s\n", PLEVEL*dlindent, " ", s);
 debug_print(dbuff);

}                                                /* end entry_debug */
/********************************************************************/


/********************************************************************/
/* exit_debug(s)     prints the name of a routine at exit           */

exit_debug(s)
char s[];               /* name of the routine */
{
 if (DEBUG < Dtrace) return;

 sprintf(dbuff, "%*s Exiting: %s\n", PLEVEL*dlindent, " ", s);
 debug_print(dbuff);
 PLEVEL--;             /* decrement the nesting level */

}                                                /* end entry_debug */
/********************************************************************/



/********************************************************************/
/* code_segment_debug()  Prints a code segment                      */

code_segment_debug(code_segment, limit)
int *code_segment;
int *limit;

{
 int i = 0;
 SYMTAB_NODE_PTR sp;
 int cp;

/*  if (DEBUG < Dbasic) return; */

 sprintf(dbuff, "\n   CREATED CODE_SEGMENT\n");
 if (DEBUG >= Dbasic) debug_print(dbuff);
 fprintf(fcodeseg, "%s", dbuff);
 while (code_segment != limit) {
   cp = (int) *code_segment;
   if (cp == STATEMENT_MARKER) {     /* a statement marker */
     sprintf(dbuff, "%d   %d   %d    %s\n",
        code_segment, i, cp, "<statement_marker>");
     if (DEBUG >= Dbasic) debug_print(dbuff);
     fprintf(fcodeseg, "%s", dbuff);
     *code_segment++;
     i++;
     cp = (int) *code_segment;
     sprintf(dbuff, "%d   %d   %d    %s\n",
        code_segment, i, cp, "<the line number>");
     if (DEBUG >= Dbasic) debug_print(dbuff);
     fprintf(fcodeseg, "%s", dbuff);
   }
   else if (cp == ADDRESS_MARKER) {   /* an address marker */
     sprintf(dbuff, "%d   %d   %d    %s\n",
        code_segment, i, cp, "<address_marker>");
     if (DEBUG >= Dbasic) debug_print(dbuff);
     fprintf(fcodeseg, "%s", dbuff);
     *code_segment++;
     i++;
     cp = (int) *code_segment;
     sprintf(dbuff, "%d   %d   %d    %s\n",
        code_segment, i, cp, "<the address>");
     if (DEBUG >= Dbasic) debug_print(dbuff);
     fprintf(fcodeseg, "%s", dbuff);
   }
   else if (tok_code_to_str(cp) != NULL) {            /* a token code */
     sprintf(dbuff, "%d   %d   %d    %s\n",
        code_segment, i, cp, tok_code_to_str(cp));
     if (DEBUG >= Dbasic) debug_print(dbuff);
     fprintf(fcodeseg, "%s", dbuff);
   }
   else {                                /* should be a symtab node ptr */
     sprintf(dbuff, "%d   %d   %d",
        code_segment, i, cp);
     if (DEBUG >= Dbasic) debug_print(dbuff);
     fprintf(fcodeseg, "%s", dbuff);
     fflush(fcodeseg);
     if (cp <= 0) {        /* REAL PROBLEM */
       sprintf(dbuff, "   <Possible problem: value out of range!>\n");
       if (DEBUG >= Dbasic) debug_print(dbuff);
       fprintf(fcodeseg, "%s", dbuff);
     }
     else {
       sp = (SYMTAB_NODE_PTR) cp;
       sprintf(dbuff, "    %s\n",
               sp->name);
       if (DEBUG >= Dbasic) debug_print(dbuff);
       fprintf(fcodeseg, "%s", dbuff);
     }
   }

   *code_segment++;
   i++;
 }  /* end while */

 sprintf(dbuff, "\nFinished printing the code segment\n");
 if (DEBUG >= Dbasic) debug_print(dbuff);
 fprintf(fcodeseg, "%s", dbuff);
 fflush(fcodeseg);


}                                         /* end code_segment_debug */
/********************************************************************/


/********************************************************************/
/* code_segment_entry_debug()  Prints an entry in a code segment    */

code_segment_entry_debug(code_entry)
int *code_entry;
{
 int cp;

 if (DEBUG < Dbasic) return;

   cp = (int) *code_entry;
   if (STATEMENT_MARKER == cp) {     /* a statement marker */
     sprintf(dbuff, "%d   %d    %s\n",
        code_entry, cp, "<statement_marker>");
 debug_print(dbuff);
 return;
   }
   else if (ADDRESS_MARKER == cp) {   /* an address marker */
     sprintf(dbuff, "%d   %d    %s\n",
        code_entry, cp, "<address_marker>");
 debug_print(dbuff);
 return;
   }
   else if (tok_code_to_str(cp) != NULL) {            /* a token code */
     sprintf(dbuff, "%d   %d    %s\n",
        code_entry, cp, tok_code_to_str(cp));
 debug_print(dbuff);
 return;
   }
   else {                    /* should be an address of some sort */
     sprintf(dbuff, "%d   %d    %s\n",
        code_entry, cp, "<an address>");
 debug_print(dbuff);
 return;
   }
}                                   /* end code_segment_entry_debug */
/********************************************************************/


/********************************************************************/
/* scan_source_debug()    Print current state of source buffer      */

extern int ch;                  /* current input character */
extern char source_buffer[];    /* the source buffer */
extern int buffer_offset;       /* char offset into source buffer */
extern char *bufferp;           /* source buffer ptr */

scan_source_debug()
{

 if (DEBUG < Dscan) return;

 sprintf(dbuff, "Source line      : %s", source_buffer);
 debug_print(dbuff);
 debug_print("\n");
/*  sprintf(dbuff, "Source line state: %c ^ %s", ch, bufferp); */
 sprintf(dbuff, "Source line state: ");
 debug_print(dbuff);
 sprintf(dbuff, "%c", ch);
 debug_print(dbuff);
 debug_print("^");
 sprintf(dbuff, "%s", bufferp);
 debug_print(dbuff);
 debug_print("\n");

}                                          /* end scan_source_debug */
/********************************************************************/



/********************************************************************/
/* scan_token_debug()     Print info about current token            */

extern TOKEN_CODE token;        /* current token code */
extern char *tokenp;            /* token string ptr */
extern char token_string[];     /* token string */

scan_token_debug()
{

 if (DEBUG < Dscan) return;

 sprintf(dbuff, "Token code: %d ; token string: %s\n",
                 token, token_string);
 debug_print(dbuff);

}                                           /* end scan_token_debug */
/********************************************************************/



/********************************************************************/



/********************************************************************/

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.