nedoPC.org

_fastcall: ; аналогично stdcall, но два первых параметра передаются через регистры
  push D
  push C
  mov edx, B
  mov eax, A
  call F
  ; ret 8 ; очистка стека - в функции

#include "stdafx.h"
//#include "vsm.hpp" //aav-
#include "tVSM.hpp" //aav+
#include "MyActiveModel.h"
#include "MyDsimModel.h"

#define OneWireDebugger_Key 0x00000000


extern "C" IDSIMMODEL __declspec (dllexport) *createdsimmodel (CHAR *device, ILICENCESERVER *ils)
extern "C" IDSIMMODEL thiscall (dllexport) *createdsimmodel (CHAR *device, ILICENCESERVER *ils)
{

  tILICENCESERVER tLS(ils); //aav+

//  tLS->authorize(OneWireDebugger_Key); //aav+

//   if (ils->authorize(OneWireDebugger_Key)) //aav-
   if (tLS.t->authorize(OneWireDebugger_Key)) { //aav+
      MessageBox(0,"authorize","VSM",0); //aav+
//      return new MyDsimModel; //aav-
      return newIDSIMMODEL(new MyDsimModel); //aav+
//      return NULL;
   } else {
      return NULL;
   }

}

extern "C" VOID __declspec (dllexport) deletedsimmodel (IDSIMMODEL *model)
{
//   delete (MyDsimModel *)model; //aav-
   deleteIDSIMMODEL((MyDsimModel *)model); //aav-
}

