home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
OS/2 Shareware BBS: 10 Tools
/
10-Tools.zip
/
WPSDEM.ZIP
/
COMPUTER
/
MICRO.IH
< prev
next >
Wrap
Text File
|
1992-08-06
|
16KB
|
578 lines
/*
* This file was generated by the SOM Compiler.
* FileName: micro.ih.
* Generated using:
* SOM Precompiler spc: 1.22
* SOM Emitter emitih: 1.59
*/
#ifndef micro_ih
#define micro_ih
/*
* Passthru lines: File: "C.ih", "before"
*/
#include <stdio.h>
#include "micro.h"
/*
* Set the scope of methods functions
*/
#ifndef SOM_Scope
#define SOM_Scope static
#endif
#ifndef SOM_CurrentClass
#define SOM_CurrentClass MicrocomputerCClassData.parentMtab
#endif
#define Microcomputer_MaxNoMethods 10
/*
* Instance data
*/
typedef struct {
double Registers[26];
double Stack[20];
int SP;
} MicrocomputerData;
/*
* Instance variable access macros
*/
#define _Registers (somThis->Registers)
#define _Stack (somThis->Stack)
#define _SP (somThis->SP)
/*
* Getdata macro
*/
#define MicrocomputerGetData(somSelf) \
((MicrocomputerData *) \
SOM_DataResolve(somSelf, MicrocomputerCClassData.instanceDataToken))
/*
* Trace/Debug macro
*/
#ifndef MicrocomputerMethodDebug
#define MicrocomputerMethodDebug(c,m) SOMMethodDebug(c,m)
#endif
/*
* Begin stuff that only goes in the primary file
*/
#ifdef Microcomputer_Class_Source
/*
* Current class macros for Instance and Meta classes.
*/
#undef SOMMeta
#define SOMMeta M_MicrocomputerCClassData.parentMtab
#undef SOMInstance
#define SOMInstance MicrocomputerCClassData.parentMtab
#ifndef M_Microcomputer_Class_Source
#define M_Microcomputer_Class_Source
#endif /* M_Microcomputer_Class_Source */
/*
* Generate the Apply Stubs.
*/
#pragma linkage(somAP_Add, system)
static void SOMLINK somAP_Add(Microcomputer *somSelf,
somId __id,
somId __desc,
va_list __ap)
{
__ap; __id; __desc; /* Referenced to prevent warning msg */
Microcomputer_Add(somSelf);
}
#pragma linkage(somAP_Sub, system)
static void SOMLINK somAP_Sub(Microcomputer *somSelf,
somId __id,
somId __desc,
va_list __ap)
{
__ap; __id; __desc; /* Referenced to prevent warning msg */
Microcomputer_Sub(somSelf);
}
#pragma linkage(somAP_Mul, system)
static void SOMLINK somAP_Mul(Microcomputer *somSelf,
somId __id,
somId __desc,
va_list __ap)
{
__ap; __id; __desc; /* Referenced to prevent warning msg */
Microcomputer_Mul(somSelf);
}
#pragma linkage(somAP_Div, system)
static void SOMLINK somAP_Div(Microcomputer *somSelf,
somId __id,
somId __desc,
va_list __ap)
{
__ap; __id; __desc; /* Referenced to prevent warning msg */
Microcomputer_Div(somSelf);
}
#pragma linkage(somAP_Pop, system)
static double SOMLINK somAP_Pop(Microcomputer *somSelf,
somId __id,
somId __desc,
va_list __ap)
{
__ap; __id; __desc; /* Referenced to prevent warning msg */
return (Microcomputer_Pop(somSelf));
}
#pragma linkage(somAP_Push, system)
static void SOMLINK somAP_Push(Microcomputer *somSelf,
somId __id,
somId __desc,
va_list __ap)
{
double Item = va_arg(__ap, double);
__ap; __id; __desc; /* Referenced to prevent warning msg */
Microcomputer_Push(somSelf,Item);
}
#pragma linkage(somAP_Store, system)
static void SOMLINK somAP_Store(Microcomputer *somSelf,
somId __id,
somId __desc,
va_list __ap)
{
int Reg = va_arg(__ap, int);
__ap; __id; __desc; /* Referenced to prevent warning msg */
Microcomputer_Store(somSelf,Reg);
}
#pragma linkage(somAP_Fetch, system)
static void SOMLINK somAP_Fetch(Microcomputer *somSelf,
somId __id,
somId __desc,
va_list __ap)
{
int Reg = va_arg(__ap, int);
__ap; __id; __desc; /* Referenced to prevent warning msg */
Microcomputer_Fetch(somSelf,Reg);
}
#pragma linkage(somAP_Input, system)
static void SOMLINK somAP_Input(Microcomputer *somSelf,
somId __id,
somId __desc,
va_list __ap)
{
__ap; __id; __desc; /* Referenced to prevent warning msg */
Microcomputer_Input(somSelf);
}
#pragma linkage(somAP_Output, system)
static void SOMLINK somAP_Output(Microcomputer *somSelf,
somId __id,
somId __desc,
va_list __ap)
{
__ap; __id; __desc; /* Referenced to prevent warning msg */
Microcomputer_Output(somSelf);
}
/*
* Overridden method: somInit
*/
#pragma linkage(somInit, system)
SOM_Scope void SOMLINK somInit(Microcomputer *somSelf);
#ifndef parent_somInit
static char *somMN_somInit = "somInit";
static somId somId_somInit = &somMN_somInit;
#define parent_somInit(somSelf) \
((SOM_ParentResolveE(SOMObject, SOM_CurrentClass, somInit)) \
(somSelf))
#endif
#define MicrocomputerParent_somInit parent_somInit
/*
* Overridden method: somUninit
*/
#pragma linkage(somUninit, system)
SOM_Scope void SOMLINK somUninit(Microcomputer *somSelf);
#ifndef parent_somUninit
static char *somMN_somUninit = "somUninit";
static somId somId_somUninit = &somMN_somUninit;
#define parent_somUninit(somSelf) \
((SOM_ParentResolveE(SOMObject, SOM_CurrentClass, somUninit)) \
(somSelf))
#endif
#define MicrocomputerParent_somUninit parent_somUninit
/*
* Temporary class data structure used only in class creation
*/
static somClassDataStructure MicrocomputertempClassData;
/*
* Initialize the class data structure
*/
struct MicrocomputerClassDataStructure MicrocomputerClassData = {(SOMAny *) NULL};
/*
* Define the C class data structure
*/
struct MicrocomputerCClassDataStructure MicrocomputerCClassData = {(somMethodTab *) NULL};
/*
* New Method: Add
*/
#pragma linkage(Add, system)
SOM_Scope void SOMLINK Add(Microcomputer *somSelf);
static char *somMN_Add = "Add";
static somId somId_Add = &somMN_Add;
static char *somDS_Add = somMD_Microcomputer_Add;
static somId somDI_Add = &somDS_Add;
#pragma linkage(somRD_Add, system)
static void SOMLINK somRD_Add(Microcomputer *somSelf)
{
va_somDispatchV(somSelf, somId_Add,
_somGetMethodDescriptor(SOM_GetClass(somSelf),somId_Add));
}
/*
* New Method: Sub
*/
#pragma linkage(Sub, system)
SOM_Scope void SOMLINK Sub(Microcomputer *somSelf);
static char *somMN_Sub = "Sub";
static somId somId_Sub = &somMN_Sub;
static char *somDS_Sub = somMD_Microcomputer_Sub;
static somId somDI_Sub = &somDS_Sub;
#pragma linkage(somRD_Sub, system)
static void SOMLINK somRD_Sub(Microcomputer *somSelf)
{
va_somDispatchV(somSelf, somId_Sub,
_somGetMethodDescriptor(SOM_GetClass(somSelf),somId_Sub));
}
/*
* New Method: Mul
*/
#pragma linkage(Mul, system)
SOM_Scope void SOMLINK Mul(Microcomputer *somSelf);
static char *somMN_Mul = "Mul";
static somId somId_Mul = &somMN_Mul;
static char *somDS_Mul = somMD_Microcomputer_Mul;
static somId somDI_Mul = &somDS_Mul;
#pragma linkage(somRD_Mul, system)
static void SOMLINK somRD_Mul(Microcomputer *somSelf)
{
va_somDispatchV(somSelf, somId_Mul,
_somGetMethodDescriptor(SOM_GetClass(somSelf),somId_Mul));
}
/*
* New Method: Div
*/
#pragma linkage(Div, system)
SOM_Scope void SOMLINK Div(Microcomputer *somSelf);
static char *somMN_Div = "Div";
static somId somId_Div = &somMN_Div;
static char *somDS_Div = somMD_Microcomputer_Div;
static somId somDI_Div = &somDS_Div;
#pragma linkage(somRD_Div, system)
static void SOMLINK somRD_Div(Microcomputer *somSelf)
{
va_somDispatchV(somSelf, somId_Div,
_somGetMethodDescriptor(SOM_GetClass(somSelf),somId_Div));
}
/*
* New Method: Pop
*/
#pragma linkage(Pop, system)
SOM_Scope double SOMLINK Pop(Microcomputer *somSelf);
static char *somMN_Pop = "Pop";
static somId somId_Pop = &somMN_Pop;
static char *somDS_Pop = somMD_Microcomputer_Pop;
static somId somDI_Pop = &somDS_Pop;
#pragma linkage(somRD_Pop, system)
static double SOMLINK somRD_Pop(Microcomputer *somSelf)
{
return ((double) va_somDispatchD(somSelf, somId_Pop,
_somGetMethodDescriptor(SOM_GetClass(somSelf),somId_Pop)));
}
/*
* New Method: Push
*/
#pragma linkage(Push, system)
SOM_Scope void SOMLINK Push(Microcomputer *somSelf,
double Item);
static char *somMN_Push = "Push";
static somId somId_Push = &somMN_Push;
static char *somDS_Push = somMD_Microcomputer_Push;
static somId somDI_Push = &somDS_Push;
#pragma linkage(somRD_Push, system)
static void SOMLINK somRD_Push(Microcomputer *somSelf,
double Item)
{
va_somDispatchV(somSelf, somId_Push,
_somGetMethodDescriptor(SOM_GetClass(somSelf),somId_Push),Item);
}
/*
* New Method: Store
*/
#pragma linkage(Store, system)
SOM_Scope void SOMLINK Store(Microcomputer *somSelf,
int Reg);
static char *somMN_Store = "Store";
static somId somId_Store = &somMN_Store;
static char *somDS_Store = somMD_Microcomputer_Store;
static somId somDI_Store = &somDS_Store;
#pragma linkage(somRD_Store, system)
static void SOMLINK somRD_Store(Microcomputer *somSelf,
int Reg)
{
va_somDispatchV(somSelf, somId_Store,
_somGetMethodDescriptor(SOM_GetClass(somSelf),somId_Store),Reg);
}
/*
* New Method: Fetch
*/
#pragma linkage(Fetch, system)
SOM_Scope void SOMLINK Fetch(Microcomputer *somSelf,
int Reg);
static char *somMN_Fetch = "Fetch";
static somId somId_Fetch = &somMN_Fetch;
static char *somDS_Fetch = somMD_Microcomputer_Fetch;
static somId somDI_Fetch = &somDS_Fetch;
#pragma linkage(somRD_Fetch, system)
static void SOMLINK somRD_Fetch(Microcomputer *somSelf,
int Reg)
{
va_somDispatchV(somSelf, somId_Fetch,
_somGetMethodDescriptor(SOM_GetClass(somSelf),somId_Fetch),Reg);
}
/*
* New Method: Input
*/
#pragma linkage(Input, system)
SOM_Scope void SOMLINK Input(Microcomputer *somSelf);
static char *somMN_Input = "Input";
static somId somId_Input = &somMN_Input;
static char *somDS_Input = somMD_Microcomputer_Input;
static somId somDI_Input = &somDS_Input;
#pragma linkage(somRD_Input, system)
static void SOMLINK somRD_Input(Microcomputer *somSelf)
{
va_somDispatchV(somSelf, somId_Input,
_somGetMethodDescriptor(SOM_GetClass(somSelf),somId_Input));
}
/*
* New Method: Output
*/
#pragma linkage(Output, system)
SOM_Scope void SOMLINK Output(Microcomputer *somSelf);
static char *somMN_Output = "Output";
static somId somId_Output = &somMN_Output;
static char *somDS_Output = somMD_Microcomputer_Output;
static somId somDI_Output = &somDS_Output;
#pragma linkage(somRD_Output, system)
static void SOMLINK somRD_Output(Microcomputer *somSelf)
{
va_somDispatchV(somSelf, somId_Output,
_somGetMethodDescriptor(SOM_GetClass(somSelf),somId_Output));
}
/*
* Routines to create the class object
*/
/*
* Declare the Static Methods table.
*/
static somStaticMethod_t MicrocomputerSM[] = {
{ &MicrocomputerClassData.Add,
&somId_Add,
&somDI_Add,
(somMethodProc *) Add,
(somMethodProc *) somRD_Add,
(somMethodProc *) somAP_Add },
{ &MicrocomputerClassData.Sub,
&somId_Sub,
&somDI_Sub,
(somMethodProc *) Sub,
(somMethodProc *) somRD_Sub,
(somMethodProc *) somAP_Sub },
{ &MicrocomputerClassData.Mul,
&somId_Mul,
&somDI_Mul,
(somMethodProc *) Mul,
(somMethodProc *) somRD_Mul,
(somMethodProc *) somAP_Mul },
{ &MicrocomputerClassData.Div,
&somId_Div,
&somDI_Div,
(somMethodProc *) Div,
(somMethodProc *) somRD_Div,
(somMethodProc *) somAP_Div },
{ &MicrocomputerClassData.Pop,
&somId_Pop,
&somDI_Pop,
(somMethodProc *) Pop,
(somMethodProc *) somRD_Pop,
(somMethodProc *) somAP_Pop },
{ &MicrocomputerClassData.Push,
&somId_Push,
&somDI_Push,
(somMethodProc *) Push,
(somMethodProc *) somRD_Push,
(somMethodProc *) somAP_Push },
{ &MicrocomputerClassData.Store,
&somId_Store,
&somDI_Store,
(somMethodProc *) Store,
(somMethodProc *) somRD_Store,
(somMethodProc *) somAP_Store },
{ &MicrocomputerClassData.Fetch,
&somId_Fetch,
&somDI_Fetch,
(somMethodProc *) Fetch,
(somMethodProc *) somRD_Fetch,
(somMethodProc *) somAP_Fetch },
{ &MicrocomputerClassData.Input,
&somId_Input,
&somDI_Input,
(somMethodProc *) Input,
(somMethodProc *) somRD_Input,
(somMethodProc *) somAP_Input },
{ &MicrocomputerClassData.Output,
&somId_Output,
&somDI_Output,
(somMethodProc *) Output,
(somMethodProc *) somRD_Output,
(somMethodProc *) somAP_Output },
};
/*
* Declare the Override Methods table.
*/
static somOverrideMethod_t MicrocomputerOM[] = {
{ &somId_somInit,
(somMethodProc *) somInit },
{ &somId_somUninit,
(somMethodProc *) somUninit },
};
static void MicrocomputersomInitializeClass ()
{
int i;
somStaticMethod_t *smp;
somOverrideMethod_t *omp;
/*
* Add the Static Methods.
*/
for (smp = MicrocomputerSM, i = 0; i < 10; smp++, i++)
*(smp->classData) =
_somAddStaticMethod (MicrocomputertempClassData.classObject,
*(smp->methodId), *(smp->methodDescriptor),
smp->method, smp->redispatchStub,
smp->applyStub);
/*
* Override methods.
*/
for (omp = MicrocomputerOM, i = 0; i < 2; omp++, i++)
_somOverrideSMethod (MicrocomputertempClassData.classObject,
*(omp->methodId), omp->method);
}
#pragma linkage(MicrocomputersomCreateClass, system)
static void SOMLINK MicrocomputersomCreateClass(SOMClass *pClsObj,
SOMClass *mClsObj)
{
MicrocomputertempClassData.classObject = _somNew (mClsObj);
_somInitClass (MicrocomputertempClassData.classObject,
"Microcomputer",
pClsObj,
sizeof(MicrocomputerData),
Microcomputer_MaxNoMethods,
Microcomputer_MajorVersion,
Microcomputer_MinorVersion);
MicrocomputerCClassData.instanceDataToken =
_somGetInstanceToken(MicrocomputertempClassData.classObject);
MicrocomputersomInitializeClass();
MicrocomputerCClassData.parentMtab =
_somGetPClsMtab(MicrocomputertempClassData.classObject);
_somSetClassData(MicrocomputertempClassData.classObject, (somClassDataStructure *)&MicrocomputerClassData);
_somClassReady(MicrocomputertempClassData.classObject);
/* make newly created class object visible */
MicrocomputerClassData.classObject = MicrocomputertempClassData.classObject;
}
Microcomputer * SOMLINK MicrocomputerNewClass (integer4 scemajorVersion,
integer4 sceminorVersion)
{
SOMClass *pClsObj;
SOMClass *mClsObj;
/* Check the version numbers */
if (((scemajorVersion != 0) &&
(scemajorVersion != Microcomputer_MajorVersion)) ||
((sceminorVersion != 0) &&
(sceminorVersion > Microcomputer_MinorVersion))) {
somPrintf("MicrocomputerNewClass: Error, bad version numbers.\n");
SOM_Error(SOMERROR_BadVersion);
}
/* Don't do anything if class object is already created. */
if (MicrocomputerClassData.classObject != (SOMAny *) NULL)
return(MicrocomputerClassData.classObject);
/* Make sure the environment is initialized. */
if (SOMClassMgrObject == (SOMAny *) NULL) somEnvironmentNew();
if (SOMClassMgrObject == (SOMAny *) NULL)
SOM_Error(SOMERROR_CouldNotStartup);
/* Get the parent class object. */
SOMObjectNewClass(1,1); /* static reference */
pClsObj = _somFindClass(SOMClassMgrObject,
SOM_IdFromString("SOMObject"), 1, 1);
if (pClsObj == (SOMClass *) NULL)
SOM_Error(SOMERROR_NoParentClass);
/* Use parent's metaclass */
mClsObj = SOM_GetClass(pClsObj);
somConstructClass(MicrocomputersomCreateClass, pClsObj, mClsObj,
&MicrocomputertempClassData);
return (MicrocomputerClassData.classObject);
}
#endif /* Microcomputer_Class_Source */
#endif /* micro_ih */