/************************************************************************
* 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;
}
Detected encoding: OEM (CP437) | 1
|
|