Nan::HandleScope scope;

v8::Local<v8::FunctionTemplate> tpl;

tpl = Nan::New<v8::FunctionTemplate>(S7Client::New);

v8::Local<v8::String> name = Nan::New<v8::String>("S7Client")

.ToLocalChecked();

tpl->SetClassName(name);

tpl->InstanceTemplate()->SetInternalFieldCount(1);

// Setup the prototype

// Control functions

Nan::SetPrototypeMethod(

tpl

, "Connect"

, S7Client::Connect);

Nan::SetPrototypeMethod(

tpl

, "ConnectTo"

, S7Client::ConnectTo);

Nan::SetPrototypeMethod(

tpl

, "SetConnectionParams"

, S7Client::SetConnectionParams);

Nan::SetPrototypeMethod(

tpl

, "SetConnectionType"

, S7Client::SetConnectionType);

Nan::SetPrototypeMethod(

tpl

, "Disconnect"

, S7Client::Disconnect);

Nan::SetPrototypeMethod(

tpl

, "GetParam"

, S7Client::GetParam);

Nan::SetPrototypeMethod(

tpl

, "SetParam"

, S7Client::SetParam);

// Data I/O Main functions

Nan::SetPrototypeMethod(

tpl

, "ReadArea"

, S7Client::ReadArea);

Nan::SetPrototypeMethod(

tpl

, "WriteArea"

, S7Client::WriteArea);

Nan::SetPrototypeMethod(

tpl

, "ReadMultiVars"

, S7Client::ReadMultiVars);

Nan::SetPrototypeMethod(

tpl

, "WriteMultiVars"

, S7Client::WriteMultiVars);

// Directory functions

Nan::SetPrototypeMethod(

tpl

, "ListBlocks"

, S7Client::ListBlocks);

Nan::SetPrototypeMethod(

tpl

, "GetAgBlockInfo"

, S7Client::GetAgBlockInfo);

Nan::SetPrototypeMethod(

tpl

, "GetPgBlockInfo"

, S7Client::GetPgBlockInfo);

Nan::SetPrototypeMethod(

tpl

, "ListBlocksOfType"

, S7Client::ListBlocksOfType);

// Blocks functions

Nan::SetPrototypeMethod(

tpl

, "Upload"

, S7Client::Upload);

Nan::SetPrototypeMethod(

tpl

, "FullUpload"

, S7Client::FullUpload);

Nan::SetPrototypeMethod(

tpl

, "Download"

, S7Client::Download);

Nan::SetPrototypeMethod(

tpl

, "Delete"

, S7Client::Delete);

Nan::SetPrototypeMethod(

tpl

, "DBGet"

, S7Client::DBGet);

Nan::SetPrototypeMethod(

tpl

, "DBFill"

, S7Client::DBFill);

// Date/Time functions

Nan::SetPrototypeMethod(

tpl

, "GetPlcDateTime"

, S7Client::GetPlcDateTime);

Nan::SetPrototypeMethod(

tpl

, "SetPlcDateTime"

, S7Client::SetPlcDateTime);

Nan::SetPrototypeMethod(

tpl

, "SetPlcSystemDateTime"

, S7Client::SetPlcSystemDateTime);

// System Info functions

Nan::SetPrototypeMethod(

tpl

, "GetOrderCode"

, S7Client::GetOrderCode);

Nan::SetPrototypeMethod(

tpl

, "GetCpuInfo"

, S7Client::GetCpuInfo);

Nan::SetPrototypeMethod(

tpl

, "GetCpInfo"

, S7Client::GetCpInfo);

Nan::SetPrototypeMethod(

tpl

, "ReadSZL"

, S7Client::ReadSZL);

Nan::SetPrototypeMethod(

tpl

, "ReadSZLList"

, S7Client::ReadSZLList);

// Control functions

Nan::SetPrototypeMethod(

tpl

, "PlcHotStart"

, S7Client::PlcHotStart);

Nan::SetPrototypeMethod(

tpl

, "PlcColdStart"

, S7Client::PlcColdStart);

Nan::SetPrototypeMethod(

tpl

, "PlcStop"

, S7Client::PlcStop);

Nan::SetPrototypeMethod(

tpl

, "CopyRamToRom"

, S7Client::CopyRamToRom);

