Source file: /~heha/messtech/pasmex.zip/CMEX.C

/************************************************************************
 * CMEX Bibliothek für Pascal-Matlab-Funktionen				*
 * Diese Bibliothek "kapselt" die Unterprogramme mit C-Aufrufkonvention	*
 * in "Hüllen" mit Pascal-Aufrufkonvention (Ausnahme: mexPrintf)	*
 * h#s, 07/97, Idee: EA							*
 * PROBLEM: Ist bei matXXX() das "int" nun ein "long" oder nicht?	*
 ************************************************************************/

#define DLLMEX

#ifndef NO_MAT
#include <stdio.h>		// Bugfix Nr. 2 (als Folge von Nr. 1)
#define __STDC__		// Bugfix Nr. 1
struct matfile { int dummy;}	// Bugfix Nr. 3 (Warnung vermeiden)
#include <mat.h>		// Zugriff auf mat-Dateien (Extra-DLL?)
#endif //NO_MAT
#ifndef NO_ENG
#include <engine.h>		// Zugriff auf MATLAB als DDE-Server
#endif //NO_ENG
#include <dllmex.h>		// #include <windows.h> in dllmex.h

#define _EXPORT _export far pascal

/* MX-Funktionen */

char* _EXPORT dllmxGetName(const Matrix *pm) {
 return mxGetName(pm);
}

void _EXPORT dllmxSetName(Matrix *pm,const char *s) {
 mxSetName(pm,s);
}

long _EXPORT dllmxGetM(const Matrix *pm) {
 return mxGetM(pm);
}

void _EXPORT dllmxSetM(Matrix *pm, long m) {
 mxSetM(pm,m);
}

long _EXPORT dllmxGetN(const Matrix *pm) {
 return mxGetN(pm);
}

void _EXPORT dllmxSetN(Matrix *pm, long n) {
 mxSetN(pm,n);
}

double* _EXPORT dllmxGetPr(const Matrix *pm) {
 return mxGetPr(pm);
}

void _EXPORT dllmxSetPr(Matrix *pm, double *pr) {
 mxSetPr(pm,pr);
}

double* _EXPORT dllmxGetPi(const Matrix *pm) {
 return mxGetPi(pm);
}

void _EXPORT dllmxSetPi(Matrix *pm, double *pi) {
 mxSetPi(pm,pi);
}

long _EXPORT dllmxGetNzmax(const Matrix *pm) {
 return mxGetNzmax(pm);
}

void _EXPORT dllmxSetNzmax(Matrix *pm, long nzmax) {
 mxSetNzmax(pm,nzmax);
}

long* _EXPORT dllmxGetIr(const Matrix *pm) {
 return mxGetIr(pm);
}

void _EXPORT dllmxSetIr(Matrix *pm, long* ir) {
 mxSetIr(pm,ir);
}

long* _EXPORT dllmxGetJc(const Matrix *pm) {
 return mxGetJc(pm);
}

void _EXPORT dllmxSetJc(Matrix *pm, long* jc) {
 mxSetJc(pm,jc);
}

int _EXPORT dllmxIsComplex(const Matrix *pm) {
 return mxIsComplex(pm);
}

int _EXPORT dllmxIsDouble(const Matrix *pm) {
 return mxIsDouble(pm);
}

int _EXPORT dllmxIsFull(const Matrix *pm) {
 return mxIsFull(pm);
}

int _EXPORT dllmxIsNumeric(const Matrix *pm) {
 return mxIsNumeric(pm);
}

int _EXPORT dllmxIsSparse(const Matrix *pm) {
 return mxIsSparse(pm);
}

int _EXPORT dllmxIsString(const Matrix *pm) {
 return mxIsString(pm);
}

int _EXPORT dllmxGetString(Matrix *pm, char *str_ptr, long str_len) {
 return mxGetString(pm,str_ptr,str_len);
}

double _EXPORT dllmxGetScalar(Matrix *pm) {
 return mxGetScalar(pm);
}

Matrix* _EXPORT dllmxCreateFull(long m, long n, long imag_flag) {
 return mxCreateFull(m,n,imag_flag);
}

