// Open Listener / Server
void transport_open_listener( lua_State *L, ServerHandle *handle )
{
// Get args & Set up connection
unsigned uart_id, tmr_id;
check_num_args( L,3 ); // 1st arg is uart num, 2nd arg is tmr_id, 3nd is handle
if ( !lua_isnumber( L, 1 ) )
luaL_error( L, "1st arg must be uart num" );
if ( !lua_isnumber( L, 2 ) )
luaL_error( L, "2nd arg must be timer num" );
// @@@ Error handling could likely be better here
uart_id = lua_tonumber( L, 1 );
if( !platform_uart_exists( uart_id ) )
luaL_error( L, "invalid uart id" );
tmr_id = lua_tonumber( L, 2 );
if( !platform_timer_exists( tmr_id ) )
luaL_error( L, "invalid timer id" );
handle->ltpt.fd = ( int )uart_id;
handle->ltpt.tmr_id = tmr_id;
// Setup uart
platform_uart_setup( (unsigned int) uart_id, 115200, 8, PLATFORM_UART_PARITY_NONE, PLATFORM_UART_STOPBITS_1 );
}
static short gfo_seek(ATOMID idfName, LPEXP lpExp, char *stName, WORD wArgs)
{
ATOMID idPos, idWhence;
long pos;
if (!check_num_args(idfName, wArgs, 2, 2))
return NULL;
if (!KppGetReadFile())
return KPC_ERROR(IDE_FNOTOPEN, NULLID);
idPos = CAR(lpExp += CDR(lpExp));
idWhence = CAR(lpExp += CDR(lpExp));
if (!KppGetAtomLong(idPos, &pos))
return KPC_ERROR(IDE_BADARG, NULLID);
if (idWhence == lpIDs->idBegin)
fseek(inFile, pos, SEEK_SET);
else if (idWhence == lpIDs->idCurrent)
fseek(inFile, pos, SEEK_CUR);
else if (idWhence == lpIDs->idEnd)
fseek(inFile, pos, SEEK_END);
else
return KPC_ERROR(IDE_BADARG, NULLID);
KappaReturnTrue;
}
// Open Connection / Client
int transport_open_connection(lua_State *L, Handle *handle)
{
// Get args & Set up connection
unsigned uart_id, tmr_id;
check_num_args( L,3 ); // 1st arg is uart num, 2nd arg is tmr_id, 3nd is handle
if ( !lua_isnumber( L, 1 ) )
return luaL_error( L, "1st arg must be uart num" );
if ( !lua_isnumber( L, 2 ) )
return luaL_error( L, "2nd arg must be timer num" );
uart_id = lua_tonumber( L, 1 );
MOD_CHECK_ID( uart, uart_id );
tmr_id = lua_tonumber( L, 1 );
MOD_CHECK_ID( timer, tmr_id );
adispatch_buff = -1;
handle->tpt.fd = ( int )uart_id;
handle->tpt.tmr_id = tmr_id;
// Setup uart
platform_uart_setup( (unsigned int) uart_id, 115200, 8, PLATFORM_UART_PARITY_NONE, PLATFORM_UART_STOPBITS_1 );
return 1;
}
static short gfo_pathname(ATOMID idfName, LPEXP lpExp, WORD wArgs)
{
ATOMID idPath, idComponent;
char drive[4], dir[FILENAME_MAX], name[10], ext[8];
if (!check_num_args(idfName, wArgs, 2, 2))
return NULL;
lpExp += CDR(lpExp);
idPath = CAR(lpExp);
lpExp += CDR(lpExp);
idComponent = CAR(lpExp);
KppGetAtomName(idPath, return_buffer, RET_BUFFER_LEN);
strlwr(return_buffer);
_splitpath(return_buffer, drive, dir, name, ext);
if (idComponent == lpIDs->idName)
KappaReturnAtom(name[0] ? KppAddAtom(name) : lpIDs->idNull);
if (idComponent == lpIDs->idDirectory)
KappaReturnAtom(dir[0] ? KppAddAtom(dir) : lpIDs->idNull);
if (idComponent == lpIDs->idExtension)
KappaReturnAtom(ext[0] ? KppAddAtom(ext) : lpIDs->idNull);
if (idComponent == lpIDs->idDrive)
KappaReturnAtom(drive[0] ? KppAddAtom(drive) : lpIDs->idNull);
return KPC_ERROR(IDE_INVALIDCOMP, idComponent);
}
/* CloseReadFile, CloseWriteFile */
static short gfo_close(ATOMID idfName, char *stName, WORD wArgs)
{
if (!check_num_args(idfName, wArgs, 0, 0))
return NULL;
if (stName[5] == 'R')
{
if (!KppGetReadFile ())
return KPC_ERROR(IDE_FNOTOPEN, NULLID);
if (KppCloseReadFile () == EOF)
KPC_ERROR(IDE_FILECLOSE, NULLID);
KappaReturnTrue;
}
if (stName[5] == 'W')
{
if (!KppGetWriteFile ())
return KPC_ERROR(IDE_FNOTOPEN, NULLID);
if (KppCloseWriteFile () == EOF)
KPC_ERROR(IDE_FILECLOSE, NULLID);
KappaReturnTrue;
}
KappaReturnError;
}
static short gfo_getprofilestring(ATOMID idfName, LPEXP lpExp, WORD wArgs)
{
char file[FILENAME_MAX], section[32], entry[32], def[32];
if (!check_num_args(idfName, wArgs, 3, 4))
return NULL;
lpExp += CDR(lpExp);
KppGetAtomName(CAR(lpExp), file, FILENAME_MAX);
lpExp += CDR(lpExp);
KppGetAtomName(CAR(lpExp), section, 32);
lpExp += CDR(lpExp);
KppGetAtomName(CAR(lpExp), entry, 32);
if (wArgs == 4)
{
lpExp += CDR(lpExp);
KppGetAtomName(CAR(lpExp), def, 32);
}
else
strcpy(def, "NULL");
GetPrivateProfileString(section, entry, def,
return_buffer, RET_BUFFER_LEN, file);
KappaReturnAtom(KppAddAtom(return_buffer));
}
static short gfo_writeprofilestring(ATOMID idfName, LPEXP lpExp, WORD wArgs)
{
char file[FILENAME_MAX], section[32], entry[32];
if (!check_num_args(idfName, wArgs, 4, 4))
return NULL;
lpExp += CDR(lpExp);
KppGetAtomName(CAR(lpExp), file, FILENAME_MAX);
lpExp += CDR(lpExp);
KppGetAtomName(CAR(lpExp), section, 32);
lpExp += CDR(lpExp);
KppGetAtomName(CAR(lpExp), entry, 32);
lpExp += CDR(lpExp);
KppGetAtomName(CAR(lpExp), return_buffer, RET_BUFFER_LEN);
if (WritePrivateProfileString(section, entry, return_buffer, file))
KappaReturnTrue;
else
KappaReturnFalse;
}
/* OpenWriteFile */
static short gfo_open_write(ATOMID idfName, ATOMID idFile, char *stFile,
LPEXP lpExp, WORD wArgs)
{
FARFILE outFile = NULL;
if (!check_num_args(idfName, wArgs, 0, 2))
return NULL;
if (KppGetWriteFile())
return KPC_ERROR(IDE_FALREADYOPEN, NULLID);
if (wArgs == 2)
{
char stParam[3];
KappaGetArgString(lpExp, 2, stParam, 2);
if (stParam[0] != 'a' && stParam[0] != 'A')
return KPC_ERROR(IDE_BADARG, NULLID);
outFile = KppOpenWriteFile(stFile, TRUE);
}
else
outFile = KppOpenWriteFile(stFile, FALSE);
if (!outFile)
return ERROR;
KappaReturnTrue;
}
// Open Connection / Client
int transport_open_connection(lua_State *L, Handle *handle)
{
check_num_args (L,2); // 1st arg is path, 2nd is handle
if (!lua_isstring (L,1))
luaL_error(L,"first argument must be serial serial port");
transport_open( &handle->tpt, lua_tostring (L,1) );
return 1;
}
// Open Listener / Server
void transport_open_listener(lua_State *L, ServerHandle *handle)
{
check_num_args (L,2); // 1st arg is path, 2nd is handle
if (!lua_isstring (L,1))
luaL_error(L,"first argument must be serial serial port");
transport_open( &handle->ltpt, lua_tostring (L,1) );
while( transport_readable( &handle->ltpt ) == 0 ); // wait for incoming data
}
virtual pair<expr, constraint_seq> check_type(expr const & m, extension_context & ctx, bool infer_only) const {
environment const & env = ctx.env();
check_num_args(env, m);
if (!infer_only)
infer_type(macro_arg(m, 0), ctx, infer_only);
expr l = whnf(macro_arg(m, 0), ctx);
expr not_l = whnf(mk_app(*g_not, l), ctx);
expr C1 = infer_type(macro_arg(m, 1), ctx, infer_only);
expr C2 = infer_type(macro_arg(m, 2), ctx, infer_only);
return mk_pair(mk_resolvent(env, ctx, m, l, not_l, C1, C2), constraint_seq());
}
virtual optional<expr> expand(expr const & m, extension_context & ctx) const {
environment const & env = ctx.env();
check_num_args(env, m);
expr l = whnf(macro_arg(m, 0), ctx);
expr not_l = whnf(mk_app(*g_not, l), ctx);
expr H1 = macro_arg(m, 1);
expr H2 = macro_arg(m, 2);
expr C1 = infer_type(H1, ctx, true);
expr C2 = infer_type(H2, ctx, true);
expr R = mk_resolvent(env, ctx, m, l, not_l, C1, C2);
return some_expr(mk_or_elim_tree1(l, not_l, C1, H1, C2, H2, R, ctx));
}
/* InterpretFile */
static short gfo_interpret(ATOMID idfName, LPEXP lpExp, WORD wArgs)
{
ATOMID idFile, idMode, idMonitor;
ATOMID idAsk = lpIDs->idNo;
char stFile[FILESIZE];
BOOL bMode, bMonitor = FALSE;
if (!check_num_args(idfName, wArgs, 1, 4))
return NULL;
KappaGetArgAtom(lpExp, 1, idFile);
KppGetAtomName(idFile, (LPSTR) stFile, FILESIZE);
/* See if more arg */
if (wArgs < 2)
bMode = FALSE;
else
{
KappaGetArgAtom(lpExp, 2, idMode);
if (idMode == lpIDs->idEcho)
bMode = TRUE;
else if (idMode == lpIDs->idFalse)
bMode = FALSE;
else
return KPC_ERROR(IDE_BADARG, NULLID);
if (wArgs >= 3)
{
KappaGetArgAtom(lpExp, 3, idAsk);
if (idAsk != lpIDs->idYes && idAsk != lpIDs->idNo &&
idAsk != lpIDs->idAsk)
return KPC_ERROR(IDE_BADARG, NULLID);
if (wArgs == 4)
{
KappaGetArgAtom(lpExp, 4, idMonitor);
if (idMonitor == lpIDs->idTrue)
bMonitor = TRUE;
else if (idMonitor == lpIDs->idFalse)
bMonitor = FALSE;
else
return KPC_ERROR(IDE_BADARG, NULLID);
}
}
}
KppSetFileMonitor(bMonitor);
if (!KppInterpretKalFile(stFile, bMode, idAsk))
return ERROR;
KappaReturnAtom(idFile);
}
short PEXPORT KppReadLineLH(LPEXP lpExp)
{
ATOMID idfName, idNumChars = NULLID, idResult;
WORD wArgs = KppArgCount(lpExp);
int iUserLength;
WORD wLen;
KappaGetArgAtom(lpExp, 0, idfName);
if (!check_num_args(idfName, wArgs, 0, 1))
return NULL;
if (!KppGetReadFile())
return KPC_ERROR(IDE_FNOTOPEN, NULLID);
if (wArgs == 1)
{
KappaGetArgAtom(lpExp, 1, idNumChars);
if (!KppGetAtomInt(idNumChars, &iUserLength) || iUserLength <= 0)
return KPC_ERROR(IDE_BADARG, NULLID);
}
if (!fgets(return_buffer, RET_BUFFER_LEN, inFile))
KappaReturnAtom(lpIDs->idNull);
wLen = strlen(return_buffer);
if (return_buffer[wLen - 1] == '\n')
return_buffer[wLen - 1] = '\0';
else
{
char c;
while ((c = fgetc(inFile)) != EOF)
if (c == '\n')
break;
}
if (idNumChars && iUserLength < RET_BUFFER_LEN)
return_buffer[iUserLength] = '\0';
if (return_buffer[0])
idResult = KppAddAtom(return_buffer);
else
idResult = lpIDs->idNull;
KappaReturnAtom(idResult);
}
// indexing a helper returns a helper
int helper_index( lua_State *L )
{
const char *s;
check_num_args( L, 2 );
MYASSERT( lua_isuserdata( L, 1 ) && ismetatable_type( L, 1, "rpc.helper" ) );
if( lua_type( L, 2 ) != LUA_TSTRING )
return luaL_error( L, "can't index handle with non-string" );
s = lua_tostring( L, 2 );
if ( strlen( s ) > NUM_FUNCNAME_CHARS - 1 )
return luaL_error( L, error_string( ERR_LONGFNAME ) );
helper_append( L, ( Helper * )lua_touserdata( L, 1 ), s );
return 1;
}
// indexing a handle returns a helper
int client_index (lua_State *L)
{
const char *s;
check_num_args( L, 2 );
MYASSERT( lua_isuserdata( L, 1 ) && ismetatable_type( L, 1, "rpc.client" ) );
if( lua_type( L, 2 ) != LUA_TSTRING )
return luaL_error( L, "can't index a handle with a non-string" );
s = lua_tostring( L, 2 );
if ( strlen( s ) > NUM_FUNCNAME_CHARS - 1 )
return luaL_error( L, error_string( ERR_LONGFNAME ) );
helper_create( L, ( Transport * )lua_touserdata( L, 1 ), s );
// return the helper object
return 1;
}
short PEXPORT KppEofLH (LPEXP lpExp)
{
ATOMID idfName;
WORD wArgs;
FARFILE inFile;
KappaGetArgAtom(lpExp, 0, idfName);
wArgs = KppArgCount(lpExp);
if (!check_num_args(idfName, wArgs, 0, 0))
return NULL;
if (! (inFile = KppGetReadFile ()))
return KPC_ERROR(IDE_FNOTOPEN, NULLID);
if (KppEndOfFile (inFile))
KappaReturnTrue;
KappaReturnFalse;
}
/*
* Find the appropriate translation
*/
static URLTranslation *find_translation(URLTranslationList *trans,
List *words, Octstr *smsc, Octstr *sender, Octstr *receiver, int *reject)
{
Octstr *keyword;
int i, n;
URLTranslation *t;
List *list;
n = list_len(words);
if (n == 0)
return NULL;
n = 1;
keyword = list_get(words, 0);
keyword = octstr_duplicate(keyword);
octstr_convert_range(keyword, 0, octstr_len(keyword), tolower);
list = get_matching_translations(trans, keyword);
/*
list now contains all translations where the keyword of the sms matches the
pattern defined by the tranlsation's keyword
*/
t = NULL;
for (i = 0; i < list_len(list); ++i) {
t = list_get(list, i);
if (check_allowed_translation(t, smsc, sender, receiver, reject) == 0
&& check_num_args(t, words) == 0)
break;
t = NULL;
}
/* Only return reject if there's only blacklisted smsc's */
if(t != NULL)
*reject = 0;
octstr_destroy(keyword);
list_destroy(list, NULL);
return t;
}
static short gfo_fileexists(ATOMID idfName, LPEXP lpExp, WORD wArgs)
{
ATOMID idPath;
if (!check_num_args(idfName, wArgs, 1, 1))
return NULL;
lpExp += CDR(lpExp);
idPath = CAR(lpExp);
if (KppGetAtomName(idPath, return_buffer, FILENAME_MAX))
{
struct stat st;
if (stat(return_buffer, &st))
KappaReturnFalse;
KappaReturnTrue;
}
KappaReturnError;
}
// rpc_on_error( [ handle, ] error_handler )
static int rpc_on_error( lua_State *L )
{
check_num_args( L, 1 );
if( global_error_handler != LUA_NOREF )
lua_unref (L,global_error_handler);
global_error_handler = LUA_NOREF;
if ( LUA_ISCALLABLE( L, 1 ) )
global_error_handler = lua_ref( L, 1 );
else if ( lua_isnil( L, 1 ) )
{ ;; }
else
return luaL_error( L, "bad args" );
// @@@ add option for handle
// Handle *h = (Handle*) lua_touserdata (L,1);
// if (lua_isuserdata (L,1) && ismetatable_type(L, 1, "rpc.client"));
return 0;
}
/*
* Find the appropriate translation
*/
static URLTranslation *find_translation(URLTranslationList *trans, Msg *msg)
{
Octstr *data;
int i;
URLTranslation *t = NULL;
List *list, *words;
/* convert tolower and try to match */
data = octstr_duplicate(msg->sms.msgdata);
i = 0;
while((i = octstr_search_char(data, 0, i)) != -1 && i < octstr_len(data) - 1) {
octstr_delete(data, i, 1);
}
list = get_matching_translations(trans, data);
words = octstr_split_words(data);
/**
* List now contains all translations where the keyword of the sms
* matches the pattern defined by the tranlsation's keyword.
*/
for (i = 0; i < gwlist_len(list); ++i) {
t = gwlist_get(list, i);
/* TODO check_num_args, do we really need this??? */
if (check_allowed_translation(t, msg->sms.smsc_id, msg->sms.sender, msg->sms.receiver, msg->sms.account) == 0
&& check_num_args(t, words) == 0)
break;
t = NULL;
}
octstr_destroy(data);
gwlist_destroy(words, octstr_destroy_item);
gwlist_destroy(list, NULL);
return t;
}
short PEXPORT KppSaveApplicationLH(LPEXP lpExp)
{
WORD wArgs;
ATOMID idfName, idFile;
ATOMID idNoPrompt = lpIDs->idFalse;
KappaGetArgAtom(lpExp, 0, idfName);
KppGetAtomName(idfName, stName, SIZE);
wArgs = KppArgCount(lpExp);
if (!check_num_args(idfName, wArgs, 0, 2))
return NULL;
if (wArgs >= 1)
{
lpExp += CDR(lpExp);
idFile = CAR(lpExp);
KppGetAtomName(idFile, appName, FILESIZE);
if (wArgs == 2)
idNoPrompt = CAR(lpExp + CDR(lpExp));
}
else
strcpy(appName, KppGetAppFullName());
if (!appName[0])
return KPC_ERROR(IDE_NOAPPYET, NULLID);
if (idNoPrompt != lpIDs->idTrue && access(appName, 0) == 0 &&
PostAlertYesNo(NULL, IDE_SAVEFILEEXISTS,
ENDSTRING, ENDSTRING, ENDSTRING) == IDNO)
KappaReturnFalse;
if (kpc_save_application(appName, TRUE))
KappaReturnTrue;
KappaReturnFalse;
}
short PEXPORT KppSaveLH(LPEXP lpExp)
{
ATOMID idfName, idName = NULLID;
FARFILE outFile;
char stName[SIZE + 1];
WORD wArgs;
idfName = CAR(lpExp);
KppGetAtomName(idfName,(LPSTR) stName, SIZE);
if (!KppIsDevelopmentMode() && (!bKalWriteState))
return KPC_ERROR(IDE_NOTSUPPORTEDINRUNTIME, NULLID);
wArgs = KppArgCount(lpExp);
if (!(outFile = KppGetWriteFile()))
return KPC_ERROR(IDE_FNOTOPEN, NULLID);
if (stName[5] != 'A')
{
WORD wMArgs = 1 + (stName[5] == 'S' || stName[5] == 'M');
if (!check_num_args(idfName, wArgs, wMArgs, wMArgs))
return NULL;
idName = KppGetNthArg(lpExp, 1, EXPATOM);
}
else if (!check_num_args(idfName, wArgs, 0, 0))
return NULL;
switch(stName[5]) {
case 'H': /* WriteHierarchy */
return check_disk_error(idfName,
gso_write_hierarchy(idfName, idName));
case 'C': /* WriteClass */
return check_disk_error(idfName,
gso_write_class(idfName, idName));
case 'I': /* WriteObject */
return check_disk_error(idfName,
gso_write_object(idfName, idName));
case 'S': /* WriteSlotValue */
return check_disk_error(idfName,
gso_write_slot(idfName, idName,
KppGetNthArg(lpExp, 2,
EXPATOM)));
case 'M': /* WriteMethod */
return check_disk_error(idfName,
gso_write_method(idfName, idName,
KppGetNthArg(lpExp, 2,
EXPATOM)));
case 'F': /* WriteFunction */
return check_disk_error(idfName,
gso_write_function(idfName, idName));
case 'R': /* WriteRule */
return check_disk_error(idfName,
gso_write_rule(idfName, idName));
case 'G': /* WriteGoal */
return check_disk_error(idfName,
gso_write_goal(idfName, idName));
case 'A': /* WriteAll... */
switch(stName[8]) {
case 'C': /* WriteAllClasses */
return check_disk_error(idfName,
gso_write_all_classes(idfName, lpExp, wArgs));
case 'I': /* WriteAllObjects */
if (!(outFile && KppSaveAllObjects(outFile)))
KappaReturnError;
if (outFile && ferror (outFile))
return KPC_ERROR (IDE_FOUTOFDISK, NULL);
KappaReturnTrue;
case 'F': /* WriteAllFunctions */
if (!(outFile && KppSaveAllFuncs(outFile)))
KappaReturnError;
if (outFile && ferror (outFile))
return KPC_ERROR (IDE_FOUTOFDISK, NULL);
KappaReturnTrue;
case 'R': /* WriteAllRules */
if (!kpc_write_all_rules())
KappaReturnError;
if (outFile && ferror (outFile))
return KPC_ERROR (IDE_FOUTOFDISK, NULL);
KappaReturnTrue;
case 'G': /* WriteAllGoals */
if (!kpc_write_all_goals())
KappaReturnError;
if (outFile && ferror (outFile))
return KPC_ERROR (IDE_FOUTOFDISK, NULL);
KappaReturnTrue;
case 'K': /* WriteAllKnowledge */
case '\0': /* WriteAll */
if (!kpc_write_all())
KappaReturnError;
if (outFile && ferror (outFile))
return KPC_ERROR (IDE_FOUTOFDISK, NULL);
KappaReturnTrue;
}
KappaReturnError;
}
KappaReturnError;
}