Nan::SetPrototypeMethod(

tpl

, "Compress"

, S7Client::Compress);

// Security functions

Nan::SetPrototypeMethod(

tpl

, "GetProtection"

, S7Client::GetProtection);

Nan::SetPrototypeMethod(

tpl

, "SetSessionPassword"

, S7Client::SetSessionPassword);

Nan::SetPrototypeMethod(

tpl

, "ClearSessionPassword"

, S7Client::ClearSessionPassword);

// Properties

Nan::SetPrototypeMethod(

tpl

, "ExecTime"

, S7Client::ExecTime);

Nan::SetPrototypeMethod(

tpl

, "LastError"

, S7Client::LastError);

Nan::SetPrototypeMethod(

tpl

, "PDURequested"

, S7Client::PDURequested);

Nan::SetPrototypeMethod(

tpl

, "PDULength"

, S7Client::PDULength);

Nan::SetPrototypeMethod(

tpl

, "PlcStatus"

, S7Client::PlcStatus);

Nan::SetPrototypeMethod(

tpl

, "Connected"

, S7Client::Connected);

// Error to text function

Nan::SetPrototypeMethod(

tpl

, "ErrorText"

, S7Client::ErrorText);

// Error codes

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errNegotiatingPDU").ToLocalChecked()

, Nan::New<v8::Integer>(errNegotiatingPDU)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliInvalidParams").ToLocalChecked()

, Nan::New<v8::Integer>(errCliInvalidParams)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliJobPending").ToLocalChecked()

, Nan::New<v8::Integer>(errCliJobPending)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliTooManyItems").ToLocalChecked()

, Nan::New<v8::Integer>(errCliTooManyItems)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliInvalidWordLen").ToLocalChecked()

, Nan::New<v8::Integer>(errCliInvalidWordLen)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliPartialDataWritten").ToLocalChecked()

, Nan::New<v8::Integer>(errCliPartialDataWritten)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliSizeOverPDU").ToLocalChecked()

, Nan::New<v8::Integer>(errCliSizeOverPDU)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliInvalidPlcAnswer").ToLocalChecked()

, Nan::New<v8::Integer>(errCliInvalidPlcAnswer)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliAddressOutOfRange").ToLocalChecked()

, Nan::New<v8::Integer>(errCliAddressOutOfRange)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliInvalidTransportSize").ToLocalChecked()

, Nan::New<v8::Integer>(errCliInvalidTransportSize)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliWriteDataSizeMismatch").ToLocalChecked()

, Nan::New<v8::Integer>(errCliWriteDataSizeMismatch)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliItemNotAvailable").ToLocalChecked()

, Nan::New<v8::Integer>(errCliItemNotAvailable)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliInvalidValue").ToLocalChecked()

, Nan::New<v8::Integer>(errCliInvalidValue)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliCannotStartPLC").ToLocalChecked()

, Nan::New<v8::Integer>(errCliCannotStartPLC)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliAlreadyRun").ToLocalChecked()

, Nan::New<v8::Integer>(errCliAlreadyRun)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliCannotStopPLC").ToLocalChecked()

, Nan::New<v8::Integer>(errCliCannotStopPLC)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliCannotCopyRamToRom").ToLocalChecked()

, Nan::New<v8::Integer>(errCliCannotCopyRamToRom)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliCannotCompress").ToLocalChecked()

, Nan::New<v8::Integer>(errCliCannotCompress)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliAlreadyStop").ToLocalChecked()

, Nan::New<v8::Integer>(errCliAlreadyStop)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliFunNotAvailable").ToLocalChecked()

, Nan::New<v8::Integer>(errCliFunNotAvailable)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliUploadSequenceFailed").ToLocalChecked()

, Nan::New<v8::Integer>(errCliUploadSequenceFailed)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliInvalidDataSizeRecvd").ToLocalChecked()

, Nan::New<v8::Integer>(errCliInvalidDataSizeRecvd)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliInvalidBlockType").ToLocalChecked()

, Nan::New<v8::Integer>(errCliInvalidBlockType)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliInvalidBlockNumber").ToLocalChecked()

, Nan::New<v8::Integer>(errCliInvalidBlockNumber)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliInvalidBlockSize").ToLocalChecked()