void _EXPORT dllmxFreeMatrix(Matrix *pmat) {
 mxFreeMatrix(pmat);
}

void* _EXPORT dllmxCalloc(unsigned int n, unsigned int size) {
 return mxCalloc(n,size);
}

void _EXPORT dllmxFree(void *p) {
 mxFree(p);
}

Matrix* _EXPORT dllmxCreateSparse(long m, long n, long nzmax, long cmplx) {
 return mxCreateSparse(m,n,nzmax,cmplx);
}

Matrix* _EXPORT dllmxCreateString(char *str_ptr) {
 return mxCreateString(str_ptr);
}

/* MEX-Funktionen */

#pragma argsused
void _EXPORT mexFunction(int nl,Matrix **pl,int nr,Matrix **pr) {
 mexErrMsgTxt("abstract: CMEX is a template DLL-MEX");
}

int _EXPORT dllmexAtExit(void(*ExitFcn)()) {
 return mexAtExit(ExitFcn);
}

Matrix* _EXPORT dllmexGetGlobal(const char *name) {
 return mexGetGlobal(name);
}

Matrix* _EXPORT dllmexGetMatrixPtr(const char *name) {
 return mexGetMatrixPtr(name);
}

int _EXPORT dllmexCallMATLAB(int nlhs, Matrix **plhs,
  int nrhs, Matrix **prhs, char *name) {
 return mexCallMATLAB(nlhs,plhs,nrhs,prhs,name);
}

void _EXPORT dllmexSetTrapFlag(int flag) {
 mexSetTrapFlag(flag);
}

void _EXPORT dllmexErrMsgTxt(const char *pch) {
 mexErrMsgTxt(pch);
}

/* Sonderfall mexPrintf() kann nicht "verhüllt" werden! */

int _EXPORT dllmexEvalString(const char *pch) {
 return mexEvalString(pch);
}

Matrix* _EXPORT dllmexGetMatrix(char *name) {
 return mexGetMatrix(name);
}

int _EXPORT dllmexPutMatrix(Matrix *pm) {
 return mexPutMatrix(pm);
}

int _EXPORT dllmexGetFull(char *name, long *m, long *n,
  double **pr, double **pi) {
 return mexGetFull(name,m,n,pr,pi);
}

int _EXPORT dllmexPutFull(char *name, long m, long n,
  double *pr, double *pi) {
 return mexPutFull(name,m,n,pr,pi);
}

#ifndef NO_MAT
/* MAT-Funktionen */

MATFile* _EXPORT dllmatOpen(char *filename,char *mode) {
 return matOpen(filename,mode);
}

int _EXPORT dllmatClose(MATFile *ph) {
 return matClose(ph);
}

FILE* _EXPORT dllmatGetFp(MATFile *ph) {
 return matGetFp(ph);
}

char** _EXPORT dllmatGetDir(MATFile *ph, long *num) {
 return matGetDir(ph,num);
}

int _EXPORT dllmatDeleteMatrix(MATFile *ph, char *name) {
 return matDeleteMatrix(ph,name);
}

Matrix* _EXPORT dllmatGetMatrix(MATFile *ph, char *name) {
 return matGetMatrix(ph,name);
}

int _EXPORT dllmatPutMatrix(MATFile *ph, Matrix *mp) {
 return matPutMatrix(ph,mp);
}

Matrix* _EXPORT dllmatGetNextMatrix(MATFile *ph) {
 return matGetNextMatrix(ph);
}

int _EXPORT dllmatGetFull(MATFile *ph, char *name, long *m, long *n,
  double **pr, double **pi) {
 return matGetFull(ph,name,m,n,pr,pi);
}

int _EXPORT dllmatPutFull(MATFile *ph, char *name, long m, long n,
  double *pr, double *pi) {
 return matPutFull(ph,name,m,n,pr,pi);
}

int _EXPORT dllmatGetString(MATFile *ph, char *name,
  char *string, long str_len) {
 return matGetString(ph,name,string,str_len);
}

