home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
The C Users' Group Library 1994 August
/
wc-cdrom-cusersgrouplibrary-1994-08.iso
/
listings
/
v_07_03
/
v7n3010a.txt
< prev
next >
Wrap
Text File
|
1989-01-16
|
14KB
|
529 lines
Listing 1:
int well_formed(), well_formed_2(), woof(); /* Declarations */
typedef struct element {
char *field;
int (*validate)();
} FORM_RULES;
FORM_RULES form[] ={
{ "field1", well_formed},
{ "field2", well_formed_2}
};
int well_formed()
{
return 0;
}
int well_formed_2()
{
return 0;
}
int woof()
{
return 0;
}
Listing 2:
main()
/* Changes well_formed reference to woof */
{
int i;
printf("\n Function addresses are %lx %lx %lx",
well_formed, well_formed_2, woof);
printf("\n Member addresses are %lx %lx",
form[0].validate, form[1].validate);
form[0].validate = woof;
printf("\n Member addresses are %lx %lx",
form[0].validate, form[1].validate);
}
Output:
Function addresses are 3e220000 3e220009 3e220012
Member addresses are 3e220000 3e220009
Member addresses are 3e220012 3e220009
Listing 3:
struct element
{
char *field;
int validate_function_id;
};
#define F_WELL_FORMED 0
#define F_WELL_FORMED_2 1
#define F_WOOF 2
struct element form[] = {
{ "field1", F_WELL_FORMED},
{ "field2", F_WELL_FORMED_2},
};
int well_formed(), well_formed_2(), woof(); /* Declarations */
static int (*validate_function[])() =
{ well_formed, well_formed_2, woof};
#define MAX_VALIDATE_FUNC (sizeof(validate_function)/sizeof(int (*)()) )
main()
{
form[0].validate_function_id = F_WOOF;
/* Indirect call */
call_function(form[0].validate_function_id);
/* Direct call -- if no checking was desired */
(*validate_function[form[0].validate_function_id])();
}
call_function(id)
int id;
{
/* Check the function id and call it */
if (id >= 0 && id < MAX_VALIDATE_FUNC)
(*validate_function[id])();
else
printf("\n Out of range validate function id", id);
}
Listing 4:
typedef int (* VALIDATER)(); /* Pointer to C function returning int */
#define VNOP ((VALIDATER) 0 ) /* Null function -- validate not required */
typedef struct field_element {
char **fptr; /* Address of a field pointer */
VALIDATER fi; /* Pointer to field function,
if fi == NOP then no field is not touched */
} FORM_RULES;
/* Pointers to allocated fields */
char *Field_A, *Field_B;
/* Form definition */
FORM_RULES twx[] = {
{ &Field_A, VNOP},
{ &Field_B, VNOP},
};
main()
{
Field_A = "ABC"; /* Same as malloc, but with content */
Field_B = "DEF";
printf("\n Field A via pointer is %s double pointer %s",
Field_A, *(twx[0].fptr));
printf("\n Field B via pointer is %s double pointer %s",
Field_B, *(twx[1].fptr));
}
Listing 5:
#include <stdio.h>
typedef int VALIDATE;
typedef VALIDATE (* VALIDATER)(); /* Pointer to C function returning int */
#define VNOP ((VALIDATER) 0 ) /* Null function -- validate not required */
typedef struct field_element {
char **fptr; /* Address of a field pointer */
VALIDATER *fi; /* Pointer to field function,
if fi == NOP then no field is not touched */
} FORM_RULES;
/* Pointers to functions */
VALIDATER Function_A;
VALIDATER Function_B;
/* Form definition */
FORM_RULES twx[] = {
{ NULL, &Function_A},
{ NULL, &Function_B},
};
VALIDATE function_one(), function_two();
main()
{
Function_A = function_one;
Function_B = function_two;
/* Call the functions */
(**twx[0].fi)();
(**twx[1].fi)();
}
VALIDATE function_one()
{
printf("\n Function one called");
return 0;
}
VALIDATE function_two()
{
printf("\n Function two called");
return 0;
}
Listing 6:
typedef int VALIDATE;
#define VNOP ((VALIDATE *) 0 ) /* Null function -- validate not required */
struct field_element {
char **fptr; /* Address of a field pointer */
VALIDATE **fi; /* Pointer to pointer to field function */
};
/* Pointers to functions */
VALIDATE *Function_A;
VALIDATE *Function_B;
struct field_element twx[] = {
{ NULL, &Function_A},
{ NULL, &Function_B},
};
func_a()
{
printf("\n Func_a was called--need the real one for this \n");
return ;
}
SCREEN.C Listing
/*
* SCREEN.C
* Modification of IVCLOCK using intervention code
*
* SCREEN goes to the scheduler via timer every 37 clock tics
* The timer clock ticks every 55 msec. x 37 == once per 2 seconds
* OR every keyboard entry.
*
* The command line format is as follows:
*
* screen
*
* screen -r
* removes the system from resident status
*
* A Change had to be made in the Interrupt Handler for INT 9
* to allow the system to respond on every key stroke
*
* CTL-F1 puts the system to sleep (without removing it)
* CTL-F2 wakes it up again.
*
* David Tal -8/XI/88
*/
#include <dos.h>
#include <stdio.h>
#include <binterv.h>
#include <bintrupt.h>
#include <bkeys.h>
#include <bscreens.h>
/* scr is the function which will be called */
/* approximately once per 2 sec. or at a keystroke */
extern void scr (IV_EVENT *);
#define STKSIZE 2000
#define OK 0
#define FALL_OUT 101
#define NOT_FOUND 1
#define ERROR_DISABLING 2
#define ERROR_REMOVING 3
#define ALREADY_INSTALLED 4
/* Definitive signature for this version of sched.*/
#define ol_sign "screen 08/11/88"
/* Allocation of stack space for the intervention */
/* scheduler and user function. */
char schedstk [STKSIZE];
/* This is the data structure to pass to the */
/* scheduler so that it will give control every */
/* 37 clock ticks. */
IV_TIME timetab = {37, IV_TM_INTERVAL};
IV_KEY keytab[3] = {
KB_C_C_F3,KB_S_C_F3,IV_KY_SERVICE,
KB_C_C_F1,KB_S_C_F1,IV_KY_SLEEP,
KB_C_C_F2,KB_S_C_F2,IV_KY_WAKE
};
/* Internal functions -- install & remove ISR. */
int install_iv (void);
int remove_iv (void);
/* here is the main program */
int main (argc, argv)
int argc;
char *argv [];
{
if (argc == 1)
exit (install_iv ());
if ((argc == 2) &&
(((argv [1][0] == '-') || (argv [1][0] == '/')) &&
((argv [1][1] == 'r') || (argv [1][1] == 'R'))))
exit (remove_iv ());
printf ("usage: screen [-r]\n");
exit (0);
}
/**
*
* Name INSTALL_IV -- Install interrupt vectors for IVREADAD and
* go TSR(terminate and stay resident).
*
* Synopsis ret = install_iv ();
*
* int ret Return code from IVINSTAL if there was
* a problem with installation of the
* intervention code routine.
*
* Description This function installs screen if another copy
* is not already installed.
*
* Returns ret ALREADY_INSTALLED (4)
* A copy of screen is already installed.
* FALL_OUT (101)
* ISRESEXT() failed.
* IV_INSTALLED (5)
* A copy of screen is already installed.
*
**/
#include <butil.h>
int install_iv ()
{
int ercode;
IV_VECTORS vecs;
/* Check to see if IVREADAD already installed. */
ivvecs (IV_RETVEC, &vecs);
if (ivsense (&vecs, ol_sign) != FARNIL)
{
puts ("SCREEN already installed.");
return (ALREADY_INSTALLED);
}
/* Install the interrupt service routine--i.e. tell */
/* the scheduler about our sched routine. */
/* note: this routine ivinstam is an altered version of ivinstal, in which
all keyboard interrupts are accepted */
if (0 !=( ercode =
ivinstam (scr, ol_sign, schedstk, STKSIZE,
&keytab, 3 ,&timetab,
sizeof(timetab) / sizeof(IV_TIME),
/* screen uses DOS support. */
IV_DOS_NEED)))
{ /* Error! */
printf ("Install error %d.\n", ercode);
return (ercode);
}
/* Terminate and stay resident. */
puts(" ******************************");
puts(" * *");
puts(" * EGA Screen Saver Installed *");
puts(" * *");
puts(" * autoerase every 3 minutes *");
puts(" ******************************");
isresext (OK);
/* Should never get here. */
return (FALL_OUT);
}
/**
*
* Name REMOVE_IV -- Remove a previously-installed copy of screen
*
* Synopsis ret = remove_iv ();
*
* int ret Return code.
* NO_ERROR (0)-
* No error encountered.
* NOT_FOUND (1)-
* pgm not found.
* ERROR_DISABLING (2)-
* pgm could not be disabled.
* This error should *never* be
* seen.
* ERROR_REMOVING (3)--
* pgm could not be removed
* (most likely overwritten MALLOC
* pointers).
*
* Description This function removes a currently-active copy of screen
* from memory, cleaning up interrupt vectors and freeing
* memory in the process.
*
* Returns ret (nonzero if error--see above).
*
**/
int remove_iv ()
{
IV_VECTORS vecs;
IV_CTRL far *pivctrl;
ivvecs (IV_RETVEC, &vecs);
if ((pivctrl = ivsense (&vecs, ol_sign)) == FARNIL)
{
puts ("SCREEN not found.");
return (NOT_FOUND);
}
if (ivdisabl (pivctrl))
{
puts ("Error disabling SCREEN");
return (ERROR_DISABLING);
}
if (isremove (pivctrl->psp))
{
puts ("Error removing SCREEN");
return (ERROR_REMOVING);
}
puts ("SCREEN successfully removed");
return (0);
}
/* Pointer to intervention event
* structure. The structure
* contains the current time of
* day (in timer ticks since
* midnight) as well as other
* data.
*
* Description This function accepts control from the scheduler
* every 2 sec
*
*
* Returns None.
*
**/
#include <binterv.h>
#include <time.h>
#include <bscreens.h>
#define TRUE 1
#define FALSE 0
void scr (pevent)
/* scr is the part of the program that does something */
IV_EVENT *pevent;
{
static long oldtime = {0};
long sec; /* the current time (in seconds since xx/yy/zz) */
static char scoff = {FALSE}; /* flag indicating that the scr. is OFF*/
static int pmode,pc,actpag;
static int setpage;
int seconds_to_wait;
seconds_to_wait = 180; /* set the number of seconds before the
screen resets here */
if (pevent->key.action == IV_KY_SLEEP)
printf("IV_KY_SLEEP\n");
if (pevent->key.action == IV_KY_WAKE)
printf("IV_KY_WAKE\n");
if (pevent->key.action == IV_KY_NONE)
/* no key pressed */
{
if(oldtime == 0) oldtime = time(&sec); /* initialization of oldtime */
if(( time(&sec) - oldtime > seconds_to_wait) && (scoff == FALSE))
{
/* TIMED OUT! reset the screen */
scmode(&pmode,&pc,&actpag); /* get mode and active page */
if (pmode ==3)setpage = 3-actpag;
else setpage = 1-actpag; /* Basically handles only
text and graphics mode for EGA. Assume one page
is blank. This works for me 99+ % of the time */
scapage(setpage); /* shut off the screen */
scpgcur(1,0,0,CUR_ADJUST); /* shut off cursor */
/* NOTE: for some reason, the cursor does NOT go off when in Text mode.
I do not completely understand why not. */
scoff = TRUE; /* set software flag indicating condition */
}
}
/* was a key pressed? */
/* NOTE: the Interrupt handler IVCNTRL was changed in the IVKEYBD section
so that all key strokes except CTL-F1 and CTL-F2 would bear
the IV_KY_SERVICE flag. New version is called IVCNTRLX. */
if (pevent->key.action == IV_KY_SERVICE)
{
oldtime = time(&sec); /* 1st, adjust the clock */
if( scoff == TRUE) /* is the screen turned off? */
/* turn the screen back on */
{
scoff = FALSE;
scapage(actpag); /* restore page */
scpgcur(0,12,13,CUR_ADJUST); /* turn the cursor back on */
}
}
}