, Nan::New<v8::Integer>(errCliInvalidBlockSize)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliDownloadSequenceFailed").ToLocalChecked()

, Nan::New<v8::Integer>(errCliDownloadSequenceFailed)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliInsertRefused").ToLocalChecked()

, Nan::New<v8::Integer>(errCliInsertRefused)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliDeleteRefused").ToLocalChecked()

, Nan::New<v8::Integer>(errCliDeleteRefused)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliNeedPassword").ToLocalChecked()

, Nan::New<v8::Integer>(errCliNeedPassword)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliInvalidPassword").ToLocalChecked()

, Nan::New<v8::Integer>(errCliInvalidPassword)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliNoPasswordToSetOrClear").ToLocalChecked()

, Nan::New<v8::Integer>(errCliNoPasswordToSetOrClear)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliJobTimeout").ToLocalChecked()

, Nan::New<v8::Integer>(errCliJobTimeout)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliPartialDataRead").ToLocalChecked()

, Nan::New<v8::Integer>(errCliPartialDataRead)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliBufferTooSmall").ToLocalChecked()

, Nan::New<v8::Integer>(errCliBufferTooSmall)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliFunctionRefused").ToLocalChecked()

, Nan::New<v8::Integer>(errCliFunctionRefused)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliDestroying").ToLocalChecked()

, Nan::New<v8::Integer>(errCliDestroying)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliInvalidParamNumber").ToLocalChecked()

, Nan::New<v8::Integer>(errCliInvalidParamNumber)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("errCliCannotChangeParam").ToLocalChecked()

, Nan::New<v8::Integer>(errCliCannotChangeParam)

, v8::ReadOnly);

// Client Connection Type

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("CONNTYPE_PG").ToLocalChecked()

, Nan::New<v8::Integer>(CONNTYPE_PG)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("CONNTYPE_OP").ToLocalChecked()

, Nan::New<v8::Integer>(CONNTYPE_OP)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("CONNTYPE_BASIC").ToLocalChecked()

, Nan::New<v8::Integer>(CONNTYPE_BASIC)

, v8::ReadOnly);

// CPU Status codes

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7CpuStatusUnknown").ToLocalChecked()

, Nan::New<v8::Integer>(S7CpuStatusUnknown)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7CpuStatusRun").ToLocalChecked()

, Nan::New<v8::Integer>(S7CpuStatusRun)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7CpuStatusStop").ToLocalChecked()

, Nan::New<v8::Integer>(S7CpuStatusStop)

, v8::ReadOnly);

// Area ID

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7AreaPE").ToLocalChecked()

, Nan::New<v8::Integer>(S7AreaPE)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7AreaPA").ToLocalChecked()

, Nan::New<v8::Integer>(S7AreaPA)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7AreaMK").ToLocalChecked()

, Nan::New<v8::Integer>(S7AreaMK)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7AreaDB").ToLocalChecked()

, Nan::New<v8::Integer>(S7AreaDB)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7AreaCT").ToLocalChecked()

, Nan::New<v8::Integer>(S7AreaCT)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7AreaTM").ToLocalChecked()

, Nan::New<v8::Integer>(S7AreaTM)

, v8::ReadOnly);

// Word Length

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7WLBit").ToLocalChecked()

, Nan::New<v8::Integer>(S7WLBit)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7WLByte").ToLocalChecked()

, Nan::New<v8::Integer>(S7WLByte)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7WLWord").ToLocalChecked()

, Nan::New<v8::Integer>(S7WLWord)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7WLDWord").ToLocalChecked()

, Nan::New<v8::Integer>(S7WLDWord)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7WLReal").ToLocalChecked()

, Nan::New<v8::Integer>(S7WLReal)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7WLCounter").ToLocalChecked()

, Nan::New<v8::Integer>(S7WLCounter)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("S7WLTimer").ToLocalChecked()

, Nan::New<v8::Integer>(S7WLTimer)

, v8::ReadOnly);

// Block type

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("Block_OB").ToLocalChecked()

, Nan::New<v8::Integer>(Block_OB)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("Block_DB").ToLocalChecked()

, Nan::New<v8::Integer>(Block_DB)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("Block_SDB").ToLocalChecked()

