int main(void) {
float *a = createvect(NUM),
*b = createvect(NUM);
// incrementing up to 20
setvect(NUM, a, 1);
basicIncrement(NUM, a);
printf("0: a = ");
printvect(NUM, a);
printf("\n");
// nested while loop
setvect(NUM, a, 1);
setvect(NUM, b, 2);
nested(NUM, a, b);
printf("1: a = ");
printvect(NUM, a);
printf("\n");
printf(" b = ");
printvect(NUM, b);
printf("\n");
// nested while loop
setvect(NUM, a, 1);
setvect(NUM, b, 2);
nested2(NUM, a, b);
printf("2: a = ");
printvect(NUM, a);
printf("\n");
printf(" b = ");
printvect(NUM, b);
printf("\n");
// a and b changing relative to each other
setvect(NUM, a, 1);
setvect(NUM, b, 2);
relativeChange(NUM, a, b);
printf("3: a = ");
printvect(NUM, a);
printf("\n");
printf(" b = ");
printvect(NUM, b);
printf("\n");
// while with an if loop inside it
setvect(NUM, a, 1);
setvect(NUM, b, 3);
whileIf(NUM, a, b);
printf("4: a = ");
printvect(NUM, a);
printf("\n");
printf(" b = ");
printvect(NUM, b);
printf("\n");
// if with a while loop inside it
setvect(NUM, a, 1);
setvect(NUM, b, 0);
ifWhile(NUM, a, b);
printf("5: a = ");
printvect(NUM, a);
printf("\n");
printf(" b = ");
printvect(NUM, b);
printf("\n");
// else in big if else statement
setvect(NUM, a, 1);
setvect(NUM, b, 4);
ifWhile(NUM, a, b);
printf("6: a = ");
printvect(NUM, a);
printf("\n");
printf(" b = ");
printvect(NUM, b);
printf("\n");
return 0;
}
void backgroundon( void )
{
oldinterrupt = getvect( 0x08 );
setvect( 0x08, newinterrupt );
}
void
jabunhack(void)
{
setvect(MyInterrupt,oldintaddr);
}
void backgroundoff (void)
{
setvect (TIMER_INTR, oldinterrupt);
}
Int11trap::Int11trap()
{
oldHandler = getvect( 0x11 );
setvect( 0x11, &Int11trap::handler );
}
void init_int9_handler(void) /*{{{*/
{
oldint9 = getvect(9);
setvect(9, int9_handler);
}
/*inicializar el pcb*/
void initPCB(...)
{
//Inicializa el primer nodo del PCB
pcb[0].offset = FP_OFF(filosofo1);
pcb[0].quantum = quantum;
pcb[0].id = 'A';
pcb[0].status = 1;
pcb[0].stcPtr = 0;
//Inicializa el segundo nodo del PCB
pcb[1].offset = FP_OFF(filosofo2);
pcb[1].quantum = quantum;
pcb[1].id = 'B';
pcb[1].status = 2;
//Inicializa el tercer nodo del PCB
pcb[2].offset = FP_OFF(filosofo3);
pcb[2].quantum = quantum;
pcb[2].id = 'C';
pcb[2].status = 2;
//Inicializa el cuarto nodo del PCB
pcb[3].offset = FP_OFF(filosofo4);
pcb[3].quantum = quantum;
pcb[3].id = 'D';
pcb[3].status = 2;
//Inicializa el quinto nodo del PCB
pcb[4].offset = FP_OFF(filosofo5);
pcb[4].quantum = quantum;
pcb[4].id = 'D';
pcb[4].status = 2;
//Guarda el SP de nuestro programa
asm mov stackPointer,sp
stackPointerAux = stackPointer;
//Realiza un corrimiento en la pila para el primer proceso
stackPointerAux = stackPointerAux - 512;
indexOffset = pcb[1].offset; //Direccion del proceso i
//Guarda todo el contexto del proceso 1
asm {
mov SP, stackPointerAux
pushf
push cs
push indexOffset
push ax
push bx
push cx
push dx
push es
push ds
push si
push di
push bp
mov stackPointerAux, SP
mov SP, stackPointer
};
//Guarda en el PCB el SP donde se encuentran el contexto del proceso
pcb[1].stcPtr = stackPointerAux;
//Realiza un corrimiento en la pila para el segundo proceso
stackPointerAux = stackPointerAux - 1024;
indexOffset = pcb[2].offset;
//Guarda todo el contexto del proceso 2
asm {
mov sp,stackPointerAux
pushf
push cs
push indexOffset
push ax
push bx
push cx
push dx
push es
push ds
push si
push di
push bp
mov stackPointerAux, SP
mov SP, stackPointer
};
//Guarda en el PCB el SP donde se encuentran el contexto del proceso
pcb[2].stcPtr = stackPointerAux;
//Realiza un corrimiento en la pila para el tercer proceso
stackPointerAux = stackPointerAux - 1536;
indexOffset = pcb[3].offset;
//Guarda todo el contexto del proceso 3
asm {
mov sp,stackPointerAux
pushf
push cs
push indexOffset
push ax
push bx
push cx
push dx
push es
push ds
push si
push di
push bp
mov stackPointerAux, SP
mov SP, stackPointer
};
//Guarda en el PCB el SP donde se encuentran el contexto del proceso
pcb[3].stcPtr = stackPointerAux;
//Realiza un corrimiento en la pila para el tercer proceso
stackPointerAux = stackPointerAux - 2048;
indexOffset = pcb[4].offset;
//Guarda todo el contexto del proceso 3
asm {
mov sp,stackPointerAux
pushf
push cs
push indexOffset
push ax
push bx
push cx
push dx
push es
push ds
push si
push di
push bp
mov stackPointerAux, SP
mov SP, stackPointer
};
pcb[4].stcPtr = stackPointerAux;
indexProcess = 0;
quantumProcess =pcb[indexProcess].quantum;
}
/*Procemiento que reemplaza la interrupcion del timer con nuestro
codigo fuente.*/
void main()
{
clrscr();
initPCB();
prev=getvect(8); //Guarda la interrupci¢n antigua del timer
setvect(8,myTimer); //Inserta con nuestro c¢digo la interrupcion del time
filosofo1();
clrscr();
while(1)
{}
}
/*Codigo fuente de nuestra interrupcion del timer*/
void interrupt myTimer(...)
{
disable(); //Apaga las demás interrupciones
(*prev)(); //Llama al antiguo c¢digo de interrupcion
//Espera una tecla y verifica si es la tecla Enter
if(kbhit() && getch() == 0xD)
{
//Devuelve la interrupción original
setvect(8,prev);
exit(0);
}
if (quantumProcess > 0 && pcb[indexProcess].status == 1)
{
quantumProcess--;
}
else
{
if ( pcb[indexProcess].status == 1)
{
pcb[indexProcess].status = 2;
}
//Salva el SP del proceso que se quedo sin quantum
asm mov stackPointer, SP
pcb[indexProcess].stcPtr = stackPointer;
indexProcess = (indexProcess + 1) % N;
stackPointer = pcb[indexProcess].stcPtr;
quantumProcess = pcb[indexProcess].quantum;
if(pcb[indexProcess].status == 2)
{
pcb[indexProcess].status = 1;
}
//Mueve el SP a donde esta el contexto del nuevo proceso que va ejecutar
asm mov sp,stackPointer
//Cambio de proceso.
f = 0;
mutex = 1;
}
enable(); //Activa las demás interrupciones
}
/*inicializar el pcb*/
void initPCB(...)
{
//Inicializa el primer nodo del PCB
pcb[0].offset = FP_OFF(processA);
pcb[0].quantum = quantum;
pcb[0].id = 'A';
pcb[0].status = 1;
pcb[0].stcPtr = 0;
//Inicializa el segundo nodo del PCB
pcb[1].offset = FP_OFF(processB);
pcb[1].quantum = quantum;
pcb[1].id = 'B';
pcb[1].status = 2;
//Guarda el SP de nuestro programa
asm mov stackPointer,sp
stackPointerAux = stackPointer;
//Realiza un corrimiento en la pila para el primer proceso
stackPointerAux = stackPointerAux - 512;
indexOffset = pcb[1].offset; //Direccion del proceso i
//Guarda todo el contexto del proceso 1
asm {
mov SP, stackPointerAux
pushf
push cs
push indexOffset
push ax
push bx
push cx
push dx
push es
push ds
push si
push di
push bp
mov stackPointerAux, SP
mov SP, stackPointer
};
//Guarda en el PCB el SP donde se encuentran el contexto del proceso
pcb[1].stcPtr = stackPointerAux;
indexProcess = 0;
quantumProcess =pcb[indexProcess].quantum;
}
/*Procemiento que reemplaza la interrupcion del timer con nuestro
codigo fuente.*/
void main()
{
clrscr();
initPCB();
prev=getvect(8); //Guarda la interrupci¢n antigua del timer
setvect(8,myTimer); //Inserta con nuestro c¢digo la interrupcion del time
actualProcess = 1;
processA();
clrscr();
while(1)
{}
}
void main ( int argc , char **argv )
{
#define QTD_MPRINC 8
#define QTD_MSECUN 4
char *opcao1[8] = { "Configuracao","Calibrar Sistema","Dados do Paciente",
"Ventilacao Voluntaria Maxima","Espirometria Forcada",
"Capacidade Vital Lenta","Resultados","Terminar" };
char *opcao2[4] = { "Visualizar","Imprimir","Arquivo","Retornar"};
int exit = FALSE;
extern int GlobOffSetP;
if (argc > 1 && strcmp ( strupr ( argv[1] ) , "-V1" ) == 0)
/* sem correcao de BTPS */
Versao = 1, --argc, ++argv;
else if (argc > 1 && strcmp ( strupr ( argv[1] ) , "-V2" ) == 0)
/* com correcao para ar expirado */
Versao = 2, --argc, ++argv;
else if (argc > 1 && strcmp ( strupr ( argv[1] ) , "-V3" ) == 0)
/* com correcao para ar ambiente a 37 graus */
Versao = 3, --argc, ++argv;
else /* Nao escolheu nenhuma versao, assume -V2 */
Versao = 2;
if (argc > 1)
GlobOffSetP = atoi(argv[1]);
else
GlobOffSetP = 4;
/* printf( "Usando OffsetP==%d\n", GlobOffSetP );
getchar(); */
#if defined(ENT_ARQ) || defined(ENT_ARQ_R)
strcpy ( NomeCurva , argv[1] );
#endif
_control87 ( MCW_EM , MCW_EM );
#ifdef LINX
vetor = getvect(0x1c);
setvect(0x1c,TrataInterrup); /* seta a Interrupcao 11 do vetor para a funcao a*/
#endif
#ifdef PLACA12
setvect ( 10 , TrataInterrup );
#else
setvect ( 11 , TrataInterrup );
#endif
LeCoef (); /* le coeficientes */
/* *ApontEspirometria = NULL;
*ApontVVM = NULL;
*ApontFluxPreBD = NULL;
*ApontFluxPosBD = NULL;
*/
RegistroTimer();
LeData ();
ModoGrafico ();
Chama_Padrao(); /* pega valores default de cor,laudo,pereira,impressora */
do{
if (limpar) LimpaTela ();
LimpaBufferTeclado ();
InitialScreen();
switch (menu(MENUPRINCIPAL,QTD_MPRINC,opcao1)) {
case 0 : Padrao();
limpar=TRUE;
break;
case 1 : if(GanhoOk) LiberaAreas();
Calibragem ();
if(GanhoOk) ReservaAreas ();
limpar = TRUE;
break;
case 2 :if(GanhoOk){
DadosPaciente ();
limpar = TRUE; }
break;
case 3 :
if (GanhoOk && DadosPacienteOk)
{
VentVol ();
limpar = TRUE;
}
else
limpar = FALSE;
break;
case 4 :
#if !defined(ENT_ARQ) && !defined(ENT_ARQ_R)
if ((GanhoOk && DadosPacienteOk) || (Versao == 3))
{
#endif
FluxVol ();
#if !defined(ENT_ARQ) && !defined(ENT_ARQ_R)
limpar = TRUE;
}
else
limpar = FALSE;
#endif
break;
case 5 :
if (GanhoOk && DadosPacienteOk)
{
setviewport ( 0 , 0 , 719 , 347 , 1 );
gprintf(585,280,"Ar Residual ? (S/N)");
do{
LEITURA('c',683,280,Resp,1,0,0);
}while(!pertence(*Resp,"SsNn"));
if(pertence(*Resp,"Ss")) {
VAR_RESP=TRUE;
Volume_de_ar_residual();
}
else VAR_RESP=FALSE;
Espirometria ();
limpar = TRUE;
}
else
limpar = FALSE;
break;
case 6 :if ((DadosPacienteOk || OK) && GanhoOk){
switch(menu(MENUSECUNDARIO,QTD_MSECUN,opcao2)){
case SALVAR: Arquivar();
break;
case IMPRIMIR: if (DadosPacienteOk)
Impressao(1);
break;
case VISUALIZAR:if (DadosPacienteOk)
Impressao(0);
break;
case 27:
case 3: break;
/* case 9: chama_help(002); break;*/
}
limpar=TRUE;
}
else limpar=FALSE;
break;
/*case 9: chama_help(002); break;*/
case 7:
exit = TRUE;
break;
}
}
while (!exit);
closegraph ();
LiberaAreas ();
}
void
restore_kbd(void)
{
setvect(KBD_INT, old_kbd);
}
/*Codigo fuente de nuestra interrupcion del timer*/
void interrupt myTimer(...)
{
disable(); //Apaga las demás interrupciones
(*prev)(); //Llama al antiguo c¢digo de interrupcion
//Espera una tecla y verifica si es la tecla Enter
if(kbhit() && getch() == 0xD)
{
//Devuelve la interrupción original
setvect(8,prev);
exit(0);
}
if (quantumProcess > 0)
{
//Si el proceso aun tiene quantum lo disminuye.
quantumProcess--;
}
else
{
//Salva el SP del proceso que se quedo sin quantum
asm mov stackPointer, SP
pcb[indexProcess].stcPtr = stackPointer;
if (pcb[indexProcess].status == 1)
{
pcb[indexProcess].status = 2;
}
//copia el valor que posee el quantum del proceso actual
int q = pcb[indexProcess].quantum;
if (q > 20)
{
//Si el quantum del proceso es mayor a 20 reinicia el quantum en su valor original
q = quantum;
}
else
{
/*Si el quantum del proceso actual no es mayor a 20 le aumenta uno para que a la siguiente ejecución
tenga un tick de reloj más*/
q++;
}
//Asigna el nuevo quantum al proceso.
pcb[indexProcess].quantum = q;
//Cambio de proceso.
indexAux = indexProcess;
indexProcess++;
indexProcess = indexProcess % 2;
if (pcb[indexProcess].status != 2)
{
indexProcess++;
indexProcess = indexProcess % 2;
}
//Guarda el quantum del nuevo proceso.
quantumProcess = pcb[indexProcess].quantum;
//revisa que no se repita el proceso que se acaba de quedar sin quantum
if (indexAux != indexProcess)
{
//Le indica que el nuevo proceso va estar en estado ejecutado.
pcb[indexProcess].status = 1;
stackPointer = pcb[indexProcess].stcPtr;
//Mueve el SP a donde esta el contexto del nuevo proceso que va ejecutar
asm mov sp,stackPointer
}
}
IVTEntry::~IVTEntry(){
setvect(ivtNo, old);
//arr[ivtNo] = NULL;
(*old)();
}
IVTEntry::IVTEntry(IVTNo ivtNo, pointerInterrupt newInterrupt):ivtNo(ivtNo){
old = getvect(ivtNo);
setvect(ivtNo, newInterrupt);
}
int OpenComPort(
char Port)
{ /* install int. handler */
unsigned status;
int retval = -1;
/* allocate input and output queues */
Serial_In_Queue = alloc_queue(SerInBufSize);
if ((QUEUE *) 0 == Serial_In_Queue)
return retval;
Serial_Out_Queue = alloc_queue(SerOutBufSize);
if ((QUEUE *) 0 == Serial_Out_Queue) {
free(Serial_In_Queue);
return retval;
}
retval = 0;
/* Setup Comm base port address and IRQ number */
switch (Port) {
case '1':
ComBase = 0x3F8;
IrqNum = 4;
break;
case '2':
ComBase = 0x2F8;
IrqNum = 3;
break;
case '3':
ComBase = 0x3E8;
IrqNum = 4;
break;
case '4':
ComBase = 0x2E8;
IrqNum = 3;
break;
default:
ComBase = 0x3F8;
IrqNum = 4;
break;
}
old_comm_params.int_enable = inp(ComBase + INT_EN);
outp(ComBase + INT_EN, 0); /* turn off comm interrupts */
/* save old comm parameters */
old_comm_params.line = inp(ComBase + LINE_CNTRL);
old_comm_params.modem = inp(ComBase + MODEM_CNTRL);
status = inp(ComBase + LINE_CNTRL);
outp(ComBase + LINE_CNTRL, (unsigned char) status | 0x80);
old_comm_params.baud_lsb = inp(ComBase + BAUD_LSB);
old_comm_params.baud_msb = inp(ComBase + BAUD_MSB);
status = inp(ComBase + LINE_CNTRL);
outp(ComBase + LINE_CNTRL, (unsigned char) status | 0x7F);
status = OUT2 | DTR; /* DTR/OUT2 must be set! */
outp(ComBase + MODEM_CNTRL, (unsigned char) status);
/* get serial port address/vector */
oldvector_serial = (void (INTERRUPT FAR *) (void)) getvect(IrqNum + 8);
/* set our interrupt handler */
setvect(IrqNum + 8, serial);
/* save the PIC */
old_comm_params.int_cntrl = inp(0x21);
status = (1 << IrqNum); /* calculate int enable bit */
status = ~status;
/* ok enable comm ints */
outp(0x21,
(unsigned char) old_comm_params.int_cntrl & (unsigned char) status);
atexit(CloseComPort);
return retval;
}
int main(int argc, char *argv[])
{
char ans[2];
char *fileargs[64];
char *optargs[64];
int n_options;
int index;
int help_flag = 0;
#ifdef __TURBOC__
setvect(0x23, ctrlc_hndlr);
#else
_dos_setvect(0x23, ctrlc_hndlr);
#endif
atexit(on_exit);
n_options = classify_args(argc, argv, fileargs, optargs);
for (index=0;index<n_options;index++)
{
if (optargs[index][0] == '?') help_flag=1;
else
{
myprintf("Invalid parameter - /",0);
myprintf(optargs[index],0); /* removed strupr */
myprintf("\r\n",0);
exit(1);
} /* end else. */
} /* end for. */
if (help_flag)
{
myprintf("\r\nLABEL Version " VERSION "\r\n", 0);
myprintf("Creates, changes or deletes the volume label of a disk.\r\n",0);
myprintf("\r\n",0);
myprintf("Syntax: LABEL [drive:][label] [/?]\r\n",0);
myprintf(" [drive:] Specifies which drive you want to label\r\n",0);
myprintf(" [label] Specifies the new label you want to label the drive\r\n",0);
myprintf(" /? Displays this help message\r\n",0);
return 0;
} /* end if. */
do_cmdline(argc, argv);
if (*Drive == '?') /* If no drive specified, use current. */
GetDrive();
/* Save current directory and move to root. */
GetCurDir(curdir);
if (curdir[0] != 0)
{
*rootdir = *Drive;
SetCurDir(rootdir);
} /* end if. */
/* If no label was specified, show current one first and then get new one. */
if (*Label == '\0')
{
disp_label();
get_label();
} /* end if. */
/* If they entered an empty label, then ask them if they want to */
/* delete the existing volume label. */
if ((*Label == '\0') && (!NoLabel))
{
do
{
myprintf("\nDelete current volume label (Y/N)? ",0);
mygets(ans,2); /* WHY not use getch? ??? */
} /* end do. */
while (((*ans=(char)toupper(*ans)) != 'Y') && (*ans != 'N'));
if (toupper(*ans) == 'N')
exit(1);
} /* end if. */
/* Delete the old volume label. */
del_label();
/* Create the new one, if there is one to create. */
if (*Label != '\0')
{
if (make_label())
{
exit(1);
} /* end if. */
} /* end if. */
exit(0);
return 0;
} /* end main. */
//------------------------------------------------------------------------------
void fin_input(void)
{
setvect(keyboard_interrupt, bios_keyboard_handler);
}
/* Uninstall our vectors before exiting the program */
void GSerial::ResetVects(void)
{
setvect(InterruptNo[m_unPortNo-1], OldVects);
}
/* 恢复原有的时钟中断处理过程 */
void KillTimer()
{
disable();
setvect(TIMER,oldhandler);
enable();
}
void restore_int9_handler(void) /*{{{*/
{
setvect(9, oldint9);
}
T_directTalkHandle DirectTalkInit(
T_directTalkReceiveCallback p_callRecv,
T_directTalkSendCallback p_callSend,
T_directTalkConnectCallback p_callConnect,
T_directTalkDisconnectCallback p_callDisconnect,
T_directTalkHandle handle)
{
T_directTalkStruct *p_talk ;
T_directTalkHandle newHandle = DIRECT_TALK_HANDLE_BAD ;
T_word16 vector ;
T_byte8 **p_vector ;
DebugRoutine("DirectTalkInit") ;
/* Record the send and receive callbacks. */
G_receiveCallback = p_callRecv ;
G_sendCallback = p_callSend ;
G_connectCallback = p_callConnect ;
G_disconnectCallback = p_callDisconnect ;
memset(&G_blankAddress, 0, sizeof(G_blankAddress)) ;
#ifdef COMPILE_OPTION_DIRECT_TALK_IS_DOS32
DebugCheck(p_callRecv != NULL) ;
DebugCheck(p_callSend == NULL) ;
DebugCheck(p_callConnect == NULL) ;
DebugCheck(p_callDisconnect == NULL) ;
if ((handle == DIRECT_TALK_HANDLE_BAD) ||
(((T_word32)handle) >= 0x100000)) {
puts("DirectTalk Failure: BAD TALK HANDLE. Is a driver running?") ;
exit(1) ;
}
/* Get access to the structure from the given handle. */
p_talk = (T_directTalkStruct *)handle ;
/* Store the pointer for future use. */
G_talk = p_talk ;
if (p_talk->tag != DIRECT_TALK_TAG) {
puts("DirectTalk Failure: BAD TALK HANDLE. Is a driver running?") ;
exit(1) ;
}
/* Make sure we are talking about the same handle. */
if (p_talk->handle != handle) {
puts("DirectTalk Failure: INCONSISTENT HANDLES.") ;
exit(1) ;
}
if ((p_talk->vector < VALID_LOW_VECTOR) ||
(p_talk->vector > VALID_HIGH_VECTOR)) {
puts("DirectTalk Failure: BAD VECTOR NUMBER.") ;
exit(1) ;
}
/* Init is successful. */
newHandle = handle ;
#else
DebugCheck(p_callRecv != NULL) ;
DebugCheck(p_callSend != NULL) ;
DebugCheck(p_callConnect != NULL) ;
DebugCheck(p_callDisconnect != NULL) ;
/* Allocate memory for the talk structure. */
p_talk = G_talk = MemAlloc(sizeof(T_directTalkStruct)) ;
if (p_talk == NULL) {
puts("DirectTalk Failure: NOT ENOUGH MEMORY.") ;
exit(1) ;
}
/* Clear the talk structure. */
memset(G_talk, 0, sizeof(T_directTalkStruct)) ;
/* Mark the talk structure as valid. */
p_talk->tag = DIRECT_TALK_TAG ;
/* Convert the address into an appropriate handle. */
handle = (((T_word32)(FP_SEG((T_void far *)p_talk)))<<4) +
((T_word32)(FP_OFF((T_void far *)p_talk))) ;
/* Store the handle for validation later. */
p_talk->handle = handle ;
/* Now, look for a vector that we can use. */
for (vector=VALID_LOW_VECTOR; vector <= VALID_HIGH_VECTOR; vector++) {
p_vector = (T_byte8 **)(vector * 4) ;
if ((!(*p_vector)) || (**p_vector == 0xCF)) {
/* Found a vector I can use. */
break ;
}
}
/* Check if the vector is now good. */
if (vector > VALID_HIGH_VECTOR) {
puts("DirectTalk Failure: CANNOT FIND USABLE VECTOR") ;
exit(1) ;
}
/* Vector is good. Store it. */
p_talk->vector = vector ;
/* Install vector. */
printf("Installing on vector 0x%02X\n", vector) ;
G_oldVector = getvect(vector);
setvect(vector, IDirectTalkISR);
G_interruptInstalled = TRUE ;
atexit(IDirectTalkUndoISR) ;
/* Record the new handle we are to use. */
newHandle = handle ;
#endif
DebugEnd() ;
return newHandle ;
}
void backgroundon (void)
{
oldinterrupt = getvect (TIMER_INTR);
setvect (TIMER_INTR, newinterrupt);
}
/*************************************************************************
*
*N vpfopencheck
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function tries its darndest to open a file. It initially calls
* fopen with the given filename and mode. If that doesn't work and
* the file is not on the hard disk, it displays a message asking the
* user to enter the correct disk in the drive, waits for either a retry
* or a cancel response, and, if told to retry, tries again. This
* process is repeated until either the file is opened or the user
* requests cancel.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* filename <input> == (char *) full path name of the file to be opened.
* mode <input> == (char *) mode of the file.
* diskname <input> == (char *) descriptive name of the disk the file is
* on.
* return <output> == (FILE *) file pointer newly associated with
* filename.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
* Dave Flinn July 1991 Updated for UNIX
*E
*************************************************************************/
FILE *vpfopencheck( const char *filename,
const char *mode,
const char * diskname )
{
FILE *fp;
char* tmpFilename = (char*) malloc ( strlen(filename) + 1 );
/*
char *text[] = {"Please insert",
" ",
"in data drive",
" "};
*/
rspf_int32 retry = 0;
#ifdef __MSDOS__
extern char home[255];
void interrupt (*doshandler)();
doshandler = getvect(36);
harderr(vpfhandler);
strncpy(text[1],diskname,strlen(text[1]));
strcpy(text[3],filename);
#endif
fp = NULL;
/* copy the filename because we might modify it. */
tmpFilename[strlen(filename)] = '\0'; /* just in case */
strcpy(tmpFilename, filename);
while (fp == NULL)
{
fp = fopen(tmpFilename,mode);
if (fp == NULL)
{
#ifdef __MSDOS__
if ( toupper(home[0]) != toupper(tmpFilename[0]) )
retry = displayerror(text, 4);
else
#else
/* give names ending in dot another chance without the dot */
if (tmpFilename[strlen(tmpFilename)-1] == '.')
{
tmpFilename[strlen(tmpFilename)-1] = '\0';
retry = TRUE;
}
else
#endif
retry = FALSE;
if (!retry) break;
}
}
free(tmpFilename);
tmpFilename = 0;
#ifdef __MSDOS__
setvect(36,doshandler);
#endif
return fp;
}
int initialize(void)
{
//int rc;
int comPath; /* path to COMMAND.COM (for COMSPEC/reload) */
char *newTTY; /* what to change TTY to */
int showinfo; /* show initial info only if no command line options */
int ec; /* error code */
unsigned offs; /* offset into environment segment */
int cmdlen; /* length of command line */
char *cmdline; /* command line duplicated into heap */
char *p, *h, *q;
#ifdef FEATURE_CALL_LOGGING
#ifndef INCLUDE_CMD_FDDEBUG
FILE *f;
#endif
#endif
/* Set up the host environment of COMMAND.COM */
/* Install the dummy handlers for Criter and ^Break */
initCBreak();
setvect(0x23, cbreak_handler);
setvect(0x24, dummy_criter_handler);
/* DOS shells patch the PPID to the own PID, how stupid this is, however,
because then DOS won't terminate them, e.g. when a Critical Error
occurs that is not detected by COMMAND.COM */
oldPSP = OwnerPSP;
atexit(exitfct);
OwnerPSP = _psp;
dbg_printmem();
#ifdef DEBUG
{ void* p;
if((p = malloc(5*1024)) == 0)
dprintf(("[MEM: Out of memory allocating test block during INIT]"));
else free(p);
}
#endif
#ifdef FEATURE_KERNEL_SWAP_SHELL
if(kswapInit()) { /* re-invoked */
if(kswapLoadStruc()) {
/* OK, on success we need not really keep the shell trick
(pretend we are our own parent), which might cause
problems with beta-software-bugs ;-)
In fact, KSSF will catch up our crashes and re-invoke
FreeCOM, probably with the loss of any internal
settings. */
OwnerPSP = oldPSP;
return E_None;
}
}
#endif
/* Some elder DOSs may not pass an initializied environment segment */
if (env_glbSeg && !isMCB(SEG2MCB(env_glbSeg)))
env_setGlbSeg(0); /* Disable the environment */
/* Now parse the command line parameters passed to COMMAND.COM */
/* Preparations */
newTTY = 0;
comPath = tracemode = 0;
showinfo = 1;
/* Because FreeCom should be executed in a DOS3+ compatible
environment most of the time, it is assumed that its path
can be determined from the environment.
This has the advantage that the string area is accessable
very early in the run.
The name of the current file is string #0. */
if((offs = env_string(0, 0)) != 0) /* OK, environment filled */
grabComFilename(0, (char far *)MK_FP(env_glbSeg, offs));
/* After that argv[0] is no longer used and maybe zapped.
This also will help, as most programs altering the environment
segment externally don't expect a string area. */
env_nullStrings(0);
/* Aquire the command line, there are three possible sources:
1) DOS command line @PSP:0x80 as pascal string,
2) extended DOS command line environment variable CMDLINE,
if peekb(PSP, 0x80) == 127,&
3) MKS command line @ENV:2, if peekb(ENV, 0) == '~'
&& peekb(ENV, 1) == '='
Currently implemented is version #1 only
*/
cmdlen = peekb(_psp, 0x80);
if(cmdlen < 0 || cmdlen > 126) {
error_corrupt_command_line();
cmdlen = 0;
}
/* duplicate the command line into the local address space */
if((cmdline = malloc(cmdlen + 1)) == 0) {
error_out_of_memory(); /* Cannot recover from this problem */
return E_NoMem;
}
_fmemcpy((char far*)cmdline, MK_FP(_psp, 0x81), cmdlen);
cmdline[cmdlen] = '\0';
#ifdef FEATURE_CALL_LOGGING
#ifndef INCLUDE_CMD_FDDEBUG
if((f = fopen(logFilename, "at")) == 0) {
fprintf(stderr, "Cannot open logfile: \"%s\"\n", logFilename);
} else {
putc('"', f);
if(ComPath) /* path to command.com already known */
fputs(ComPath, f);
putc('"', f);
putc(':', f);
fputs(cmdline, f);
putc('\n', f);
fclose(f);
}
#else
cmd_fddebug(logFilename);
dbg_outc('"');
dbg_outs(ComPath);
dbg_outc('"');
dbg_outc(':');
dbg_outsn(cmdline);
#endif
#endif
canexit = 1;
p = cmdline; /* start of the command line */
do {
ec = leadOptions(&p, opt_init, 0);
if(ec == E_NoOption) { /* /C or /K */
assert(p && *p);
if(!isoption(p)) {
error_quoted_c_k();
p = 0;
break;
}
assert(p[1] && strchr("kKcC", p[1]));
p += 2; /* p := start of command line to execute */
break;
} else if(ec != E_None) {
showhelp = 1;
p = 0;
break;
}
assert(p && !isoption(p) && !isspace(*p));
if(!*p) {
p = 0;
break; /* end of line reached */
}
q = unquote(p, h = skip_word(p));
p = h; /* Skip this word */
if(!q) {
error_out_of_memory();
p = 0;
break;
}
if(!comPath) { /* 1st argument */
grabComFilename(1, (char far*)q);
comPath = 1;
free(q);
} else if(!newTTY) { /* 2nd argument */
#ifdef INCLUDE_CMD_CTTY
newTTY = q;
#else
error_ctty_excluded();
free(q);
#endif
} else {
error_too_many_parameters(q);
showhelp = 1;
free(q);
break;
}
} while(1);
/*
* Now:
* + autoexec: AUTOEXEC.BAT file to be executed if /P switch
* is enabled; if NULL, use default
* + comPath: user-defined PATH to COMMAND.COM; if NULL, use
* the one from the environment
* + newTTY: the name of the device to be CTTY'ed; if NULL,
* no change
* + p: pointer to the command to be executed:
* *p == 'c' or 'C' --> spawn command, then terminate shell
* *p == 'k' or 'K' --> spawn command, then go interactive
* &p[1] --> command line, unless the first character is an
* argument character
*/
/* Now process the options */
#ifdef INCLUDE_CMD_CTTY
if (newTTY) { /* change TTY as early as possible so the caller gets
the messages into the correct channel */
cmd_ctty(newTTY);
free(newTTY);
}
#endif
if(!ComPath) {
/* FreeCom is unable to find itself --> print error message */
/* Emergency error */
#undef TEXT_MSG_FREECOM_NOT_FOUND
puts(TEXT_MSG_FREECOM_NOT_FOUND);
return E_Useage;
}
/* First of all, set up the environment */
/* If a new valid size is specified, use that */
env_resizeCtrl |= ENV_USEUMB | ENV_ALLOWMOVE;
if(newEnvSize > 16 && newEnvSize < 32767)
env_setsize(0, newEnvSize);
/* Otherwise the path is placed into the environment */
/* Set the COMSPEC variable. */
if(chgEnv("COMSPEC", ComPath)) { /* keep it silent */
/* Failed to add this variable, the most likely problem should be that
the environment is too small --> it is increased and the
operation is redone */
env_resize(0, strlen(ComPath) + 10);
if(chgEnv("COMSPEC", ComPath))
chgEnv("COMSPEC", NULL); /* Cannot set -> zap an old one */
}
inInit = 0;
/* Install INT 24 Critical error handler */
/* Needs the ComPath variable, eventually */
if(!kswapContext) {
/* Load the module/context into memory */
if((kswapContext = modContext()) == 0) {
error_loading_context();
return E_NoMem;
}
#ifdef FEATURE_KERNEL_SWAP_SHELL
if(swapOnExec != ERROR)
kswapRegister(kswapContext);
#endif
}
ctxtCreate();
/* re-use the already loaded Module */
setvect(0x24, (void interrupt(*)())
MK_FP(FP_SEG(kswapContext->cbreak_hdlr), kswapContext->ofs_criter));
if(internalBufLen)
error_l_notimplemented();
if(inputBufLen)
error_u_notimplemented();
if(tracemode)
showinfo = 0;
if (showhelp)
displayString(TEXT_CMDHELP_COMMAND);
if ((showhelp || exitflag) && canexit)
return E_None;
/* Now the /P option can be processed */
if(!canexit) {
char *autoexec;
autoexec = user_autoexec? user_autoexec: AUTO_EXEC;
showinfo = 0;
short_version();
if(skipAUTOEXEC) { /* /D option */
showinfo = 0;
displayString(TEXT_MSG_INIT_BYPASSING_AUTOEXEC, autoexec);
} else {
if(exist(autoexec)) {
#ifdef FEATURE_BOOT_KEYS
struct REGPACK r;
int key;
r.r_ax = 0x3000; /* Get DOS version & OEM ID */
intr(0x21, &r);
if(!tracemode /* /Y --> F8 on CONFIG.SYS */
|| ((r.r_bx & 0xff00) == 0xfd00 /* FreeDOS >= build 2025 */
&& !(r.r_cx > 0x101 || (r.r_bx & 0xff) > 24))) {
displayString(TEXT_MSG_INIT_BYPASS_AUTOEXEC, autoexec);
key = cgetchar_timed(3);
putchar('\n');
} else key = 0;
if(key == KEY_F8)
tracemode = 1;
if(key == KEY_F5)
displayString(TEXT_MSG_INIT_BYPASSING_AUTOEXEC, autoexec);
else
#endif
process_input(1, autoexec);
} else {
if(user_autoexec)
error_sfile_not_found(user_autoexec);
#ifdef INCLUDE_CMD_DATE
cmd_date(0);
#endif
#ifdef INCLUDE_CMD_TIME
cmd_time(0);
#endif
}
}
free(user_autoexec);
} else {
assert(user_autoexec == 0);
}
/* Now the /C or /K option can be processed */
if (p)
{
process_input(1, p);
return spawnAndExit;
}
/* Don't place something here that must be executed after a /K or /C */
if (showinfo)
{
short_version();
#ifndef DEBUG
putchar('\n');
showcmds(0);
putchar('\n');
#endif
}
return E_None;
}
void Done (void) {
_setcursortype (_NORMALCURSOR);
setvect (9,old9handler);
}
Int11trap::~Int11trap()
{
setvect( 0x11, oldHandler );
}
XInstrument::~XInstrument() {
setvect(0x1c,old1cvect);
AboutQuitAnalog();
delete pCh;
}
void backgroundoff( void )
{
setvect( 0x08, oldinterrupt );
}
static void execute(char *first, char *rest)
{
/*
* This command (in first) was not found in the command table
*
*
* first - first word on command line
* rest - rest of command line
*
*/
char *fullname;
assert(first);
assert(rest);
/* check for a drive change */
if ((strcmp(first + 1, ":") == 0) && isalpha(*first))
{
changeDrive(*first);
return;
}
if (strchr(first,'?') || strchr(first,'*'))
{
error_bad_command();
return;
}
/* search through %PATH% for the binary */
errno = 0;
fullname = find_which(first);
dprintf(("[find_which(%s) returned %s]\n", first, fullname));
if (!fullname)
{
error_bad_command();
return;
}
/* check if this is a .BAT file */
assert(strrchr(fullname, '.'));
if (stricmp(strrchr(fullname, '.'), ".bat") == 0)
{
dprintf(("[BATCH: %s %s]\n", fullname, rest));
batch(fullname, first, rest);
}
else
/* exec the program */
{
int result;
dprintf(("[EXEC: %s %s]\n", fullname, rest));
if (strlen(rest) > MAX_EXTERNAL_COMMAND_SIZE)
{
error_line_too_long();
return;
}
/* Prepare to call an external program */
/* Unload the message block if not loaded persistently */
if(!persistentMSGs)
unloadMsgs();
/* Execute the external program */
#ifdef FEATURE_KERNEL_SWAP_SHELL
if(swapOnExec == TRUE
&& kswapMkStruc(fullname, rest)) {
/* The Criter and ^Break handlers has been installed within
the PSP in kswapRegister() --> nothing to do here */
dprintf(("[EXEC: exiting to kernel swap support]\n"));
exit(123); /* Let the kernel swap support do the rest */
}
#ifdef DEBUG
if(swapOnExec == TRUE)
dprintf(("KSWAP: failed to save context, proceed without swapping\n"));
#endif
#endif
/* Install the dummy (always abort) handler */
setvect(0x23, (void interrupt(*)()) kswapContext->cbreak_hdlr);
result = exec(fullname, rest, 0);
setvect(0x23, cbreak_handler); /* Install local CBreak handler */
perform_exec_result(result);
}
}
/*--------------------------------------------------------------------------*
Name ctrlbrk - sets control-break handler
Usage void ctrlbrk(int (*fptr)(void));
Prototype in dos.h
Description ctrlbrk sets a new control-break handler function pointed
to by fptr. The interrupt vector 0x23 is modified to call
the named function.
The named function is not called directly. ctrlbrk
establishes a DOS interrupt handler that calls the named
function.
Return value ctrlbrk returns nothing. The handler function returns 0 to
abort the current program; any other value will cause the
program to resume execution.
*---------------------------------------------------------------------------*/
void ctrlbrk(int (*fptr)())
{
Hfunc = fptr;
setvect(0x23, FARINT(hentry));
}
void
iC_quit(int sig)
{
#ifdef RASPBERRYPI
sig = (*iC_term)(sig); /* clear and unexport RASPBERRYPI stuff */
#endif /* RASPBERRYPI */
/********************************************************************
* The following termination function is an empty function
* in the libict.a support library.
* int iCend(void) { return -1; }
* It may be implemented in a literal block of an iC source, in
* which case that function will be linked in preference.
* User implementations of iCend() should return 0, to activate
* the debug message "== iCend complete ======".
*
* It can be used to free allocated memory, etc.
*
* If the iCbegin() function contains a fork() call, iCend() may have
* a matching wait() call.
*******************************************************************/
if ((sig >= QUIT_TERMINAL || sig == SIGINT)
&& iCend() != -1 /* iC termination function */
) {
#if YYDEBUG
if (iC_debug & 0100) {
fprintf(iC_outFP, "\n== iCend complete ======\n");
}
#endif /* YYDEBUG */
}
#ifdef TCP
if (iC_sockFN > 0) {
if (sig < SIGUSR1 || sig == QUIT_TERMINAL || sig == QUIT_DEBUGGER) { /* but not QUIT_SERVER */
#ifdef LOAD
if (C_channel) {
/* disconnect iClive - follow with '0' for iCserver */
snprintf(regBuf, REQUEST, "%hu:5,%hu:0", C_channel, C_channel);
iC_send_msg_to_server(iC_sockFN, regBuf);
#ifdef WIN32
Sleep(200); /* 200 ms in ms */
#else /* WIN32 */
nanosleep(&ms200, NULL);
#endif /* WIN32 */
if (iC_micro) iC_microPrint("Disconnected", 0);
}
#endif /* LOAD */
if (iC_Xflag) { /* stop iCserver if this process started it */
snprintf(regBuf, REQUEST, "X%s", iC_iccNM);
iC_send_msg_to_server(iC_sockFN, regBuf);
}
iC_send_msg_to_server(iC_sockFN, ""); /* 0 length message to disconnect from iCserver */
}
close(iC_sockFN); /* close connection to iCserver */
}
#endif /* TCP */
/********************************************************************
* Normal quit
*******************************************************************/
fflush(iC_outFP); /* in case dangling debug messages without CR */
if (iC_outFP != stdout) {
fclose(iC_outFP);
}
if ((iC_debug & DQ) == 0) {
if (sig == QUIT_TERMINAL) {
fprintf(iC_errFP, "\n'%s' stopped from terminal\n", iC_iccNM);
} else if (sig == QUIT_DEBUGGER) {
fprintf(iC_errFP, "\n'%s' stopped by debugger\n", iC_iccNM);
} else if (sig == QUIT_SERVER) {
fprintf(iC_errFP, "\n'%s' disconnected by server\n", iC_iccNM);
}
}
if (sig == SIGINT) {
fprintf(iC_errFP, "\n'%s' stopped by interrupt from terminal\n", iC_iccNM);
} else if (sig == SIGSEGV) {
fprintf(iC_errFP, "\n'%s' stopped by 'Invalid memory reference'\n", iC_iccNM);
} else if (sig == SIGUSR1) {
fprintf(iC_errFP, "\n'%s' stopped by 'non-recoverable run-time error'\n", iC_iccNM);
}
#if defined(TCP) && defined(LOAD)
if (iC_savFP) {
fflush(iC_savFP);
fclose(iC_savFP);
}
if (iC_vcdFP) {
fflush(iC_vcdFP);
fclose(iC_vcdFP);
}
#endif /* defined(TCP) && defined(LOAD) */
#ifdef _MSDOS_
if (oldhandler && iC_debug & 03000) {
/* reset the old interrupt handler */
#ifdef MSC
_dos_setvect(INTR, oldhandler);
#else /* MSC */
setvect(INTR, oldhandler);
#endif /* MSC */
}
#else /* ! _MSDOS_ Linux */
if (ttyparmFlag) {
if (tcsetattr(0, TCSAFLUSH, &ttyparms) == -1) exit(-1);
}
#endif /* ! _MSDOS_ Linux */
if (iC_errFP != stderr) {
fflush(iC_errFP);
fclose(iC_errFP);
}
#if defined(TCP) && defined(EFENCE)
free(rpyBuf);
free(regBuf);
#ifdef LOAD
free(msgBuf);
free(iC_outBuf);
#endif /* LOAD */
#endif /* defined(TCP) && defined(EFENCE) */
exit(sig < QUIT_TERMINAL ? sig : 0); /* really quit */
} /* iC_quit */
