// 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; }