Status GRCsim::visit(BinaryOp &e) { assert(e.source1); assert(e.source2); if(debug) cerr<<"Warning: 3-valued-simulator does NOT support BinaryOp yet!\n"; int val1 = intVal(e.source1); int val2 = intVal(e.source2); int result = (e.op == "and") ? (val1 && val2) : (e.op == "or") ? (val1 || val2) : (e.op == "+") ? (val1 + val2) : (e.op == "-") ? (val1 - val2) : (e.op == "*") ? (val1 * val2) : (e.op == "/") ? (val1 / val2) : (e.op == "mod") ? (val1 % val2) : (e.op == "=") ? (val1 == val2) : (e.op == "<>") ? (val1 != val2) : (e.op == "<") ? (val1 < val2) : (e.op == "<=") ? (val1 <= val2) : (e.op == ">") ? (val1 > val2) : (e.op == ">=") ? (val1 >= val2) : 0; return Status(result); }
void cShortcut::attribChanged (const QString &name) { if (name == "command") { d->command = strVal ("command"); updateVisibleName (); return; } if (name == "key") { d->key = intVal ("key"); updateVisibleName (); return; } if (name == "modifiers") { d->modifiers = intVal ("modifiers"); updateVisibleName (); return; } if (name == "send") { d->send = boolVal ("send"); return; } if (name == "overwrite") { d->overwrite = boolVal ("overwrite"); return; } if (name == "script") updateVisibleName (); }
void cgStElem(IRLS& env, const IRInstruction* inst) { auto const rbase = srcLoc(env, inst, 0).reg(); auto const ridx = srcLoc(env, inst, 1).reg(); auto const idx = inst->src(1); auto& v = vmain(env); if (idx->hasConstVal() && deltaFits(idx->intVal(), sz::dword)) { storeTV(v, rbase[idx->intVal()], srcLoc(env, inst, 2), inst->src(2)); } else { storeTV(v, rbase[ridx], srcLoc(env, inst, 2), inst->src(2)); } }
void cgLdElem(IRLS& env, const IRInstruction* inst) { auto const rbase = srcLoc(env, inst, 0).reg(); auto const ridx = srcLoc(env, inst, 1).reg(); auto const idx = inst->src(1); auto& v = vmain(env); if (idx->hasConstVal() && deltaFits(idx->intVal(), sz::dword)) { loadTV(v, inst->dst(), dstLoc(env, inst, 0), rbase[idx->intVal()]); } else { loadTV(v, inst->dst(), dstLoc(env, inst, 0), rbase[ridx]); } }
/* * Extract an int64 value from a DefElem. */ int64 defGetInt64(DefElem *def) { if (def->arg == NULL) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("%s requires a numeric value", def->defname))); switch (nodeTag(def->arg)) { case T_Integer: return (int64) intVal(def->arg); case T_Float: /* * Values too large for int4 will be represented as Float * constants by the lexer. Accept these if they are valid int8 * strings. */ return DatumGetInt64(DirectFunctionCall1(int8in, CStringGetDatum(strVal(def->arg)))); default: ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("%s requires a numeric value", def->defname))); } return 0; /* keep compiler quiet */ }
/* * BeginStreamScan */ void BeginStreamScan(ForeignScanState *node, int eflags) { ForeignScan *plan = (ForeignScan *) node->ss.ps.plan; StreamScanState *state; ListCell *lc; List *colnames = (List *) linitial(plan->fdw_private); List *physical_tlist = (List *) lsecond(plan->fdw_private); Value *sample_cutoff = (Value *) lthird(plan->fdw_private); int i = 0; state = palloc0(sizeof(StreamScanState)); state->pi = palloc(sizeof(StreamProjectionInfo)); state->pi->mcxt = AllocSetContextCreate(CurrentMemoryContext, "ExecProjectContext", ALLOCSET_DEFAULT_MINSIZE, ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE); state->pi->ecxt = CreateStandaloneExprContext(); state->pi->outdesc = ExecTypeFromTL(physical_tlist, false); state->pi->indesc = NULL; state->sample_cutoff = sample_cutoff ? intVal(sample_cutoff) : -1; Assert(state->pi->outdesc->natts == list_length(colnames)); foreach(lc, colnames) { Value *v = (Value *) lfirst(lc); namestrcpy(&(state->pi->outdesc->attrs[i++]->attname), strVal(v)); }
Variant SSATmp::variantVal() const { switch (type().toDataType()) { case KindOfUninit: case KindOfNull: // Upon return both will converted to KindOfNull anyway. return init_null(); case KindOfBoolean: return boolVal(); case KindOfInt64: return intVal(); case KindOfDouble: return dblVal(); case KindOfStaticString: case KindOfString: return Variant(const_cast<StringData*>(strVal())); case KindOfArray: return const_cast<ArrayData*>(arrVal()); case KindOfObject: case KindOfResource: case KindOfRef: case KindOfClass: break; } not_reached(); }
/* * Extract a string value (otherwise uninterpreted) from a DefElem. */ char * defGetString(DefElem *def) { if (def->arg == NULL) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("%s requires a parameter", def->defname))); switch (nodeTag(def->arg)) { case T_Integer: { char *str = palloc(32); snprintf(str, 32, "%ld", (long) intVal(def->arg)); return str; } case T_Float: /* * T_Float values are kept in string form, so this type cheat * works (and doesn't risk losing precision) */ return strVal(def->arg); case T_String: return strVal(def->arg); case T_TypeName: return TypeNameToString((TypeName *) def->arg); case T_List: return NameListToString((List *) def->arg); default: elog(ERROR, "unrecognized node type: %d", (int) nodeTag(def->arg)); } return NULL; /* keep compiler quiet */ }
Status GRCsim::visit(StartCounter &stcnt) { if (debug) cerr << ":start counter\n"; if(debug) cerr<<"Warning: 3-valued-simulator does NOT support StartCounter yet!\n"; assert(stcnt.counter); assert(stcnt.count); counters[stcnt.counter] = intVal(stcnt.count); return Status(); }
Status GRCsim::visit(CheckCounter &chkcnt) { assert(chkcnt.counter); assert(chkcnt.predicate); if (intVal(chkcnt.predicate)) counters[chkcnt.counter]--; return Status( counters[chkcnt.counter] == 0); }
// Read next sector of stream void ole2_bufread(OLE2Stream* olest) { BYTE *ptr; assert(olest); assert(olest->ole); if ((DWORD)olest->fatpos!=ENDOFCHAIN) { if(olest->sfat) { assert(olest->ole->SSAT); assert(olest->buf); assert(olest->ole->SSecID); ptr = olest->ole->SSAT + olest->fatpos*olest->ole->lssector; memcpy(olest->buf, ptr, olest->bufsize); olest->fatpos=intVal(olest->ole->SSecID[olest->fatpos]); olest->pos=0; olest->cfat++; } else { assert(olest->fatpos >= 0); //printf("fatpos: %d max=%u\n",olest->fatpos, (olest->ole->cfat*olest->ole->lsector)/4); if(olest->fatpos > (olest->ole->cfat*olest->ole->lsector)/4) exit(-1); #if 0 // TODO: remove fseek(olest->ole->file,olest->fatpos*olest->ole->lsector+512,0); ret = fread(olest->buf,1,olest->bufsize,olest->ole->file); assert(ret == olest->bufsize); #endif assert((int)olest->fatpos >= 0); sector_read(olest->ole, olest->buf, olest->fatpos); //printf("Fat val: %d[0x%X]\n",olest->fatpos,olest->ole->SecID[olest->fatpos], olest->ole->SecID[olest->fatpos]); olest->fatpos=intVal(olest->ole->SecID[olest->fatpos]); olest->pos=0; olest->cfat++; } } // else printf("ENDOFCHAIN!!!\n"); }
TInt COpenMAXALTestModule::validateAudioCodecDescriptorAtIndex( XAuint32 aAudioCodecId, XAAudioCodecDescriptor& aDesc, CStifItemParser& aItem ) { TInt status(KErrNone); TInt intVal(0); TInt loopIndex(0); RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.maxChannels); RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.minBitsPerSample); RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.maxBitsPerSample); RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.minSampleRate); RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.maxSampleRate); RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.isFreqRangeContinuous); RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.numSampleRatesSupported); for(loopIndex = 0; loopIndex < aDesc.numSampleRatesSupported; loopIndex++) { RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.pSampleRatesSupported[loopIndex]); } RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.minBitRate); RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.maxBitRate); RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.isBitrateRangeContinuous); RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.numBitratesSupported); for(loopIndex = 0; loopIndex < aDesc.numBitratesSupported; loopIndex++) { RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.pBitratesSupported[loopIndex]); } switch (aAudioCodecId) { case XA_AUDIOCODEC_PCM: RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.profileSetting); if (!status) { RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.modeSetting); } break; case XA_AUDIOCODEC_AMR: RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.profileSetting); if (!status) { RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.modeSetting); } break; case XA_AUDIOCODEC_AAC: RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.profileSetting); if (!status) { RETURN_ERR_IF_NOT_EQUAL(aItem, intVal, aDesc.modeSetting); } break; } return status; }
Status GRCsim::visit(UnaryOp &e) { if(debug) cerr<<"Warning: 3-valued-simulator does NOT support UnaryOp yet!\n"; int val = intVal(e.source); int result = (e.op == "not") ? ( !val ) : (e.op == "-") ? ( -val ) : 0; return Status(result); }
/* * Extract a boolean value from a DefElem. */ bool defGetBoolean(DefElem *def) { /* * If no parameter given, assume "true" is meant. */ if (def->arg == NULL) return true; /* * Allow 0, 1, "true", "false", "on", "off" */ switch (nodeTag(def->arg)) { case T_Integer: switch (intVal(def->arg)) { case 0: return false; case 1: return true; default: /* otherwise, error out below */ break; } break; default: { char *sval = defGetString(def); /* * The set of strings accepted here should match up with the * grammar's opt_boolean production. */ if (pg_strcasecmp(sval, "true") == 0) return true; if (pg_strcasecmp(sval, "false") == 0) return false; if (pg_strcasecmp(sval, "on") == 0) return true; if (pg_strcasecmp(sval, "off") == 0) return false; } break; } ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("%s requires a Boolean value", def->defname))); return false; /* keep compiler quiet */ }
Status GRCsim::visit(Emit &e) { assert(e.signal); SignalSymbol *ss = e.signal; if(ss->type && ss->type->name=="integer"){ signals_v[ss]=intVal(e.value); if(debug) cerr<<" value : "<<signals_v[ss]<<" "; } if (debug) cerr << ":emit " << ss->name <<" = "<<globalcc<< endl; if(signals[ss] != 1) signals[ss] = globalcc; return Status(); }
// Move in stream void ole2_seek(OLE2Stream* olest,DWORD ofs) { if(olest->sfat) { ldiv_t div_rez=ldiv(ofs,olest->ole->lssector); int i; olest->fatpos=olest->start; if (div_rez.quot!=0) { for (i=0;i<div_rez.quot;i++) olest->fatpos=intVal(olest->ole->SSecID[olest->fatpos]); } ole2_bufread(olest); olest->pos=div_rez.rem; olest->eof=0; olest->cfat=div_rez.quot; //printf("%i=%i %i\n",ofs,div_rez.quot,div_rez.rem); } else { ldiv_t div_rez=ldiv(ofs,olest->ole->lsector); int i; olest->fatpos=olest->start; if (div_rez.quot!=0) { for (i=0;i<div_rez.quot;i++) olest->fatpos=intVal(olest->ole->SecID[olest->fatpos]); } ole2_bufread(olest); olest->pos=div_rez.rem; olest->eof=0; olest->cfat=div_rez.quot; //printf("%i=%i %i\n",ofs,div_rez.quot,div_rez.rem); } }
Status GRCsim::visit(Assign &a) { assert(a.variable); assert(a.value); assert(a.variable->type); if(debug) cerr<<"Warning: 3-valued-simulator does NOT support Assign yet!\n"; if (a.variable->type->name != "integer" && a.variable->type->name != "boolean") { throw IR::Error("Only integer and boolean variables supported"); } var[a.variable] = intVal(a.value); return Status(); }
std::string Instruction::getJumpName() { std::string result = ""; bitset<26> jmp = jmp_offset(); bitset<32> intVal(0); for( int i = 0; i < 26; i++ ) { intVal[i] = jmp[i]; } for( int i = 26; i < 32; i++ ) { intVal[i] = jmp[25]; } std::cout << intVal.to_string() << std::endl; result = std::to_string( static_cast<int>( intVal.to_ulong() ) ); return result; }
TEST(Type, Const) { auto five = Type::cns(5); EXPECT_LT(five, Type::Int); EXPECT_NE(five, Type::Int); EXPECT_TRUE(five.isConst()); EXPECT_EQ(5, five.intVal()); EXPECT_TRUE(five.isConst(Type::Int)); EXPECT_TRUE(five.isConst(5)); EXPECT_FALSE(five.isConst(5.0)); EXPECT_TRUE(Type::Gen.maybe(five)); EXPECT_EQ(Type::Int, five | Type::Int); EXPECT_EQ(Type::Int, five | Type::cns(10)); EXPECT_EQ(five, five | Type::cns(5)); EXPECT_EQ(five, Type::cns(5) & five); EXPECT_EQ(five, five & Type::Int); EXPECT_EQ(five, Type::Gen & five); EXPECT_EQ("Int<5>", five.toString()); EXPECT_EQ(five, five - Type::Arr); EXPECT_EQ(five, five - Type::cns(1)); EXPECT_EQ(Type::Bottom, five - Type::Int); EXPECT_EQ(Type::Bottom, five - five); EXPECT_EQ(Type::Int, five.dropConstVal()); EXPECT_TRUE(five.not(Type::cns(2))); auto True = Type::cns(true); EXPECT_EQ("Bool<true>", True.toString()); EXPECT_LT(True, Type::Bool); EXPECT_NE(True, Type::Bool); EXPECT_TRUE(True.isConst()); EXPECT_EQ(true, True.boolVal()); EXPECT_TRUE(Type::Uncounted.maybe(True)); EXPECT_FALSE(five <= True); EXPECT_FALSE(five > True); EXPECT_TRUE(five.not(True)); EXPECT_EQ(Type::Int | Type::Bool, five | True); EXPECT_EQ(Type::Bottom, five & True); EXPECT_TRUE(Type::Uninit.isConst()); EXPECT_TRUE(Type::InitNull.isConst()); EXPECT_FALSE(Type::Null.isConst()); EXPECT_FALSE((Type::Uninit | Type::Bool).isConst()); EXPECT_FALSE(Type::Int.isConst()); }
void GRCsim::init() { entergrc = dynamic_cast<EnterGRC*>(top->control_flow_graph); if (entergrc) grcroot = dynamic_cast<GRCNode*>(entergrc->successors.back()); else grcroot = dynamic_cast<GRCNode*>(top->control_flow_graph); assert (grcroot); stroot = dynamic_cast<STexcl *>(top->selection_tree); assert(stroot); boot = dynamic_cast<STleaf* >(stroot->children.back()); assert(boot); globalcc = 1; setState(boot,true); ternary = false; if ( debug & debugDFS ) cerr << "will dfs\n"; jump = false; dfs(grcroot); if (debug & debugDFS ) cerr << "init ok\n"; if (debug & debugDFS ){ cerr << "--------topo-------:\n"; for (vector<GRCNode*>::iterator i = topo.end()-1; i >= topo.begin(); i--) cerr << cfgmap[*i] << ' '; cerr << "\n"; } // Initialize constants assert(module->constants); for ( SymbolTable::const_iterator i = module->constants->begin(); i != module->constants->end() ; i++ ) { ConstantSymbol *cs = dynamic_cast<ConstantSymbol*>(*i); if (cs && cs->initializer) { assert(cs->type); if (cs->type->name != "integer" && cs->type->name != "boolean") throw IR::Error("only integer and boolean constants are supported"); var[cs] = intVal(cs->initializer); } } }
Status GRCsim::visit(Test &s) { GRCNode *successor; assert(s.predicate); //assert(s.successors.size()==2); int predvalue = intVal(s.predicate); if (predvalue==-1){//unknown if (debug) { cerr << cfgmap[&s] << ":test -- " << predvalue << " --> "; for(vector<GRCNode *>::iterator i = s.successors.begin(); i != s.successors.end(); i++){ if (*i) cerr << cfgmap[*i]; else cerr<<" (none)"; } cerr<<"\n"; } ternary = true; for(vector<GRCNode *>::iterator i = s.successors.begin(); i != s.successors.end(); i++){ schedule(*i,-1); } } else{ assert ( predvalue >= 0 && predvalue < (int)s.successors.size() ); successor = s.successors[predvalue]; if (debug) { cerr << cfgmap[&s] << ":test --" << predvalue << "--> "; if (successor) cerr << cfgmap[successor]; else cerr << "(none)"; cerr << '\n'; } if (successor) schedule(successor,globalcc); } return Status(); }
/* * oidparse - get OID from IConst/FConst node */ Oid oidparse(Node *node) { switch (nodeTag(node)) { case T_Integer: return intVal(node); case T_Float: /* * Values too large for int4 will be represented as Float * constants by the lexer. Accept these if they are valid OID * strings. */ return oidin_subr(strVal(node), NULL); default: elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node)); } return InvalidOid; /* keep compiler quiet */ }
/* * Extract an int32 value from a DefElem. */ int32 defGetInt32(DefElem *def) { if (def->arg == NULL) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("%s requires an integer value", def->defname))); switch (nodeTag(def->arg)) { case T_Integer: return (int32) intVal(def->arg); default: ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("%s requires an integer value", def->defname))); } return 0; /* keep compiler quiet */ }
Variant SSATmp::variantVal() const { switch (type().toDataType()) { case KindOfUninit: case KindOfNull: // Upon return both will converted to KindOfNull anyway. return init_null(); case KindOfBoolean: return boolVal(); case KindOfInt64: return intVal(); case KindOfDouble: return dblVal(); case KindOfString: case KindOfStaticString: return Variant(const_cast<StringData*>(strVal())); case KindOfArray: return const_cast<ArrayData*>(arrVal()); default: always_assert(false); } }
/* * Extract a type length indicator (either absolute bytes, or * -1 for "variable") from a DefElem. */ int defGetTypeLength(DefElem *def) { if (def->arg == NULL) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("%s requires a parameter", def->defname))); switch (nodeTag(def->arg)) { case T_Integer: return intVal(def->arg); case T_Float: ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("%s requires an integer value", def->defname))); break; case T_String: if (pg_strcasecmp(strVal(def->arg), "variable") == 0) return -1; /* variable length */ break; case T_TypeName: /* cope if grammar chooses to believe "variable" is a typename */ if (pg_strcasecmp(TypeNameToString((TypeName *) def->arg), "variable") == 0) return -1; /* variable length */ break; case T_List: /* must be an operator name */ break; default: elog(ERROR, "unrecognized node type: %d", (int) nodeTag(def->arg)); } ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("invalid argument for %s: \"%s\"", def->defname, defGetString(def)))); return 0; /* keep compiler quiet */ }
/** * Get weight associated with queue. See queue.c. * * Attention is paid in order to avoid catalog lookups when not allowed. The * superuser() function performs catalog lookups in certain cases. Also the * GetResqueueCapabilityEntry will always do a catalog lookup. In such cases * use the default weight. */ static int ResourceQueueGetPriorityWeight(Oid queueId) { List *capabilitiesList = NULL; List *entry = NULL; ListCell *le = NULL; int weight = BackoffDefaultWeight(); if (!IsTransactionState()) return weight; if (superuser()) return BackoffSuperuserStatementWeight(); if (queueId == InvalidOid) return weight; capabilitiesList = GetResqueueCapabilityEntry(queueId); /* This is a list of * lists */ if (!capabilitiesList) return weight; foreach(le, capabilitiesList) { Value *key = NULL; entry = (List *) lfirst(le); Assert(entry); key = (Value *) linitial(entry); Assert(key->type == T_Integer); /* This is resource type id */ if (intVal(key) == PG_RESRCTYPE_PRIORITY) { Value *val = lsecond(entry); Assert(val->type == T_String); weight = BackoffPriorityValueToInt(strVal(val)); } }
/* * Extract a numeric value (actually double) from a DefElem. */ double defGetNumeric(DefElem *def) { if (def->arg == NULL) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("%s requires a numeric value", def->defname))); switch (nodeTag(def->arg)) { case T_Integer: return (double) intVal(def->arg); case T_Float: return floatVal(def->arg); default: ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("%s requires a numeric value", def->defname))); } return 0; /* keep compiler quiet */ }
TEST(Type, Const) { auto five = Type::cns(5); EXPECT_LT(five, Type::Int); EXPECT_NE(five, Type::Int); EXPECT_TRUE(five.isConst()); EXPECT_EQ(5, five.intVal()); EXPECT_TRUE(five.isConst(Type::Int)); EXPECT_TRUE(five.isConst(5)); EXPECT_FALSE(five.isConst(5.0)); EXPECT_TRUE(Type::Gen.maybe(five)); EXPECT_EQ(Type::Int, five | Type::Int); EXPECT_EQ(Type::Int, five | Type::cns(10)); EXPECT_EQ(five, five | Type::cns(5)); EXPECT_EQ(five, Type::cns(5) & five); EXPECT_EQ(five, five & Type::Int); EXPECT_EQ(five, Type::Gen & five); EXPECT_EQ("Int<5>", five.toString()); EXPECT_EQ(five, five - Type::Arr); EXPECT_EQ(five, five - Type::cns(1)); EXPECT_EQ(Type::Int, Type::Int - five); // conservative EXPECT_EQ(Type::Bottom, five - Type::Int); EXPECT_EQ(Type::Bottom, five - five); EXPECT_EQ(Type::PtrToGen, (Type::PtrToGen|Type::Nullptr) - Type::Nullptr); EXPECT_EQ(Type::Int, five.dropConstVal()); EXPECT_TRUE(five.not(Type::cns(2))); auto True = Type::cns(true); EXPECT_EQ("Bool<true>", True.toString()); EXPECT_LT(True, Type::Bool); EXPECT_NE(True, Type::Bool); EXPECT_TRUE(True.isConst()); EXPECT_EQ(true, True.boolVal()); EXPECT_TRUE(Type::Uncounted.maybe(True)); EXPECT_FALSE(five <= True); EXPECT_FALSE(five > True); EXPECT_TRUE(five.not(True)); EXPECT_EQ(Type::Int | Type::Bool, five | True); EXPECT_EQ(Type::Bottom, five & True); EXPECT_TRUE(Type::Uninit.isConst()); EXPECT_TRUE(Type::InitNull.isConst()); EXPECT_FALSE(Type::Null.isConst()); EXPECT_FALSE((Type::Uninit | Type::Bool).isConst()); EXPECT_FALSE(Type::Int.isConst()); auto array = make_packed_array(1, 2, 3, 4); auto arrData = ArrayData::GetScalarArray(array.get()); auto constArray = Type::cns(arrData); auto packedArray = Type::Arr.specialize(ArrayData::kPackedKind); auto mixedArray = Type::Arr.specialize(ArrayData::kMixedKind); EXPECT_TRUE(constArray <= packedArray); EXPECT_TRUE(constArray < packedArray); EXPECT_FALSE(packedArray <= constArray); EXPECT_TRUE(constArray <= constArray); EXPECT_FALSE(packedArray <= mixedArray); EXPECT_FALSE(mixedArray <= packedArray); EXPECT_FALSE(constArray <= mixedArray); EXPECT_EQ(constArray, constArray & packedArray); ArrayTypeTable::Builder ratBuilder; auto rat1 = ratBuilder.packedn(RepoAuthType::Array::Empty::No, RepoAuthType(RepoAuthType::Tag::Str)); auto ratArray1 = Type::Arr.specialize(rat1); auto rat2 = ratBuilder.packedn(RepoAuthType::Array::Empty::No, RepoAuthType(RepoAuthType::Tag::Int)); auto ratArray2 = Type::Arr.specialize(rat2); EXPECT_EQ(Type::Arr, ratArray1 & ratArray2); EXPECT_TRUE(ratArray1 < Type::Arr); EXPECT_TRUE(ratArray1 <= ratArray1); EXPECT_TRUE(ratArray1 < (Type::Arr|Type::Obj)); EXPECT_FALSE(ratArray1 < ratArray2); EXPECT_NE(ratArray1, ratArray2); auto packedRat = packedArray & ratArray1; EXPECT_EQ("Arr=PackedKind:N([Str])", packedRat.toString()); EXPECT_TRUE(packedRat <= packedArray); EXPECT_TRUE(packedRat < packedArray); EXPECT_TRUE(packedRat <= ratArray1); EXPECT_TRUE(packedRat < ratArray1); EXPECT_EQ(packedRat, packedRat & packedArray); EXPECT_EQ(packedRat, packedRat & ratArray1); }
// Open physical file OLE2* ole2_open(const BYTE *file) { //BYTE buf[1024]; OLE2Header* oleh; OLE2* ole; OLE2Stream* olest; PSS* pss; BYTE* name = NULL; #ifdef OLE_DEBUG printf("----------------------------------------------\n"); printf("ole2_open %s\n", file); #endif if(xls_debug) printf("ole2_open: %s\n", file); ole=(OLE2*)calloc(1, sizeof(OLE2)); if (!(ole->file=fopen((char *)file,"rb"))) { if(xls_debug) printf("File not found\n"); free(ole); return(NULL); } // read header and check magic numbers oleh=(OLE2Header*)malloc(512); fread(oleh,1,512,ole->file); convertHeader(oleh); // make sure the file looks good. Note: this code only works on Little Endian machines if(oleh->id[0] != 0xE011CFD0 || oleh->id[1] != 0xE11AB1A1 || oleh->byteorder != 0xFFFE) { fclose(ole->file); printf("Not an excel file\n"); free(ole); return NULL; } //ole->lsector=(WORD)pow(2,oleh->lsector); //ole->lssector=(WORD)pow(2,oleh->lssector); ole->lsector=512; ole->lssector=64; assert(oleh->lsectorB==9); // 2**9 == 512 assert(oleh->lssectorB==6); // 2**6 == 64 ole->cfat=oleh->cfat; ole->dirstart=oleh->dirstart; ole->sectorcutoff=oleh->sectorcutoff; ole->sfatstart=oleh->sfatstart; ole->csfat=oleh->csfat; ole->difstart=oleh->difstart; ole->cdif=oleh->cdif; ole->files.count=0; #ifdef OLE_DEBUG printf("==== OLE HEADER ====\n"); //printf ("Header Size: %i \n", sizeof(OLE2Header)); //printf ("id[0]-id[1]: %X-%X \n", oleh->id[0], oleh->id[1]); printf ("verminor: %X \n",oleh->verminor); printf ("verdll: %X \n",oleh->verdll); //printf ("Byte order: %X \n",oleh->byteorder); printf ("sect len: %X (%i)\n",ole->lsector,ole->lsector); // ole printf ("mini len: %X (%i)\n",ole->lssector,ole->lssector); // ole printf ("Fat sect.: %i \n",oleh->cfat); printf ("Dir Start: %i \n",oleh->dirstart); printf ("Mini Cutoff: %i \n",oleh->sectorcutoff); printf ("MiniFat Start: %X \n",oleh->sfatstart); printf ("Count MFat: %i \n",oleh->csfat); printf ("Dif start: %X \n",oleh->difstart); printf ("Count Dif: %i \n",oleh->cdif); printf ("Fat Size: %u (0x%X) \n",oleh->cfat*ole->lsector,oleh->cfat*ole->lsector); #endif // read directory entries read_MSAT(ole, oleh); // reuse this buffer pss = (PSS*)oleh; // oleh = (void *)NULL; // Not needed as oleh not used from here on olest=ole2_sopen(ole,ole->dirstart, -1); do { ole2_read(pss,1,sizeof(PSS),olest); convertPss(pss); name=unicode_decode(pss->name, pss->bsize, 0, "UTF-8"); #ifdef OLE_DEBUG printf("OLE NAME: %s count=%d\n", name, ole->files.count); #endif if (pss->type == PS_USER_ROOT || pss->type == PS_USER_STREAM) // (name!=NULL) // { #ifdef OLE_DEBUG printf("OLE TYPE: %s file=%d \n", pss->type == PS_USER_ROOT ? "root" : "user", ole->files.count); #endif if (ole->files.count==0) { ole->files.file=malloc(sizeof(struct st_olefiles_data)); } else { ole->files.file=realloc(ole->files.file,(ole->files.count+1)*sizeof(struct st_olefiles_data)); } ole->files.file[ole->files.count].name=name; ole->files.file[ole->files.count].start=pss->sstart; ole->files.file[ole->files.count].size=pss->size; ole->files.count++; if(pss->sstart == ENDOFCHAIN) { if (xls_debug) verbose("END OF CHAIN\n"); } else if(pss->type == PS_USER_STREAM) { #ifdef OLE_DEBUG printf("----------------------------------------------\n"); printf("name: %s (size=%d [c=%c])\n", name, pss->bsize, name ? name[0]:' '); printf("bsize %i\n",pss->bsize); printf("type %i\n",pss->type); printf("flag %i\n",pss->flag); printf("left %X\n",pss->left); printf("right %X\n",pss->right); printf("child %X\n",pss->child); printf("guid %.4X-%.4X-%.4X-%.4X %.4X-%.4X-%.4X-%.4X\n",pss->guid[0],pss->guid[1],pss->guid[2],pss->guid[3], pss->guid[4],pss->guid[5],pss->guid[6],pss->guid[7]); printf("user flag %.4X\n",pss->userflags); printf("sstart %.4d\n",pss->sstart); printf("size %.4d\n",pss->size); #endif } else if(pss->type == PS_USER_ROOT) { DWORD sector, k, blocks; BYTE *wptr; blocks = (pss->size + (ole->lsector - 1)) / ole->lsector; // count partial ole->SSAT = (BYTE *)malloc(blocks*ole->lsector); // printf("blocks %d\n", blocks); assert(ole->SSecID); sector = pss->sstart; wptr=(BYTE*)ole->SSAT; for(k=0; k<blocks; ++k) { // printf("block %d sector %d\n", k, sector); assert(sector != ENDOFCHAIN); fseek(ole->file,sector*ole->lsector+512,0); fread(wptr,1,ole->lsector,ole->file); wptr += ole->lsector; sector = intVal(ole->SecID[sector]); } } } else { free(name); } } while (!olest->eof); ole2_fclose(olest); free(pss); return ole; }
/* * DefineAggregate * * "oldstyle" signals the old (pre-8.2) style where the aggregate input type * is specified by a BASETYPE element in the parameters. Otherwise, * "args" is a pair, whose first element is a list of FunctionParameter structs * defining the agg's arguments (both direct and aggregated), and whose second * element is an Integer node with the number of direct args, or -1 if this * isn't an ordered-set aggregate. * "parameters" is a list of DefElem representing the agg's definition clauses. */ ObjectAddress DefineAggregate(List *name, List *args, bool oldstyle, List *parameters, const char *queryString) { char *aggName; Oid aggNamespace; AclResult aclresult; char aggKind = AGGKIND_NORMAL; List *transfuncName = NIL; List *finalfuncName = NIL; List *combinefuncName = NIL; List *serialfuncName = NIL; List *deserialfuncName = NIL; List *mtransfuncName = NIL; List *minvtransfuncName = NIL; List *mfinalfuncName = NIL; bool finalfuncExtraArgs = false; bool mfinalfuncExtraArgs = false; List *sortoperatorName = NIL; TypeName *baseType = NULL; TypeName *transType = NULL; TypeName *serialType = NULL; TypeName *mtransType = NULL; int32 transSpace = 0; int32 mtransSpace = 0; char *initval = NULL; char *minitval = NULL; char *parallel = NULL; int numArgs; int numDirectArgs = 0; oidvector *parameterTypes; ArrayType *allParameterTypes; ArrayType *parameterModes; ArrayType *parameterNames; List *parameterDefaults; Oid variadicArgType; Oid transTypeId; Oid serialTypeId = InvalidOid; Oid mtransTypeId = InvalidOid; char transTypeType; char mtransTypeType = 0; char proparallel = PROPARALLEL_UNSAFE; ListCell *pl; /* Convert list of names to a name and namespace */ aggNamespace = QualifiedNameGetCreationNamespace(name, &aggName); /* Check we have creation rights in target namespace */ aclresult = pg_namespace_aclcheck(aggNamespace, GetUserId(), ACL_CREATE); if (aclresult != ACLCHECK_OK) aclcheck_error(aclresult, ACL_KIND_NAMESPACE, get_namespace_name(aggNamespace)); /* Deconstruct the output of the aggr_args grammar production */ if (!oldstyle) { Assert(list_length(args) == 2); numDirectArgs = intVal(lsecond(args)); if (numDirectArgs >= 0) aggKind = AGGKIND_ORDERED_SET; else numDirectArgs = 0; args = (List *) linitial(args); } /* Examine aggregate's definition clauses */ foreach(pl, parameters) { DefElem *defel = (DefElem *) lfirst(pl); /* * sfunc1, stype1, and initcond1 are accepted as obsolete spellings * for sfunc, stype, initcond. */ if (pg_strcasecmp(defel->defname, "sfunc") == 0) transfuncName = defGetQualifiedName(defel); else if (pg_strcasecmp(defel->defname, "sfunc1") == 0) transfuncName = defGetQualifiedName(defel); else if (pg_strcasecmp(defel->defname, "finalfunc") == 0) finalfuncName = defGetQualifiedName(defel); else if (pg_strcasecmp(defel->defname, "combinefunc") == 0) combinefuncName = defGetQualifiedName(defel); else if (pg_strcasecmp(defel->defname, "serialfunc") == 0) serialfuncName = defGetQualifiedName(defel); else if (pg_strcasecmp(defel->defname, "deserialfunc") == 0) deserialfuncName = defGetQualifiedName(defel); else if (pg_strcasecmp(defel->defname, "msfunc") == 0) mtransfuncName = defGetQualifiedName(defel); else if (pg_strcasecmp(defel->defname, "minvfunc") == 0) minvtransfuncName = defGetQualifiedName(defel); else if (pg_strcasecmp(defel->defname, "mfinalfunc") == 0) mfinalfuncName = defGetQualifiedName(defel); else if (pg_strcasecmp(defel->defname, "finalfunc_extra") == 0) finalfuncExtraArgs = defGetBoolean(defel); else if (pg_strcasecmp(defel->defname, "mfinalfunc_extra") == 0) mfinalfuncExtraArgs = defGetBoolean(defel); else if (pg_strcasecmp(defel->defname, "sortop") == 0) sortoperatorName = defGetQualifiedName(defel); else if (pg_strcasecmp(defel->defname, "basetype") == 0) baseType = defGetTypeName(defel); else if (pg_strcasecmp(defel->defname, "hypothetical") == 0) { if (defGetBoolean(defel)) { if (aggKind == AGGKIND_NORMAL) ereport(ERROR, (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION), errmsg("only ordered-set aggregates can be hypothetical"))); aggKind = AGGKIND_HYPOTHETICAL; } } else if (pg_strcasecmp(defel->defname, "stype") == 0) transType = defGetTypeName(defel); else if (pg_strcasecmp(defel->defname, "serialtype") == 0) serialType = defGetTypeName(defel); else if (pg_strcasecmp(defel->defname, "stype1") == 0) transType = defGetTypeName(defel); else if (pg_strcasecmp(defel->defname, "sspace") == 0) transSpace = defGetInt32(defel); else if (pg_strcasecmp(defel->defname, "mstype") == 0) mtransType = defGetTypeName(defel); else if (pg_strcasecmp(defel->defname, "msspace") == 0) mtransSpace = defGetInt32(defel); else if (pg_strcasecmp(defel->defname, "initcond") == 0) initval = defGetString(defel); else if (pg_strcasecmp(defel->defname, "initcond1") == 0) initval = defGetString(defel); else if (pg_strcasecmp(defel->defname, "minitcond") == 0) minitval = defGetString(defel); else if (pg_strcasecmp(defel->defname, "parallel") == 0) parallel = defGetString(defel); else ereport(WARNING, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("aggregate attribute \"%s\" not recognized", defel->defname))); }