extern "C" IDSIMMODEL __declspec (dllexport) *createdsimmodel (CHAR *device, ILICENCESERVER *ils)
{
10012850  push        ebp 
10012851  mov         ebp,esp 
10012853  sub         esp,0C0h 
10012859  push        ebx 
1001285A  push        esi 
1001285B  push        edi 
1001285C  lea         edi,[ebp-0C0h] 
10012862  mov         ecx,30h 
10012867  mov         eax,0CCCCCCCCh 
1001286C  rep stos    dword ptr es:[edi] 

ils->authorize(0x5555,0xAAAA);
1001286E  mov         esi,esp 
10012870  push        0AAAAh 
10012875  push        5555h 
1001287A  mov         eax,dword ptr [ils] 
1001287D  mov         edx,dword ptr [eax] 
1001287F  mov         ecx,dword ptr [ils] 
10012882  mov         eax,dword ptr [edx] 
10012884  call        eax 
10012886  cmp         esi,esp 
10012888  call        @ILT+390(__RTC_CheckEsp) (1001118Bh) 
      return NULL;

003B118B  push        ebp 
003B118C  mov         ebp,esp 
003B118E  push        0AAAAh 
003B1193  push        5555h 
003B1198  mov         eax,dword ptr [ebp+0Ch] 
003B119B  push        eax 
003B119C  mov         edx,dword ptr [eax] 
003B119E  call        dword ptr [edx] 
003B11A0  xor         eax,eax 
003B11A2  pop         ebp 
003B11A3  ret         8 

int _stdcall WinMain(HINSTANCE,HINSTANCE,char*,int) {

  LS *oo=new LS;

  oo->authorize(0xAA,0x55);
  oo->aa(0xAA,0x55);

  HINSTANCE L;
  bool (*Proc)(char*,void*);
  //  F=(void(*)(char*,void*))Proc;

  //*************

  L=LoadLibrary("E:\\VSM\\vs\\Debug\\OneWireDebugger.dll");
  Proc=(bool(*)(char*,void*))GetProcAddress(L,"createdsimmodel");
  (*Proc)("hello",&oLS);

  //*************

  L=LoadLibrary("E:\\VSM\\bc-00001\\onewiredebugger.dll");
  Proc=(bool(*)(char*,void*))GetProcAddress(L,"createdsimmodel");
  (*Proc)("hello",&oLS);

  //*************

  FreeLibrary(L);

  return 0;

}

/*** 20-11-2012 ******************** aav@lora.nsk.su Алексеев А.В. ***
 * Переходние для Proteus                                            *
 ********************************************************************/

#ifndef _tVSM_HPP_

#include "VSM.HPP"

/********************************************************************/

//tILICENCESERVER

/*** 20-11-2012 ******************** aav@lora.nsk.su Алексеев А.В. ***
 * IDSIMMODEL                                                        *
 ********************************************************************/

class ttIDSIMMODEL;

class tIDSIMMODEL {

  public:

//virtual INT           isdigital (CHAR *pinname) = 0;
  virtual INT  _stdcall isdigital (CHAR *pinname) = 0;
//virtual VOID          setup (IINSTANCE *instance, IDSIMCKT *dsim) = 0;
  virtual VOID _stdcall setup (IINSTANCE *instance, IDSIMCKT *dsim) = 0;
//virtual VOID          runctrl (RUNMODES mode) = 0;
  virtual VOID _stdcall runctrl (RUNMODES mode) = 0;
//virtual VOID          actuate (REALTIME time, ACTIVESTATE newstate) = 0;
  virtual VOID _stdcall actuate (REALTIME time, ACTIVESTATE newstate) = 0;
//virtual BOOL          indicate (REALTIME time, ACTIVEDATA *newstate) = 0;
  virtual BOOL _stdcall indicate (REALTIME time, ACTIVEDATA *newstate) = 0;
//virtual VOID          simulate (ABSTIME time, DSIMMODES mode) = 0;
  virtual VOID _stdcall simulate (ABSTIME time, DSIMMODES mode) = 0;
//virtual VOID          callback (ABSTIME time, EVENTID eventid) = 0;
  virtual VOID _stdcall callback (ABSTIME time, EVENTID eventid) = 0;

  ttIDSIMMODEL* tt;

};

class ttIDSIMMODEL : private IDSIMMODEL {

  public:

   ttIDSIMMODEL(tIDSIMMODEL*);
  ~ttIDSIMMODEL(void);

  virtual INT  isdigital (CHAR *pinname);
  virtual VOID setup (IINSTANCE *instance, IDSIMCKT *dsim);
  virtual VOID runctrl (RUNMODES mode);
  virtual VOID actuate (REALTIME time, ACTIVESTATE newstate);
  virtual BOOL indicate (REALTIME time, ACTIVEDATA *newstate);
  virtual VOID simulate (ABSTIME time, DSIMMODES mode);
  virtual VOID callback (ABSTIME time, EVENTID eventid);

  private:

  tIDSIMMODEL* t;

};

extern "C" IDSIMMODEL* _stdcall    newIDSIMMODEL(tIDSIMMODEL*);
extern "C" void        _stdcall deleteIDSIMMODEL(tIDSIMMODEL*);

/*** 20-11-2012 ******************** aav@lora.nsk.su Алексеев А.В. ***
 * ILICENCESERVER                                                    *
 ********************************************************************/

class ttILICENCESERVER {

  public:

  _stdcall ttILICENCESERVER(ILICENCESERVER* ils) { tLS=ils; };

//virtual BOOL            authorize (DWORD product_id, DWORD apiver=VSM_API_VERSION);
  virtual BOOL  _stdcall  authorize (DWORD product_id, DWORD apiver=VSM_API_VERSION);
//virtual BOOL            authorizeex (DWORD product_id, DWORD apiver=VSM_API_VERSION, DWORD builddate=VSM_BUILD_DATE);
  virtual BOOL  _stdcall  authorizeex (DWORD product_id, DWORD apiver=VSM_API_VERSION, DWORD builddate=VSM_BUILD_DATE);
//virtual DWORD           getid();
  virtual DWORD _stdcall  getid();
//virtual CHAR*           getname();
  virtual CHAR*  _stdcall getname();
//virtual CHAR*           getcompany();
  virtual CHAR*  _stdcall getcompany();
//virtual CHAR*           getexpirydate();
  virtual CHAR*  _stdcall getexpirydate();

  private:

  ILICENCESERVER* tLS;

};

extern "C" ttILICENCESERVER* _stdcall    newILICENCESERVER(  ILICENCESERVER*);
extern "C" void              _stdcall deleteILICENCESERVER(ttILICENCESERVER*);

class tILICENCESERVER {

  public:
  _stdcall  tILICENCESERVER(ILICENCESERVER* ils) { t=   newILICENCESERVER(ils); }
  _stdcall ~tILICENCESERVER(void)                {   deleteILICENCESERVER(t); }

  ttILICENCESERVER* t;

};

/*** 20-11-2012 ******************** aav@lora.nsk.su Алексеев А.В. ***
 * Инициализация переходников                                        *
 ********************************************************************/


/********************************************************************/

#define _tVSM_HPP_
#endif  _tVSM_HPP_

/*** END ************************************************************/

#include <windows.h>

#include "tVSM.hpp"

extern "C" IDSIMMODEL* _stdcall    newIDSIMMODEL(tIDSIMMODEL* i) {
  return (IDSIMMODEL*)new ttIDSIMMODEL(i);
}

extern "C" void _stdcall    deleteIDSIMMODEL(tIDSIMMODEL* i) {
  delete i->tt;
//  delete i;
}

ttIDSIMMODEL::ttIDSIMMODEL(tIDSIMMODEL* i) {
  t=i;
}

ttIDSIMMODEL::~ttIDSIMMODEL(void) {
  delete t;
}

INT  ttIDSIMMODEL::isdigital (CHAR *pinname) {
  return t->isdigital(pinname);
}

VOID ttIDSIMMODEL::setup (IINSTANCE *instance, IDSIMCKT *dsim) {
  t->setup (instance,dsim);
}

VOID ttIDSIMMODEL::runctrl(RUNMODES mode) {
  t->runctrl (mode);
}

VOID ttIDSIMMODEL::actuate (REALTIME time, ACTIVESTATE newstate) {
  t->actuate (time,newstate);
}
BOOL ttIDSIMMODEL::indicate (REALTIME time, ACTIVEDATA *newstate) {
  return t->indicate (time,newstate);
}
VOID ttIDSIMMODEL::simulate (ABSTIME time, DSIMMODES mode) {
  t->simulate (time,mode);
}
VOID ttIDSIMMODEL::callback (ABSTIME time, EVENTID eventid) {
  t->callback (time,eventid);
}

//*************

ttILICENCESERVER* _stdcall newILICENCESERVER(ILICENCESERVER* ils) {
  return new ttILICENCESERVER(ils);
}

void              _stdcall deleteILICENCESERVER(ttILICENCESERVER* tls) {
  delete (tls);
}

BOOL _stdcall ttILICENCESERVER::authorize (DWORD product_id, DWORD apiver) {
  return tLS->authorize (product_id,apiver);
}

BOOL _stdcall ttILICENCESERVER::authorizeex (DWORD product_id, DWORD apiver, DWORD builddate) {
  return tLS->authorizeex (product_id,apiver,builddate);
}

DWORD _stdcall  ttILICENCESERVER::getid() {
  return tLS->getid();
}

CHAR*  _stdcall ttILICENCESERVER::getname() {
  return tLS->getname();
}
CHAR*  _stdcall ttILICENCESERVER::getcompany() {
  return tLS->getcompany();
}
CHAR*  _stdcall ttILICENCESERVER::getexpirydate() {
  return tLS->getexpirydate();
}

#pragma once
#include "StdAfx.h"
//#include "vsm.hpp" //aav-
#include "tVSM.hpp" //aav+

//class MyDsimModel : public IDSIMMODEL //aav-
class MyDsimModel : public tIDSIMMODEL //aav+
{
public:

  MyDsimModel(void); //aav+

//   INT            isdigital (CHAR *pinname); //aav-
   INT  _stdcall isdigital (CHAR *pinname); //aav+
//   VOID          setup (IINSTANCE *inst, IDSIMCKT *dsim); //aav-
   VOID _stdcall setup (IINSTANCE *inst, IDSIMCKT *dsim); //aav+
//   VOID          runctrl (RUNMODES mode); //aav-
   VOID _stdcall runctrl (RUNMODES mode); //aav+
//   VOID          actuate (REALTIME time, ACTIVESTATE newstate);
   VOID _stdcall actuate (REALTIME time, ACTIVESTATE newstate);
//   BOOL          indicate (REALTIME time, ACTIVEDATA *data);
   BOOL _stdcall indicate (REALTIME time, ACTIVEDATA *data);
//   VOID          simulate (ABSTIME time, DSIMMODES mode);
   VOID _stdcall simulate (ABSTIME time, DSIMMODES mode);
//   VOID          callback (ABSTIME time, EVENTID eventid);
   VOID _stdcall callback (ABSTIME time, EVENTID eventid);
private:
   IINSTANCE *inst;
   IDSIMCKT *ckt;
   IDSIMPIN *PinI1W;      // Пин I1W
   LONGLONG prev_time;      // Предыдущее время
   BOOL prev_st;         // Предыдущее состояние пина I1W
   IDEBUGPOPUP *myPopup;
   BYTE imode;   // Режим:
            // 0 - ожидание RESET
            // 1 - RESET получили, ожидание PRESENCE
   BYTE byt;      // Байт, считанный с линии
   BYTE num_bit;      // Номер бита
   BYTE kolvo;      // Сколько байт будем передавать/принимать
   BYTE cmnd;      // Последняя команда
};

#include "StdAfx.h"
#include "MyDsimModel.h"

//aav+ {

//_stdcall tIDSIMMODEL::tIDSIMMODEL(void) {
//
//}

//aav+ }

MyDsimModel::MyDsimModel(void) {       //aav+
  MessageBox(0,"constructor","VSM",0); //aav+
}                                      //aav+

//INT MyDsimModel::isdigital (CHAR *pinname) {  //aav+
//  MessageBox(0,"isdigital K","VSM",0);         //aav+
//   return 1;   // У модели все выводы цифровые //aav+
//}                                              //aav+


//INT          MyDsimModel::isdigital (CHAR *pinname) //aav-
  INT _stdcall MyDsimModel::isdigital (CHAR *pinname) //aav+
{

  MessageBox(0,"isdigital T","VSM",0); //aav+

   return 1;   // У модели все выводы цифровые
}

//VOID          MyDsimModel::setup (IINSTANCE *instance, IDSIMCKT *dsimckt) //aav-
  VOID _stdcall MyDsimModel::setup (IINSTANCE *instance, IDSIMCKT *dsimckt) //aav+
{
  MessageBox(0,"setup","VSM",0);

   inst = instance;
   ckt = dsimckt;
   PinI1W = inst->getdsimpin("I1W", true);   // Связываем переменную с пином I1W
   prev_time = 0;

   CREATEPOPUPSTRUCT *cps = new CREATEPOPUPSTRUCT;
   cps->caption = "1-wire Debugger Log";   // Заголовок окна
   cps->flags = PWF_VISIBLE;            // Видимое окно
   cps->type = PWT_DEBUG;               // Тип окна - DEBUG
   cps->height = 500;                  // Высота окна
   cps->width = 300;                  // Ширина окна
   cps->id = 123;                     // Идентификатор окна

   myPopup = (IDEBUGPOPUP *)instance->createpopup(cps);

  if (ils->authorize(OneWireDebugger_Key))