, Nan::New<v8::Integer>(Block_SDB)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("Block_FC").ToLocalChecked()

, Nan::New<v8::Integer>(Block_FC)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("Block_SFC").ToLocalChecked()

, Nan::New<v8::Integer>(Block_SFC)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("Block_FB").ToLocalChecked()

, Nan::New<v8::Integer>(Block_FB)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("Block_SFB").ToLocalChecked()

, Nan::New<v8::Integer>(Block_SFB)

, v8::ReadOnly);

// Sub Block Type

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("SubBlk_OB").ToLocalChecked()

, Nan::New<v8::Integer>(SubBlk_OB)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("SubBlk_SDB").ToLocalChecked()

, Nan::New<v8::Integer>(SubBlk_SDB)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("SubBlk_FC").ToLocalChecked()

, Nan::New<v8::Integer>(SubBlk_FC)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("SubBlk_SFC").ToLocalChecked()

, Nan::New<v8::Integer>(SubBlk_SFC)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("SubBlk_FB").ToLocalChecked()

, Nan::New<v8::Integer>(SubBlk_FB)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("SubBlk_SFB").ToLocalChecked()

, Nan::New<v8::Integer>(SubBlk_SFB)

, v8::ReadOnly);

// Block languages

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("BlockLangAWL").ToLocalChecked()

, Nan::New<v8::Integer>(BlockLangAWL)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("BlockLangKOP").ToLocalChecked()

, Nan::New<v8::Integer>(BlockLangKOP)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("BlockLangFUP").ToLocalChecked()

, Nan::New<v8::Integer>(BlockLangFUP)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("BlockLangSCL").ToLocalChecked()

, Nan::New<v8::Integer>(BlockLangSCL)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("BlockLangDB").ToLocalChecked()

, Nan::New<v8::Integer>(BlockLangDB)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("BlockLangGRAPH").ToLocalChecked()

, Nan::New<v8::Integer>(BlockLangGRAPH)

, v8::ReadOnly);

// Parameter

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("LocalPort").ToLocalChecked()

, Nan::New<v8::Integer>(p_u16_LocalPort)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("RemotePort").ToLocalChecked()

, Nan::New<v8::Integer>(p_u16_RemotePort)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("PingTimeout").ToLocalChecked()

, Nan::New<v8::Integer>(p_i32_PingTimeout)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("SendTimeout").ToLocalChecked()

, Nan::New<v8::Integer>(p_i32_SendTimeout)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("RecvTimeout").ToLocalChecked()

, Nan::New<v8::Integer>(p_i32_RecvTimeout)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("WorkInterval").ToLocalChecked()

, Nan::New<v8::Integer>(p_i32_WorkInterval)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("SrcRef").ToLocalChecked()

, Nan::New<v8::Integer>(p_u16_SrcRef)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("DstRef").ToLocalChecked()

, Nan::New<v8::Integer>(p_u16_DstRef)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("SrcTSap").ToLocalChecked()

, Nan::New<v8::Integer>(p_u16_SrcTSap)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("PDURequest").ToLocalChecked()

, Nan::New<v8::Integer>(p_i32_PDURequest)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("MaxClients").ToLocalChecked()

, Nan::New<v8::Integer>(p_i32_MaxClients)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("BSendTimeout").ToLocalChecked()

, Nan::New<v8::Integer>(p_i32_BSendTimeout)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("BRecvTimeout").ToLocalChecked()

, Nan::New<v8::Integer>(p_i32_BRecvTimeout)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("RecoveryTime").ToLocalChecked()

, Nan::New<v8::Integer>(p_u32_RecoveryTime)

, v8::ReadOnly);

Nan::SetPrototypeTemplate(

tpl

, Nan::New<v8::String>("KeepAliveTime").ToLocalChecked()

, Nan::New<v8::Integer>(p_u32_KeepAliveTime)

, v8::ReadOnly);

constructor.Reset(tpl);

Nan::Set(target, name, Nan::GetFunction(tpl).ToLocalChecked());

if (info.IsConstructCall()) {

S7Client *s7client = new S7Client();

s7client->Wrap(info.This());

info.GetReturnValue().Set(info.This());

} else {

v8::Local<v8::FunctionTemplate> constructorHandle;

constructorHandle = Nan::New<v8::FunctionTemplate>(constructor);

info.GetReturnValue().Set(

Nan::NewInstance(Nan::GetFunction(constructorHandle).ToLocalChecked()).ToLocalChecked());

}

