could anybody convert this code to freebasic?
I have no c / c++ knowledge.
Thanx
AU3PLUGIN.H
Code: Select all
#ifndef __AU3PLUGIN_H
#define __AU3PLUGIN_H
/*
*
* AutoIt v3 Plugin SDK
*
* Copyright (C)1999-2005 Jonathan Bennett <jon at autoitscript dot com>
*
* au3plugin.h
*
* This code may be freely used to create plugins for use in AutoIt.
*
*/
/* Includes */
#include <windows.h>
/* Defines */
#ifdef __cplusplus
#define AU3_PLUGINAPI extern "C" __declspec(dllexport)
#else
#define AU3_PLUGINAPI __declspec(dllexport)
#endif
#define AU3_PLUGIN_OK 0
#define AU3_PLUGIN_ERR 1
#define AU3_PLUGIN_INT32 1 /* 32bit Integer */
#define AU3_PLUGIN_INT64 2 /* 64bit Integer */
#define AU3_PLUGIN_DOUBLE 3 /* Double float */
#define AU3_PLUGIN_STRING 4 /* String */
#define AU3_PLUGIN_HWND 5 /* Handle (Window) */
#define AU3_PLUGIN_ITOA_MAX 65 /* Maximum returned length of an i64toa operation */
/* Variant and plugin function structures */
typedef struct tagAU3_PLUGIN_VAR
{
int m_nType; /* Type */
union
{
int m_nValue; /* Value of int32 (for AU3_PLUGIN_INT32) */
__int64 m_n64Value; /* Value of int64 (for AU3_PLUGIN_INT64) */
double m_fValue; /* Value of double (for AU3_PLUGIN_DOUBLE) */
char *m_szValue; /* Value of double (for AU3_PLUGIN_STRING) */
HWND m_hWnd; /* Value of handle (for AU3_PLUGIN_HWND) */
};
} AU3_PLUGIN_VAR;
typedef struct tagAU3_PLUGIN_FUNC
{
char *m_szName;
int m_nMinParams;
int m_nMaxParams;
} AU3_PLUGIN_FUNC;
/* Simplified function declarations */
#define AU3_PLUGIN_DEFINE(funcname) AU3_PLUGINAPI int funcname(int n_AU3_NumParams, const AU3_PLUGIN_VAR *p_AU3_Params, AU3_PLUGIN_VAR **p_AU3_Result, int *n_AU3_ErrorCode, int *n_AU3_ExtCode)
/* Helper functions for working with variant like variables */
AU3_PLUGIN_VAR * AU3_AllocVar(void);
void AU3_FreeVar(AU3_PLUGIN_VAR *pVar);
void AU3_ResetVar(AU3_PLUGIN_VAR *pVar);
int AU3_GetType(AU3_PLUGIN_VAR *pVar);
void AU3_SetString(AU3_PLUGIN_VAR *pVar, const char *szString);
char * AU3_GetString(const AU3_PLUGIN_VAR *pVar);
void AU3_FreeString(char *szString);
void AU3_SetInt32(AU3_PLUGIN_VAR *pVar, int nValue);
int AU3_GetInt32(AU3_PLUGIN_VAR *pVar);
void AU3_SetInt64(AU3_PLUGIN_VAR *pVar, __int64 n64Value);
__int64 AU3_GetInt64(AU3_PLUGIN_VAR *pVar);
void AU3_SetDouble(AU3_PLUGIN_VAR *pVar, double fValue);
double AU3_GetDouble(AU3_PLUGIN_VAR *pVar);
void AU3_SethWnd(AU3_PLUGIN_VAR *pVar, HWND hWnd);
HWND AU3_GethWnd(AU3_PLUGIN_VAR *pVar);
int AU3_HexToDec(const char *szHex);
/* END */
#endif
AU3PLUGIN.C
Code: Select all
/*
*
* AutoIt v3 Plugin SDK
*
* Copyright (C)1999-2005 Jonathan Bennett <jon at autoitscript dot com>
*
* au3plugin.c
*
* This code may be freely used to create plugins for use in AutoIt.
*
*/
#include <stdio.h>
#include <windows.h>
#include "au3plugin.h"
// Disable 64bit warnings on Visual C .NET
#ifdef _MSC_VER
#pragma warning(disable : 4311 4312)
#endif
/****************************************************************************
* AU3_AllocVar()
****************************************************************************/
AU3_PLUGIN_VAR* AU3_AllocVar(void)
{
AU3_PLUGIN_VAR *pVar = malloc(sizeof(AU3_PLUGIN_VAR));
pVar->m_nType = AU3_PLUGIN_INT32;
pVar->m_nValue = 0;
return pVar;
}
/****************************************************************************
* AU3_ResetVar()
****************************************************************************/
void AU3_ResetVar(AU3_PLUGIN_VAR *pVar)
{
if (pVar == NULL)
return;
if (pVar->m_nType == AU3_PLUGIN_STRING)
free(pVar->m_szValue);
pVar->m_nType = AU3_PLUGIN_INT32;
pVar->m_nValue = 0;
}
/****************************************************************************
* AU3_FreeVar()
****************************************************************************/
void AU3_FreeVar(AU3_PLUGIN_VAR *pVar)
{
if (pVar == NULL)
return;
AU3_ResetVar(pVar);
free(pVar);
}
/****************************************************************************
* AU3_GetType()
****************************************************************************/
int AU3_GetType(AU3_PLUGIN_VAR *pVar)
{
return pVar->m_nType;
}
/****************************************************************************
* AU3_SetString()
****************************************************************************/
void AU3_SetString(AU3_PLUGIN_VAR *pVar, const char *szString)
{
AU3_ResetVar(pVar);
pVar->m_nType = AU3_PLUGIN_STRING;
pVar->m_szValue = malloc( strlen(szString)+1 );
strcpy(pVar->m_szValue, szString);
}
/****************************************************************************
* AU3_GetString()
****************************************************************************/
char * AU3_GetString(const AU3_PLUGIN_VAR *pVar)
{
char szTemp[32]; // It is unclear just how many 0000 the sprintf function can add...
char *szString;
if (pVar->m_nType == AU3_PLUGIN_STRING)
{
szString = malloc( strlen(pVar->m_szValue)+1 );
strcpy(szString, pVar->m_szValue);
return szString;
}
switch(pVar->m_nType)
{
case AU3_PLUGIN_INT32:
// Work out the string representation of the number
itoa(pVar->m_nValue, szTemp, 10);
break;
case AU3_PLUGIN_INT64:
// Work out the string representation of the number
_i64toa(pVar->m_n64Value, szTemp, 10);
break;
case AU3_PLUGIN_DOUBLE:
// Work out the string representation of the number, don't print trailing zeros
sprintf(szTemp, "%.15g", pVar->m_fValue); // Have at least 15 digits after the . for precision (default is 6)
break;
case AU3_PLUGIN_HWND:
sprintf(szTemp, "0x%p", pVar->m_hWnd);
break;
}
szString = malloc( strlen(szTemp)+1 );
strcpy(szString, szTemp);
return szString;
}
/****************************************************************************
* AU3_FreeString()
****************************************************************************/
void AU3_FreeString(char *szString)
{
free(szString);
}
/****************************************************************************
* AU3_SetInt32()
****************************************************************************/
void AU3_SetInt32(AU3_PLUGIN_VAR *pVar, int nValue)
{
AU3_ResetVar(pVar);
pVar->m_nType = AU3_PLUGIN_INT32;
pVar->m_nValue = nValue;
}
/****************************************************************************
* AU3_GetInt32()
****************************************************************************/
int AU3_GetInt32(AU3_PLUGIN_VAR *pVar)
{
switch (pVar->m_nType)
{
case AU3_PLUGIN_INT32:
return pVar->m_nValue;
case AU3_PLUGIN_DOUBLE:
return (int)pVar->m_fValue;
case AU3_PLUGIN_STRING:
if ( (pVar->m_szValue[0] == '0') && (pVar->m_szValue[1] == 'x' || pVar->m_szValue[1] == 'X') )
{
return AU3_HexToDec(&pVar->m_szValue[2]); // Assume hex conversion
}
else
return atoi(pVar->m_szValue);
case AU3_PLUGIN_INT64:
return (int)pVar->m_n64Value;
case AU3_PLUGIN_HWND:
return (int)pVar->m_hWnd;
default:
return 0;
}
}
/****************************************************************************
* AU3_SetInt64()
****************************************************************************/
void AU3_SetInt64(AU3_PLUGIN_VAR *pVar, __int64 n64Value)
{
AU3_ResetVar(pVar);
pVar->m_nType = AU3_PLUGIN_INT64;
pVar->m_n64Value = n64Value;
}
/****************************************************************************
* AU3_GetInt64()
****************************************************************************/
__int64 AU3_GetInt64(AU3_PLUGIN_VAR *pVar)
{
switch (pVar->m_nType)
{
case AU3_PLUGIN_INT32:
return (__int64)pVar->m_nValue;
case AU3_PLUGIN_DOUBLE:
return (__int64)pVar->m_fValue;
case AU3_PLUGIN_STRING:
if ( (pVar->m_szValue[0] == '0') && (pVar->m_szValue[1] == 'x' || pVar->m_szValue[1] == 'X') )
{
return (__int64)AU3_HexToDec(&pVar->m_szValue[2]); // Assume hex conversion
}
else
return _atoi64(pVar->m_szValue);
case AU3_PLUGIN_INT64:
return pVar->m_n64Value;
default:
return 0;
}
}
/****************************************************************************
* AU3_SetDouble()
****************************************************************************/
void AU3_SetDouble(AU3_PLUGIN_VAR *pVar, double fValue)
{
AU3_ResetVar(pVar);
pVar->m_nType = AU3_PLUGIN_DOUBLE;
pVar->m_fValue = fValue;
}
/****************************************************************************
* AU3_GetDouble()
****************************************************************************/
double AU3_GetDouble(AU3_PLUGIN_VAR *pVar)
{
switch (pVar->m_nType)
{
case AU3_PLUGIN_INT32:
return (double)pVar->m_nValue;
case AU3_PLUGIN_DOUBLE:
return pVar->m_fValue;
case AU3_PLUGIN_STRING:
if ( (pVar->m_szValue[0] == '0') && (pVar->m_szValue[1] == 'x' || pVar->m_szValue[1] == 'X') )
{
return (double)AU3_HexToDec(&pVar->m_szValue[2]); // Assume hex conversion
}
else
return atof(pVar->m_szValue);
case AU3_PLUGIN_INT64:
return (double)pVar->m_n64Value;
default:
return 0;
}
}
/****************************************************************************
* AU3_SethWnd()
****************************************************************************/
void AU3_SethWnd(AU3_PLUGIN_VAR *pVar, HWND hWnd)
{
AU3_ResetVar(pVar);
pVar->m_nType = AU3_PLUGIN_HWND;
pVar->m_hWnd = hWnd;
}
/****************************************************************************
* AU3_GethWnd()
****************************************************************************/
HWND AU3_GethWnd(AU3_PLUGIN_VAR *pVar)
{
switch (pVar->m_nType)
{
case AU3_PLUGIN_HWND:
return pVar->m_hWnd;
case AU3_PLUGIN_INT32:
return (HWND)pVar->m_nValue;
case AU3_PLUGIN_STRING:
if ( (pVar->m_szValue[0] == '0') && (pVar->m_szValue[1] == 'x' || pVar->m_szValue[1] == 'X') )
{
return (HWND)AU3_HexToDec(&pVar->m_szValue[2]); // Assume hex conversion
}
else
return (HWND)atoi(pVar->m_szValue);
default:
return 0;
}
}
/****************************************************************************
* AU3_HexToDec()
****************************************************************************/
int AU3_HexToDec(const char *szHex)
{
// Really crappy hex conversion
int nDec;
int i, j;
int nMult;
i = (int)strlen(szHex) - 1;
nDec = 0;
nMult = 1;
for (j = 0; j < 8; ++j)
{
if (i < 0)
break;
if (szHex[i] >= '0' && szHex[i] <= '9')
nDec += (szHex[i] - '0') * nMult;
else if (szHex[i] >= 'A' && szHex[i] <= 'F')
nDec += (((szHex[i] - 'A'))+10) * nMult;
else if (szHex[i] >= 'a' && szHex[i] <= 'f')
nDec += (((szHex[i] - 'a'))+10) * nMult;
else
{
return 0;
}
--i;
nMult = nMult * 16;
}
if (i != -1)
nDec = 0;
return nDec;
}
Code: Select all
/*
*
* AutoIt v3 Plugin SDK - Example
*
* Copyright (C)1999-2005 Jonathan Bennett <jon at autoitscript dot com>
*
* example.c
*
*/
#include <stdio.h>
#include <windows.h>
#include "au3plugin.h"
/****************************************************************************
* Function List
*
* This is where you define the functions available to AutoIt. Including
* the function name (Must be the same case as your exported DLL name), the
* minimum and maximum number of parameters that the function takes.
*
****************************************************************************/
/* "FunctionName", min_params, max_params */
AU3_PLUGIN_FUNC g_AU3_Funcs[] =
{
{"PluginFunc1", 2, 2}
};
/*
Multiple Function Example
AU3_PLUGIN_FUNC g_AU3_Funcs[NUMFUNCS] =
{
{"PluginFunc1", 2, 2},
{"PluginFunc2", 1, 1},
{"PluginFunc3", 1, 5}
};
*/
/****************************************************************************
* AU3_GetPluginDetails()
*
* This function is called by AutoIt when the plugin dll is first loaded to
* query the plugin about what functions it supports. DO NOT MODIFY.
*
****************************************************************************/
AU3_PLUGINAPI int AU3_GetPluginDetails(int *n_AU3_NumFuncs, AU3_PLUGIN_FUNC **p_AU3_Func)
{
/* Pass back the number of functions that this DLL supports */
*n_AU3_NumFuncs = sizeof(g_AU3_Funcs)/sizeof(AU3_PLUGIN_FUNC);;
/* Pack back the address of the global function table */
*p_AU3_Func = g_AU3_Funcs;
return AU3_PLUGIN_OK;
}
/****************************************************************************
* DllMain()
*
* This function is called when the DLL is loaded and unloaded. Do not
* modify it unless you understand what it does...
*
****************************************************************************/
BOOL WINAPI DllMain(HANDLE hInst, ULONG ul_reason_for_call, LPVOID lpReserved)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
/****************************************************************************
* PluginFunc1()
*
* This is an example function that is a simple message box that takes 2
* parameters:
*
* PluginFunc1("title", "text")
*
****************************************************************************/
AU3_PLUGIN_DEFINE(PluginFunc1)
{
/* The inputs to a plugin function are:
* n_AU3_NumParams - The number of parameters being passed
* p_AU3_Params - An array of variant like variables used by AutoIt
*
* The outputs of a plugin function are:
* p_AU3_Result - A pointer to a variant variable for the result
* n_AU3_ErrorCode - The value for @Error
* n_AU3_ExtCode - The value for @Extended
*/
AU3_PLUGIN_VAR *pMyResult;
char *szTitle, *szText;
/* Get string representations of the two parameters passed - this works even if we
* were passed numbers or floats.
* Note: AU3_GetString() allocates some memory that we must manually free later.
*/
szTitle = AU3_GetString(&p_AU3_Params[0]);
szText = AU3_GetString(&p_AU3_Params[1]);
/* Do the message box */
MessageBox(NULL, szText, szTitle, MB_OK);
/* Free temporary storage */
AU3_FreeString(szTitle);
AU3_FreeString(szText);
/* Allocate and build the return variable */
pMyResult = AU3_AllocVar();
/* Set the return variable */
AU3_SetString(pMyResult, "Hello World");
/*AU3_SetInt32(pMyResult, 42);*/
/* Pass back the result, error code and extended code.
* Note: AutoIt is responsible for freeing the memory used in p_AU3_Result
*/
*p_AU3_Result = pMyResult;
*n_AU3_ErrorCode = 0;
*n_AU3_ExtCode = 0;
return AU3_PLUGIN_OK;
}