CSensor_btprox::~CSensor_btprox() { Cancel(); BtClose(); SESSION_CLOSE_IF_OPEN(iSocketServ); SESSION_CLOSE_IF_OPEN(iTimer); FreeResult(iResult); FreeResult(iOldResult); }
GLBSYM GetIdentityElement_EM (LPPL_YYSTYPE lpYYFcnStrLft, // Ptr to left operand function strand LPTOKEN lptkLftArg, // Ptr to left arg token LPPL_YYSTYPE lpYYFcnStrRht, // Ptr to right operand function strand (may be NULL if Scan) LPTOKEN lptkRhtArg) // Ptr to right arg token { LPPL_YYSTYPE lpYYRes = NULL, // Ptr to intermediate result lpYYRes2 = NULL, // Ptr to secondary result lpYYResL = NULL, // Ptr to left result lpYYResL2 = NULL, // Ptr to secondary left result lpYYResR = NULL, // Ptr to right result lpYYResR2 = NULL; // Ptr to secondary right result GLBSYM hGlbSym = {NULL}; // Result LPPRIMFLAGS lpPrimFlagsLft; // Ptr to Left operand primitive flags LPTOKEN lptkAxisLft, // Ptr to left operand axis token lptkAxisRht; // ... right ... TOKEN tkFcn = {0}; // Function token Assert (lpYYFcnStrLft NE NULL); Assert (lptkRhtArg NE NULL); // If the right operand is defined (thus, it's Inner Product), ... if (lpYYFcnStrRht NE NULL) { LPPRIMFNS lpPrimProtoRht; // Ptr to right operand prototype function TOKEN tkLft = tkZero; // Boolean zero token // Setup a token with the Boolean scalar zero ////////tkLft.tkFlags.TknType = TKT_VARIMMED; // Already set from tkZero ////////tkLft.tkFlags.ImmType = IMMTYPE_BOOL; // Already set from tkZero ////////tkLft.tkFlags.NoDisplay = FALSE; // Already set from tkZero ////////tkLft.tkData.tkBoolean = 0; // Already set from tkZero tkLft.tkCharIndex = lpYYFcnStrRht->tkToken.tkCharIndex; // Setup a token with the {rho} function tkFcn.tkFlags.TknType = TKT_FCNIMMED; tkFcn.tkFlags.ImmType = IMMTYPE_PRIMFCN; ////////tkFcn.tkFlags.NoDisplay = FALSE; // Already zero from tkZero tkFcn.tkData.tkChar = UTF16_RHO; tkFcn.tkCharIndex = lpYYFcnStrRht->tkToken.tkCharIndex; // Check for right operand axis operator lptkAxisRht = CheckAxisOper (lpYYFcnStrRht); // Execute the right operand between the left and right args // as a prototype function if it's a UDFO // Get the appropriate prototype function ptr lpPrimProtoRht = GetPrototypeFcnPtr (&lpYYFcnStrRht->tkToken); // Check for error if (lpPrimProtoRht EQ NULL) goto RIGHT_NONCE_EXIT; // Reshape the left arg item to an empty vector lpYYResL = PrimFnDydRho_EM_YY (&tkLft, // Ptr to left arg token &tkFcn, // Ptr to function token lptkLftArg, // Ptr to right arg token NULL); // Ptr to axis token (may be NULL) // Check for error if (lpYYResL EQ NULL) goto ERROR_EXIT; // Reshape the right arg item to an empty vector lpYYResR = PrimFnDydRho_EM_YY (&tkLft, // Ptr to left arg token &tkFcn, // Ptr to function token lptkRhtArg, // Ptr to right arg token NULL); // Ptr to axis token (may be NULL) // Check for error if (lpYYResR EQ NULL) goto ERROR_EXIT; // Setup a token with the {take} function ////////tkFcn.tkFlags.TknType = TKT_FCNIMMED; // Already set above ////////tkFcn.tkFlags.ImmType = IMMTYPE_PRIMFCN; // Already set above ////////tkFcn.tkFlags.NoDisplay = FALSE; // Already zero from = {0} tkFcn.tkData.tkChar = UTF16_UPARROW; ////////tkFcn.tkCharIndex = lpYYFcnStrLft->tkToken.tkCharIndex; // Execute monadic UpArrow on the last two results to extract the first item lpYYResL2 = PrimFnMonUpArrow_EM_YY (&tkFcn, // Ptr to function token &lpYYResL->tkToken, // Ptr to right arg token NULL); // Ptr to axis token (may be NULL) // Check for error if (lpYYResL2 EQ NULL) goto ERROR_EXIT; // Execute monadic UpArrow on the last two results to extract the first item lpYYResR2 = PrimFnMonUpArrow_EM_YY (&tkFcn, // Ptr to function token &lpYYResR->tkToken, // Ptr to right arg token NULL); // Ptr to axis token (may be NULL) // Check for error if (lpYYResR2 EQ NULL) goto ERROR_EXIT; // Execute the right operand between the left and right args // Note that we cast the function strand to LPTOKEN // to bridge the two types of calls -- one to a primitive // function which takes a function token, and one to a // primitive operator which takes a function strand lpYYRes2 = (*lpPrimProtoRht) (&lpYYResL2->tkToken, // Ptr to left arg token (may be NULL) (LPTOKEN) lpYYFcnStrRht, // Ptr to left operand function strand &lpYYResR2->tkToken, // Ptr to right arg token lptkAxisRht); // Ptr to axis token (may be NULL) } else { // Setup a token with the {take} function tkFcn.tkFlags.TknType = TKT_FCNIMMED; // Already set above tkFcn.tkFlags.ImmType = IMMTYPE_PRIMFCN; // Already set above ////////tkFcn.tkFlags.NoDisplay = FALSE; // Already zero from = {0} tkFcn.tkData.tkChar = UTF16_UPARROW; tkFcn.tkCharIndex = lpYYFcnStrLft->tkToken.tkCharIndex; // Execute monadic UpArrow on the right arg to extract the first item lpYYRes2 = PrimFnMonUpArrow_EM_YY (&tkFcn, // Ptr to function token lptkRhtArg, // Ptr to right arg token NULL); // Ptr to axis token (may be NULL) } // End IF/ELSE // Check for error if (lpYYRes2 EQ NULL) goto ERROR_EXIT; // Copy the result as the new right arg token lptkRhtArg = &lpYYRes2->tkToken; // Execute the left operand identity function on the right arg // Check for left operand axis operator lptkAxisLft = CheckAxisOper (lpYYFcnStrLft); // Get the appropriate identity function ptr lpPrimFlagsLft = GetPrimFlagsPtr (&lpYYFcnStrLft->tkToken); // Check for error if (lpPrimFlagsLft EQ NULL || lpPrimFlagsLft->lpPrimOps EQ NULL) goto LEFT_NONCE_EXIT; lpYYRes = (*lpPrimFlagsLft->lpPrimOps) (lptkRhtArg, // Ptr to original right arg token lpYYFcnStrLft, // Ptr to operator or function strand lptkRhtArg, // Ptr to right arg token lptkAxisLft); // Ptr to axis token (may be NULL) // Check for error if (lpYYRes EQ NULL) goto ERROR_EXIT; // Is the token immediate? if (IsTknImmed (&lpYYRes->tkToken)) { // Copy the LPSYMENTRY as the result hGlbSym.lpSym = MakeSymEntry_EM (lpYYRes->tkToken.tkFlags.ImmType, // ImmType to use (see IMM_TYPES) &lpYYRes->tkToken.tkData.tkLongest, // Ptr to value to use &lpYYFcnStrLft->tkToken); // Ptr to token to use in case of error // Check for error if (hGlbSym.lpSym EQ NULL) goto ERROR_EXIT; } else // Copy the HGLOBAL as the result hGlbSym.hGlb = CopySymGlbDir_PTB (lpYYRes->tkToken.tkData.tkGlbData); goto NORMAL_EXIT; LEFT_NONCE_EXIT: ErrorMessageIndirectToken (ERRMSG_NONCE_ERROR APPEND_NAME, &lpYYFcnStrLft->tkToken); goto ERROR_EXIT; RIGHT_NONCE_EXIT: ErrorMessageIndirectToken (ERRMSG_NONCE_ERROR APPEND_NAME, &lpYYFcnStrRht->tkToken); goto ERROR_EXIT; ERROR_EXIT: NORMAL_EXIT: if (lpYYRes) { FreeResult (lpYYRes); YYFree (lpYYRes); lpYYRes = NULL; } // End IF if (lpYYRes2) { FreeResult (lpYYRes2); YYFree (lpYYRes2); lpYYRes2 = NULL; } // End IF if (lpYYResL) { FreeResult (lpYYResL); YYFree (lpYYResL); lpYYResL = NULL; } // End IF if (lpYYResL2) { FreeResult (lpYYResL2); YYFree (lpYYResL2); lpYYResL2 = NULL; } // End IF if (lpYYResR) { FreeResult (lpYYResR); YYFree (lpYYResR); lpYYResR = NULL; } // End IF if (lpYYResR2) { FreeResult (lpYYResR2); YYFree (lpYYResR2); lpYYResR2 = NULL; } // End IF return hGlbSym; } // End GetIdentityElement_EM
LPPL_YYSTYPE PrimOpDieresisJotCommon_EM_YY (LPTOKEN lptkLftArg, // Ptr to left arg token (may be NULL if monadic derived function) LPPL_YYSTYPE lpYYFcnStrLft, // Ptr to left operand function strand LPPL_YYSTYPE lpYYFcnStrOpr, // Ptr to operator function strand LPPL_YYSTYPE lpYYFcnStrRht, // Ptr to right operand function strand LPTOKEN lptkRhtArg, // Ptr to right arg token (may be NULL if niladic) UBOOL bPrototyping) // TRUE iff protoyping { HGLOBAL hGlbMFO1, // Magic function/operator #1 global memory handle hGlbMFO2, // Magic function/operator #2 global memory handle hGlbOprRht; // Right operand global memory handle LPPERTABDATA lpMemPTD; // Ptr to PerTabData global memory LPPL_YYSTYPE lpYYRes = NULL; // Ptr to result LPTOKEN lptkAxisOpr; // Ptr to axis token LPPLLOCALVARS lpplLocalVars; // Ptr to re-entrant vars LPUBOOL lpbCtrlBreak; // Ptr to Ctrl-Break flag // Get the thread's ptr to local vars lpplLocalVars = TlsGetValue (dwTlsPlLocalVars); // Get the ptr to the Ctrl-Break flag lpbCtrlBreak = &lpplLocalVars->bCtrlBreak; // Check for axis operator lptkAxisOpr = CheckAxisOper (lpYYFcnStrOpr); // Ensure the left operand is a function if (!IsTknFcnOpr (&lpYYFcnStrLft->tkToken) || IsTknFillJot (&lpYYFcnStrLft->tkToken)) goto LEFT_OPERAND_SYNTAX_EXIT; // Ensure the right operand is a variable if (IsTknFcnOpr (&lpYYFcnStrRht->tkToken) || IsTknFillJot (&lpYYFcnStrRht->tkToken)) goto RIGHT_OPERAND_SYNTAX_EXIT; // Get ptr to PerTabData global memory lpMemPTD = GetMemPTD (); // Get the magic function/operator global memory handles hGlbMFO1 = (lptkLftArg EQ NULL) ? lpMemPTD->hGlbMFO[MFOE_MonRank] : lpMemPTD->hGlbMFO[MFOE_DydRank]; hGlbMFO2 = lpMemPTD->hGlbMFO[MFOE_Conform]; // Get right operand global ptrs hGlbOprRht = GetGlbHandle (&lpYYFcnStrRht->tkToken); // If the right operand is not immediate, ... if (hGlbOprRht NE NULL) { APLSTYPE aplTypeOprRht; // Right operand storage type APLNELM aplNELMOprRht; // Right operand NELM APLRANK aplRankOprRht; // Right operand rank // Get the attributes (Type, NELM, and Rank) // of the right arg token AttrsOfGlb (hGlbOprRht, &aplTypeOprRht, &aplNELMOprRht, &aplRankOprRht, NULL); // Check for RIGHT OPERAND RANK ERROR if (1 < aplRankOprRht) goto RIGHT_OPERAND_RANK_EXIT; // Check for RIGHT OPERAND LENGTH ERROR if (1 > aplNELMOprRht || aplNELMOprRht > 3) goto RIGHT_OPERAND_LENGTH_EXIT; // Check for RIGHT OPERAND DOMAIN ERROR if (!IsNumeric (aplTypeOprRht)) goto RIGHT_OPERAND_DOMAIN_EXIT; } else // Check for RIGHT OPERAND DOMAIN ERROR if (!IsImmNum (lpYYFcnStrRht->tkToken.tkFlags.ImmType)) goto RIGHT_OPERAND_DOMAIN_EXIT; lpYYRes = ExecuteMagicOperator_EM_YY (lptkLftArg, // Ptr to left arg token (may be NULL if monadic/niladic) &lpYYFcnStrOpr->tkToken, // Ptr to function token lpYYFcnStrLft, // Ptr to left operand function strand lpYYFcnStrOpr, // Ptr to function strand lpYYFcnStrRht, // Ptr to right operand function strand (may be NULL) lptkRhtArg, // Ptr to right arg token (may be NULL if niladic) NULL, // Ptr to axis token hGlbMFO1, // Magic function/operator global memory handle NULL, // Ptr to HSHTAB struc (may be NULL) bPrototyping ? LINENUM_PRO : LINENUM_ONE); // Starting line # type (see LINE_NUMS) // If the result is valid, finish the process with Conforming Disclose if (lpYYRes NE NULL && !IsTknImmed (&lpYYRes->tkToken)) { HGLOBAL hGlbRes; // Result global memory handle LPAPLNESTED lpMemRes; // Ptr to result global memory APLSTYPE aplTypeRes; // Result storage type APLNELM aplNELMRes; // Result NELM APLRANK aplRankRes; // Result rank // Get result global ptrs hGlbRes = GetGlbHandle (&lpYYRes->tkToken); // Get the attributes (Type, NELM, and Rank) // of the result global AttrsOfGlb (hGlbRes, &aplTypeRes, &aplNELMRes, &aplRankRes, NULL); // If the result is nested, ... if (IsNested (aplTypeRes)) { APLRANK uMinRank, // Minimum rank across all items uMaxRank; // maximum ... APLUINT uRes; // Loop counter APLRANK aplRankItm; // Result item rank LPPL_YYSTYPE lpYYRes2; // Secondary result // Lock the memory to get a ptr to it lpMemRes = MyGlobalLockVar (hGlbRes); // Skip over the header to the data lpMemRes = VarArrayDataFmBase (lpMemRes); // Initialize minimum & maximum ranks uMinRank = NEG1A; uMaxRank = 0; // In case it's empty, we need to process the prototype aplNELMRes = max (aplNELMRes, 1); // Loop through the result looking for the minimum/maximum rank items for (uRes = 0; uRes < aplNELMRes; uRes++) { // Check for Ctrl-Break if (CheckCtrlBreak (*lpbCtrlBreak)) goto ERROR_EXIT; // Split cases based the item ptr type switch (GetPtrTypeDir (lpMemRes[uRes])) { case PTRTYPE_STCONST: // Get the minimum rank uMinRank = min (uMinRank, 0); break; case PTRTYPE_HGLOBAL: // Get the attributes (Type, NELM, and Rank) // of the result global item AttrsOfGlb (lpMemRes[uRes], NULL, NULL, &aplRankItm, NULL); // Get the minimum rank uMinRank = min (uMinRank, aplRankItm); // Get the maximum rank uMaxRank = max (uMaxRank, aplRankItm); break; defstop break; } // End SWITCH } // End FOR // We no longer need this ptr MyGlobalUnlock (hGlbRes); lpMemRes = NULL; // If the two ranks are unequal, ... if (uMinRank NE uMaxRank) { TOKEN tkLftArg = {0}; // Left arg token // Fill in the left arg token tkLftArg.tkFlags.TknType = TKT_VARIMMED; tkLftArg.tkFlags.ImmType = IMMTYPE_INT; ////////////////tkLftArg.tkFlags.NoDisplay = FALSE; // Already zero from = {0} tkLftArg.tkData.tkInteger = uMaxRank; ////////////////tkLftArg.tkCharIndex = 0; // Already zero from = {0} #ifdef DEBUG // Decrement the SI level of lpYYRes so YYResIsEmpty won't complain lpYYRes->SILevel--; #endif // Finish it off with another magic function/operator lpYYRes2 = ExecuteMagicFunction_EM_YY (&tkLftArg, // Ptr to left arg token &lpYYFcnStrOpr->tkToken, // Ptr to function token NULL, // Ptr to function strand &lpYYRes->tkToken, // Ptr to right arg token NULL, // Ptr to axis token hGlbMFO2, // Magic function/operator global memory handle NULL, // Ptr to HSHTAB struc (may be NULL) LINENUM_ONE); // Starting line # type (see LINE_NUMS) #ifdef DEBUG // Restore the SI level of lpYYRes lpYYRes->SILevel++; #endif // Free the first YYRes FreeResult (lpYYRes); YYFree (lpYYRes); lpYYRes = NULL; // Copy secondary result as primary result lpYYRes = lpYYRes2; lpYYRes2 = NULL; } // End IF // Just disclose the argument lpYYRes2 = PrimFnMonRightShoe_EM_YY (&lpYYFcnStrOpr->tkToken, // Ptr to function token &lpYYRes->tkToken, // Ptr to right arg token lptkAxisOpr); // Ptr to axis token // Free the first YYRes FreeResult (lpYYRes); YYFree (lpYYRes); lpYYRes = NULL; // Copy secondary result as primary result lpYYRes = lpYYRes2; } // End IF } // End IF
LPPL_YYSTYPE PrimFnMonCircleSlope_EM_YY (LPTOKEN lptkFunc, // Ptr to function token LPTOKEN lptkRhtArg, // Ptr to right arg token LPTOKEN lptkAxis) // Ptr to axis token (may be NULL) { APLSTYPE aplTypeRht; // Right arg storage type APLNELM aplNELMRht; // ... NELM APLRANK aplRankRht; // ... rank HGLOBAL hGlbLft; // Left arg global memory handle LPVOID lpMemLft; // Ptr to left arg global memory LPPL_YYSTYPE lpYYRes, // Ptr to the result lpYYRes2; // Ptr to secondary result APLUINT ByteRes; // # bytes in the result APLBOOL bQuadIO; // []IO // Get the current value of []IO bQuadIO = GetQuadIO (); //*************************************************************** // This function is not sensitive to the axis operator, // so signal a syntax error if present //*************************************************************** if (lptkAxis NE NULL) goto AXIS_SYNTAX_EXIT; // Get the attributes (Type, NELM, and Rank) of the right arg AttrsOfToken (lptkRhtArg, &aplTypeRht, &aplNELMRht, &aplRankRht, NULL); // Calculate space needed for the left arg ByteRes = CalcArraySize (ARRAY_APA, aplRankRht, 1); // Check for overflow if (ByteRes NE (APLU3264) ByteRes) goto WSFULL_EXIT; // Allocate storage for the left argument hGlbLft = DbgGlobalAlloc (GHND, (APLU3264) ByteRes); if (hGlbLft EQ NULL) goto WSFULL_EXIT; // Lock the memory to get a ptr to it lpMemLft = MyGlobalLock000 (hGlbLft); #define lpHeader ((LPVARARRAY_HEADER) lpMemLft) // Fill in the header values lpHeader->Sig.nature = VARARRAY_HEADER_SIGNATURE; lpHeader->ArrType = ARRAY_APA; ////lpHeader->PermNdx = PERMNDX_NONE;// Already zero from GHND ////lpHeader->SysVar = FALSE; // Already zero from GHND lpHeader->RefCnt = 1; lpHeader->NELM = aplRankRht; lpHeader->Rank = 1; #undef lpHeader // Fill in the dimension *VarArrayBaseToDim (lpMemLft) = aplRankRht; // Skip over the header and dimensions to the data lpMemLft = VarArrayDataFmBase (lpMemLft); // Fill in the APA parameters #define lpAPA ((LPAPLAPA) lpMemLft) lpAPA->Off = (aplRankRht - 1) + bQuadIO; lpAPA->Mul = -1; #undef lpAPA // We no longer need this ptr MyGlobalUnlock (hGlbLft); lpMemLft = NULL; // Allocate a new YYRes lpYYRes = YYAlloc (); // Fill in the left arg token lpYYRes->tkToken.tkFlags.TknType = TKT_VARARRAY; ////lpYYRes->tkToken.tkFlags.ImmType = IMMTYPE_ERROR; // Already zero from YYAlloc ////lpYYRes->tkToken.tkFlags.NoDisplay = FALSE; // Already zero from YYAlloc lpYYRes->tkToken.tkData.tkGlbData = MakePtrTypeGlb (hGlbLft); lpYYRes->tkToken.tkCharIndex = lptkFunc->tkCharIndex; // Call the dyadic function lpYYRes2 = PrimFnDydCircleSlope_EM_YY (&lpYYRes->tkToken, // Ptr to left arg token lptkFunc, // Ptr to function token lptkRhtArg, // Ptr to right arg token lptkAxis); // Ptr to axis token (may be NULL) // We no longer need this storage FreeResult (lpYYRes); YYFree (lpYYRes); lpYYRes = NULL; return lpYYRes2; AXIS_SYNTAX_EXIT: ErrorMessageIndirectToken (ERRMSG_SYNTAX_ERROR APPEND_NAME, lptkAxis); return NULL; WSFULL_EXIT: ErrorMessageIndirectToken (ERRMSG_WS_FULL APPEND_NAME, lptkFunc); return NULL; } // End PrimFnMonCircleSlope_EM_YY