switch (WordLen) {

case S7WLBit:

case S7WLByte:

return 1;

case S7WLWord:

case S7WLCounter:

case S7WLTimer:

return 2;

case S7WLReal:

case S7WLDWord:

return 4;

default:

return 0;

}

S7Client *s7client = ObjectWrap::Unwrap<S7Client>(info.Holder());

if (!info[0]->IsFunction()) {

int ret = s7client->snap7Client->Connect();

info.GetReturnValue().Set(Nan::New<v8::Boolean>(ret == 0));

} else {

Nan::Callback *callback = new Nan::Callback(info[0].As<v8::Function>());

Nan::AsyncQueueWorker(new IOWorker(callback, s7client, CONNECT));

info.GetReturnValue().SetUndefined();

}

S7Client *s7client = ObjectWrap::Unwrap<S7Client>(info.Holder());

if (info.Length() < 3) {

return Nan::ThrowTypeError("Wrong number of arguments");

}

if (!info[0]->IsString() || !info[1]->IsInt32() || !info[2]->IsInt32()) {

return Nan::ThrowTypeError("Wrong arguments");

}

Nan::Utf8String *remAddress = new Nan::Utf8String(info[0]);

if (!info[3]->IsFunction()) {

int ret = s7client->snap7Client->ConnectTo(

**remAddress

, Nan::To<int32_t>(info[1]).FromJust()

, Nan::To<int32_t>(info[2]).FromJust());

delete remAddress;

info.GetReturnValue().Set(Nan::New<v8::Boolean>(ret == 0));

} else {

Nan::Callback *callback = new Nan::Callback(info[3].As<v8::Function>());

Nan::AsyncQueueWorker(new IOWorker(callback, s7client, CONNECTTO

, remAddress, Nan::To<int32_t>(info[1]).FromJust(), Nan::To<int32_t>(info[2]).FromJust()));

info.GetReturnValue().SetUndefined();

}

S7Client *s7client = ObjectWrap::Unwrap<S7Client>(info.Holder());

if (!info[0]->IsString() || !info[1]->IsUint32() ||

!info[2]->IsUint32()) {

return Nan::ThrowTypeError("Wrong arguments");

}

Nan::Utf8String remAddress(info[0]);

word LocalTSAP = Nan::To<uint32_t>(info[1]).FromJust();

word RemoteTSAP = Nan::To<uint32_t>(info[2]).FromJust();

int ret = s7client->snap7Client->SetConnectionParams(

*remAddress

, LocalTSAP

, RemoteTSAP);

info.GetReturnValue().Set(Nan::New<v8::Boolean>(ret == 0));

S7Client *s7client = ObjectWrap::Unwrap<S7Client>(info.Holder());

if (!info[0]->IsUint32()) {

return Nan::ThrowTypeError("Wrong arguments");

}

word type = Nan::To<uint32_t>(info[0]).FromJust();

int ret = s7client->snap7Client->SetConnectionType(type);

info.GetReturnValue().Set(Nan::New<v8::Boolean>(ret == 0));

S7Client *s7client = ObjectWrap::Unwrap<S7Client>(info.Holder());

int ret = s7client->snap7Client->Disconnect();

info.GetReturnValue().Set(Nan::New<v8::Boolean>(ret == 0));

S7Client *s7client = ObjectWrap::Unwrap<S7Client>(info.Holder());

if (!info[0]->IsInt32()) {

return Nan::ThrowTypeError("Wrong arguments");

}

int pData;

int returnValue = s7client->snap7Client->GetParam(Nan::To<int32_t>(info[0]).FromJust()

, &pData);

if (returnValue == 0) {

info.GetReturnValue().Set(Nan::New<v8::Integer>(pData));

} else {

info.GetReturnValue().Set(Nan::New<v8::Integer>(returnValue));

}

S7Client *s7client = ObjectWrap::Unwrap<S7Client>(info.Holder());

if (!(info[0]->IsInt32() || info[1]->IsInt32())) {

return Nan::ThrowTypeError("Wrong arguments");

}