int _EXPORT dllmatPutString(MATFile *ph, char *name, char *string) {
 return matPutString(ph,name,string);
}
#endif

/* ENG-Funktionen */

void _EXPORT dllengWinInit(HANDLE hInstance) {
 engWinInit(hInstance);
}

Engine* _EXPORT dllengOpen(char *cmdstr) {
 return engOpen(cmdstr);
}

void _EXPORT dllengSetEvalTimeout(Engine *ep,long timeout) {
 engSetEvalTimeout(ep,timeout);
}

void _EXPORT dllengSetEvalCallback(Engine *ep,void (*callback)()) {
 engSetEvalCallback(ep,callback);
}

int _EXPORT dllengEvalString(Engine *ep, char *string) {
 return engEvalString(ep,string);
}

int _EXPORT dllengClose(Engine *ep) {
 return engClose(ep);
}

Matrix* _EXPORT dllengGetMatrix(Engine *ep, char *name) {
 return engGetMatrix(ep,name);
}

int _EXPORT dllengPutMatrix(Engine *ep, Matrix *mp) {
 return engPutMatrix(ep,mp);
}

int _EXPORT dllengGetFull(Engine *ep, char *name,
  FOUR_BYTE_INT *m, FOUR_BYTE_INT *n, Real **pr, Real **pi) {
 return engGetFull(ep,name,m,n,pr,pi);
}

int _EXPORT dllengPutFull(Engine *ep, char *name,
 FOUR_BYTE_INT m, FOUR_BYTE_INT n, Real *pr, Real *pi) {
 return engPutFull(ep,name,m,n,pr,pi);
}

void _EXPORT dllengOutputBuffer(Engine *ep, char *buffer, int buflen) {
 engOutputBuffer(ep,buffer,buflen);
}

/* Variablenzugriffe */

HANDLE _EXPORT dllhInstMATLAB(void) {
 return hInstMATLAB;
}

HWND _EXPORT dllhWndMATLABCmd(void) {
 return hWndMATLABCmd;
}

HANDLE _EXPORT dllhInstDLL(void) {
 return hInstDLL;
}

WORD _EXPORT dllwDataSegment(void) {
 return wDataSegment;
}

WORD _EXPORT dllwHeapSize(void) {
 return wHeapSize;
}

/* HugeMem-Zugriffe */
#if 0	// Etwas effektivere Lösung in Assembler (ohne Entry/Exitcode)
void _EXPORT IncHP(char huge **p, unsigned by) {
 *p+=by;
}

void _EXPORT DecHP(char huge **p, unsigned by) {
 *p-=by;
}

void _EXPORT IncHPL(char huge **p, long by) {
 *p+=by;
}
#endif

/* VPrintf auf Printf aufzusetzen erfordert den Klimmzug, die Daten
 * auf den Stack kopieren zu müssen. Dazu ist eine Längenangabe nötig,
 * um Schutzverletzungen durch Segmentüberschreitungen auszuschließen.
 * Alternativ wäre die Bestimmung der Segmentgrenze mit "lsl" möglich,
 * aber wer will eine "reichliche" Menge Words auf den Stack kopieren?
 */
void _EXPORT mexVPrintf(const char *s, const void *args, unsigned arglen) {
 asm{	mov	cx,[arglen]
	jcxz	lbl1
	inc	cx
	and	cl,not 1	// gerade aufrunden: Anzahl Bytes
	mov	[arglen],cx	// retten
	sub	sp,cx		// Platz auf dem Stack
	mov	di,sp		// Ziel
	push	es
	push	ds
	push	ss
	pop	es		// Ziel in ES:DI
	lds	si,[args]	// Quelle in DS:SI
	shr	cx,1		// Anzahl Words
	cld
	rep	movsw		// auf den Stack kopieren
	pop	ds
	pop	es
 }lbl1: mexPrintf(s);
 asm{	add	sp,[arglen]	// Stackkorrektur
 }
}

/* Um die zur DLL gehörige MATLAB-Bibliotheks-Version abzufagen, diese
 * obligatorische Funktion
 */
unsigned _EXPORT mxGetLibVersion(void) {
 return 4*256+20;
}