mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
355 lines
7.3 KiB
355 lines
7.3 KiB
/*[
|
|
* Name: pigyoda.c
|
|
*
|
|
* Author: William Charnell
|
|
*
|
|
* Created: May 1991
|
|
*
|
|
* Sccs ID: @(#)pigyoda.c 1.9 06/30/94
|
|
*
|
|
* Purpose: This module contains the yoda interface routines for
|
|
* an application pigger.
|
|
*
|
|
* (c)Copyright Insignia Solutions Ltd., 1990. All rights reserved.
|
|
]*/
|
|
|
|
/* Standard Includes */
|
|
#include "insignia.h"
|
|
#include "host_def.h"
|
|
|
|
/* System Includes */
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
|
|
/* SoftPC Includes */
|
|
#include "xt.h"
|
|
#include "bios.h"
|
|
#include "sas.h"
|
|
#include "trace.h"
|
|
|
|
#ifdef PIG
|
|
|
|
IMPORT LONG pig_verbose;
|
|
IMPORT LONG sync_count, sync_count_target;
|
|
IMPORT LONG counting_syncs;
|
|
IMPORT LONG vidchecking;
|
|
|
|
#ifdef ANSI
|
|
IMPORT VOID set_flags_ignore(char *);
|
|
#else
|
|
IMPORT VOID set_flags_ignore();
|
|
#endif
|
|
IMPORT VOID enable_pig();
|
|
IMPORT VOID disable_pig();
|
|
IMPORT VOID show_before();
|
|
IMPORT VOID show_C_after();
|
|
IMPORT VOID show_A_after();
|
|
IMPORT VOID show_execed();
|
|
IMPORT VOID show_mem();
|
|
IMPORT VOID show_pig_stats();
|
|
IMPORT VOID watch_mem();
|
|
IMPORT VOID test_pig_results();
|
|
|
|
extern void dump_execed IPT1( FILE *, fptr );
|
|
|
|
/**/
|
|
|
|
typedef struct {
|
|
char name[20];
|
|
void (*func)();
|
|
char help[100];
|
|
} cmdstruct;
|
|
|
|
/**/
|
|
|
|
LOCAL LONG quit_pig_yoda;
|
|
|
|
/* vbls for the 'more' function */
|
|
#define LINECOUNT_LIMIT 20
|
|
LOCAL SHORT linecount;
|
|
|
|
LOCAL char temp_str[80];
|
|
LOCAL char whitespc[] = { '\t',' ',',','\0' };
|
|
LOCAL char pig_cmd[80], cmd[40], lhs[40], rhs[40],extra[80];
|
|
|
|
/**/
|
|
|
|
LOCAL void do_quit()
|
|
{
|
|
quit_pig_yoda = TRUE;
|
|
}
|
|
|
|
LOCAL void set_pig_vb(lhs)
|
|
char *lhs;
|
|
{
|
|
pig_verbose = atoi(lhs);
|
|
}
|
|
|
|
LOCAL void do_zsc()
|
|
{
|
|
sync_count = 0;
|
|
}
|
|
|
|
LOCAL void do_bsc(lhs)
|
|
char *lhs;
|
|
{
|
|
sync_count_target = atoi(lhs);
|
|
counting_syncs = TRUE;
|
|
}
|
|
|
|
LOCAL void do_psc()
|
|
{
|
|
fprintf(trace_file,"sync count = %d\n",sync_count);
|
|
if (counting_syncs)
|
|
{
|
|
fprintf(trace_file,"sync count target = %d\n",sync_count_target);
|
|
}
|
|
}
|
|
|
|
LOCAL void do_cst()
|
|
{
|
|
counting_syncs = FALSE;
|
|
}
|
|
|
|
LOCAL void do_vid(lhs)
|
|
char *lhs;
|
|
{
|
|
LONG found = FALSE;
|
|
|
|
if (lhs[0] == '\0')
|
|
{
|
|
vidchecking = !vidchecking;
|
|
found = TRUE;
|
|
}
|
|
if (strcmp(lhs,"on")==0)
|
|
{
|
|
vidchecking = TRUE;
|
|
found = TRUE;
|
|
}
|
|
if (strcmp(lhs,"off")==0)
|
|
{
|
|
vidchecking = FALSE;
|
|
found = TRUE;
|
|
}
|
|
if (!found)
|
|
printf("parameter '%s' not understood\n",lhs);
|
|
printf("video checking is now ");
|
|
if (vidchecking)
|
|
printf("ON\n");
|
|
else
|
|
printf("OFF\n");
|
|
}
|
|
|
|
LOCAL void
|
|
dump_script IFN1( char *, fname )
|
|
{
|
|
FILE *fptr;
|
|
|
|
if( fptr = fopen( fname, "w" ))
|
|
{
|
|
dump_execed( fptr );
|
|
fclose( fptr );
|
|
}
|
|
else
|
|
{
|
|
printf( "Couldn't open file %s\n", fname );
|
|
}
|
|
}
|
|
|
|
|
|
/* forward decl of help func */
|
|
|
|
LOCAL void do_pig_help();
|
|
|
|
cmdstruct commands[] =
|
|
{
|
|
{"quit",do_quit, " - return to yoda"},
|
|
{"q",do_quit, " - synonym for quit"},
|
|
{"c",do_quit, " - synonym for quit"},
|
|
{"help",do_pig_help, " - display instructions"},
|
|
{"h",do_pig_help, " - synonym for help"},
|
|
{"on",enable_pig, " - start pigging"},
|
|
{"off",disable_pig, " - stop pigging"},
|
|
{"verbose",set_pig_vb, " <verbose> - set verbose level"},
|
|
{"v",set_pig_vb, " <verbose> - synonyn for verbose"},
|
|
{"fignore",set_flags_ignore, " <flags> - set the flags ignore state"},
|
|
{"f",set_flags_ignore, " <flags> - synonyn for fignore"},
|
|
{"zsc",do_zsc, " - zero the sync count"},
|
|
{"bsc",do_bsc, " <count> - break after <count> syncs"},
|
|
{"psc",do_psc, " - print current sync count"},
|
|
{"sb",show_before, " - show 'before' cpu state"},
|
|
{"sca",show_C_after, " - show cpu state after C CPU"},
|
|
{"saa",show_A_after, " - show_cpu_state after Asm CPU"},
|
|
{"sc",show_execed, " - show code for last sync"},
|
|
{"sm",show_mem, " - show mem for last sync"},
|
|
{"cst",do_cst, " - clear the sync target number"},
|
|
{"vid",do_vid, " <on|off> - set video checking on or off or toggle state"},
|
|
{"smstats",show_pig_stats, " - show stats for pig memory useage"},
|
|
{"wmem",watch_mem, " <off|start,len> - watch host memory location(s)"},
|
|
{"ds",dump_script, " <file name> - dump iPig script" },
|
|
{"test",test_pig_results, " - show test failures again" },
|
|
{"",do_quit,""}
|
|
};
|
|
|
|
char *helpstr[] =
|
|
{
|
|
"\n",
|
|
" valid values of <verbose> are:\n",
|
|
" 0 = quiet\n",
|
|
" 1 = code stream only\n",
|
|
" 2 = memory changes only\n",
|
|
" 3(or above) = full verbose\n",
|
|
"\n",
|
|
" valid values of <flags> are:\n",
|
|
" all = ignore all flags\n",
|
|
" none = test all flags\n",
|
|
"\n",
|
|
""
|
|
};
|
|
|
|
/*
|
|
* more
|
|
*
|
|
* This routine controls the display of a large quantity of output, usually
|
|
* the 'help' display.
|
|
*/
|
|
|
|
SHORT more()
|
|
{
|
|
if ((linecount++)>LINECOUNT_LIMIT)
|
|
{
|
|
if (trace_file == stdout)
|
|
{
|
|
fprintf(trace_file,"hit return to continue\n");
|
|
gets(temp_str);
|
|
linecount=0;
|
|
if ((strcmp(temp_str,"q")==0) || (strcmp(temp_str,"quit")==0))
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
LOCAL void do_pig_help()
|
|
{
|
|
cmdstruct *sptr;
|
|
SHORT i,quithelp;
|
|
|
|
linecount=0;
|
|
quithelp =FALSE;
|
|
sptr= commands;
|
|
while ((sptr->name[0] != '\0') && !quithelp)
|
|
{
|
|
fprintf(trace_file,"%8s%s\n",sptr->name,sptr->help);
|
|
sptr++;
|
|
quithelp=more();
|
|
}
|
|
i=0;
|
|
while ((*helpstr[i] != '\0') && (!quithelp))
|
|
{
|
|
fprintf(trace_file,helpstr[i++]);
|
|
quithelp=more();
|
|
}
|
|
|
|
}
|
|
|
|
getNextToken(posp,buf,dest)
|
|
USHORT *posp;
|
|
char *buf, *dest;
|
|
{
|
|
SHORT len, numopen, numcls, wholetoken, maxlen, cnt;
|
|
char *cptr;
|
|
|
|
/* first get rid of any leading whitespace (incl commas) */
|
|
*posp += strspn(&buf[*posp],whitespc);
|
|
|
|
/* find the length of the next token up to the next white space. */
|
|
/* NB. this may not be the whole token if there is a '(' in it */
|
|
len = strcspn(&buf[*posp],whitespc);
|
|
|
|
maxlen = strlen(&buf[*posp]);
|
|
wholetoken = FALSE;
|
|
while (!wholetoken && (len < maxlen))
|
|
{
|
|
numopen = numcls = 0;
|
|
cptr = &buf[*posp];
|
|
cnt=0;
|
|
while ((*cptr != '\0') && (cnt++ < len))
|
|
{
|
|
if (*cptr++ == '(')
|
|
numopen++;
|
|
}
|
|
cptr = &buf[*posp];
|
|
cnt=0;
|
|
while ((*cptr != '\0') && (cnt++ < len))
|
|
{
|
|
if (*cptr++ == ')')
|
|
numcls++;
|
|
}
|
|
if (numopen == numcls)
|
|
wholetoken = TRUE;
|
|
else
|
|
{
|
|
len += strcspn(&buf[*posp +len],")") + 1;
|
|
}
|
|
}
|
|
strncpy(dest,&buf[*posp],len);
|
|
dest[len] = '\0';
|
|
*posp += len;
|
|
}
|
|
|
|
tokenise_pig_cmd(str,cmd,lhs,rhs,rest)
|
|
char *str, *cmd, *lhs, *rhs, *rest;
|
|
{
|
|
SHORT pos;
|
|
|
|
pos = 0;
|
|
getNextToken(&pos,str,cmd);
|
|
getNextToken(&pos,str,lhs);
|
|
getNextToken(&pos,str,rhs);
|
|
strcpy(rest,&str[pos]);
|
|
}
|
|
|
|
LONG searchCommandTable(cmd_table)
|
|
cmdstruct *cmd_table;
|
|
{
|
|
cmdstruct *sptr;
|
|
void (*func_ptr)();
|
|
LONG found = FALSE;
|
|
|
|
sptr = cmd_table;
|
|
while ((sptr->name[0])!='\0')
|
|
{
|
|
if (strcmp(cmd,sptr->name)==0)
|
|
{
|
|
func_ptr=sptr->func;
|
|
(*func_ptr)(lhs, rhs, extra);
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
sptr++;
|
|
}
|
|
return (found);
|
|
}
|
|
|
|
void pig_yoda()
|
|
{
|
|
|
|
quit_pig_yoda = FALSE;
|
|
|
|
while (!quit_pig_yoda)
|
|
{
|
|
printf("PIG> ");
|
|
fflush(stdout);
|
|
gets(pig_cmd);
|
|
tokenise_pig_cmd(pig_cmd,cmd,lhs,rhs,extra);
|
|
if (!searchCommandTable(&commands[0]))
|
|
{
|
|
printf("command '%s' not found\n",cmd);
|
|
printf("type 'h' or 'help' for a list of commands\n");
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* PIG */
|