int pData = Nan::To<int32_t>(info[1]).FromJust();

int ret = s7client->snap7Client->SetParam(Nan::To<int32_t>(info[0]).FromJust(), &pData);

info.GetReturnValue().Set(Nan::New<v8::Boolean>(ret == 0));

uv_mutex_lock(&s7client->mutex);

switch (caller) {

case CONNECTTO:

returnValue = s7client->snap7Client->ConnectTo(

**static_cast<Nan::Utf8String*>(pData), int1, int2);

break;

case CONNECT:

returnValue = s7client->snap7Client->Connect();

break;

case READAREA:

returnValue = s7client->snap7Client->ReadArea(int1, int2, int3, int4

, int5, pData);

break;

case WRITEAREA:

returnValue = s7client->snap7Client->WriteArea(int1, int2, int3, int4

, int5, pData);

break;

case READMULTI:

returnValue = s7client->snap7Client->ReadMultiVars(

static_cast<PS7DataItem>(pData), int1);

break;

case WRITEMULTI:

returnValue = s7client->snap7Client->WriteMultiVars(

static_cast<PS7DataItem>(pData), int1);

break;

case PLCSTATUS:

returnValue = s7client->snap7Client->PlcStatus();

if ((returnValue == S7CpuStatusUnknown) ||

(returnValue == S7CpuStatusStop) ||

(returnValue == S7CpuStatusRun)) {

int1 = returnValue;

returnValue = 0;

}

break;

case CLEARSESSIONPW:

returnValue = s7client->snap7Client->ClearSessionPassword();

break;

case SETSESSIONPW:

returnValue = s7client->snap7Client->SetSessionPassword(

**static_cast<Nan::Utf8String*>(pData));

break;

case GETPROTECTION:

returnValue = s7client->snap7Client->GetProtection(

static_cast<PS7Protection>(pData));

break;

case PLCSTOP:

returnValue = s7client->snap7Client->PlcStop();

break;

case PLCCOLDSTART:

returnValue = s7client->snap7Client->PlcColdStart();

break;

case PLCHOTSTART:

returnValue = s7client->snap7Client->PlcHotStart();

break;

case GETCPINFO:

returnValue = s7client->snap7Client->GetCpInfo(

static_cast<PS7CpInfo>(pData));

break;

case GETCPUINFO:

returnValue = s7client->snap7Client->GetCpuInfo(

static_cast<PS7CpuInfo>(pData));

break;

case GETORDERCODE:

returnValue = s7client->snap7Client->GetOrderCode(

static_cast<PS7OrderCode>(pData));

break;

case SETPLCSYSTEMDATETIME:

returnValue = s7client->snap7Client->SetPlcSystemDateTime();

break;

case GETPLCDATETIME:

returnValue = s7client->snap7Client->GetPlcDateTime(

static_cast<tm*>(pData));

break;

case SETPLCDATETIME:

returnValue = s7client->snap7Client->SetPlcDateTime(

static_cast<tm*>(pData));

break;

case COMPRESS:

returnValue = s7client->snap7Client->Compress(int1);

break;

case COPYRAMTOROM:

returnValue = s7client->snap7Client->CopyRamToRom(int1);

break;

case DBFILL:

returnValue = s7client->snap7Client->DBFill(int1, int2);

break;

case DBGET:

returnValue = s7client->snap7Client->DBGet(int1, pData, &int2);

break;

case DELETEBLOCK:

returnValue = s7client->snap7Client->Delete(int1, int2);

break;

case DOWNLOAD:

returnValue = s7client->snap7Client->Download(int1, pData, int2);

break;

case FULLUPLOAD:

returnValue = s7client->snap7Client->FullUpload(int1, int2, pData, &int3);

break;

case UPLOAD:

returnValue = s7client->snap7Client->Upload(int1, int2, pData, &int3);

break;

case LISTBLOCKSOFTYPE:

returnValue = s7client->snap7Client->ListBlocksOfType(int1

, static_cast<PS7BlocksOfType>(pData), &int2);

break;

case GETAGBLOCKINFO:

returnValue = s7client->snap7Client->GetAgBlockInfo(int1, int2

, static_cast<PS7BlockInfo>(pData));

break;