/// <summary> /// Enumerates all instructions and eliminates floating point constants from them. /// </summary> /// <param name="ctx">The context.</param> /// <param name="ctxEpilogue">The context of the epilogue.</param> private void ProcessInstructions(Context ctx, Context ctxEpilogue) { // Current constant operand ConstantOperand co = null; for (; !ctx.EndOfInstruction; ctx.GotoNext()) { // A constant may only appear on the right side of an expression, so we ignore constants in // result - there should never be one there. foreach (Operand op in ctx.Operands) { co = op as ConstantOperand; if (co != null && IsLargeConstant(co)) { // Move the constant out of the code stream and place it right after the code. ctxEpilogue.AppendInstruction(CPUx86.Instruction.LiteralInstruction); ctxEpilogue.LiteralData = new IR.LiteralData(ctx.Label, co.Type, co.Value); op.Replace(((ctxEpilogue.Instruction) as CPUx86.LiteralInstruction).CreateOperand(ctxEpilogue), InstructionSet); _constantRemoved = true; } } } }
/// <summary> /// Replaces the instrinsic call site /// </summary> /// <param name="context">The context.</param> /// <param name="typeSystem">The type system.</param> public void ReplaceIntrinsicCall(Context context, ITypeSystem typeSystem) { Context loadContext = new Context(context.InstructionSet, context.Operand1.Definitions[0]); ConstantOperand op1 = loadContext.Operand1 as ConstantOperand; if (op1 == null) { throw new InvalidOperationException(); } int irq = -1; object obj = op1.Value; if ((obj is int) || (obj is uint)) { irq = (int)obj; } else if (obj is sbyte) { irq = (sbyte)obj; } if ((irq > 256) || (irq < 0)) { throw new InvalidOperationException(); } SigType PTR = new SigType(CilElementType.Ptr); context.SetInstruction(IR.Instruction.MoveInstruction, context.Result, new SymbolOperand(PTR, @"Mosa.Tools.Compiler.LinkerGenerated.<$>InterruptISR" + irq.ToString() + "()")); }
/// <summary> /// Determines whether the value is zero. /// </summary> /// <param name="cilElementType">Type of the cil element.</param> /// <param name="constantOperand">The constant operand.</param> /// <returns> /// <c>true</c> if the value is zero; otherwise, <c>false</c>. /// </returns> private static bool IsValueZero(Metadata.CilElementType cilElementType, ConstantOperand constantOperand) { switch (cilElementType) { case Metadata.CilElementType.Char: goto case Metadata.CilElementType.U2; case Metadata.CilElementType.U1: return((byte)(constantOperand.Value) == 0); case Metadata.CilElementType.U2: return((ushort)(constantOperand.Value) == 0); case Metadata.CilElementType.U4: return((int)(constantOperand.Value) == 0); case Metadata.CilElementType.I1: return((sbyte)(constantOperand.Value) == 0); case Metadata.CilElementType.I2: return((short)(constantOperand.Value) == 0); case Metadata.CilElementType.I4: return((int)(constantOperand.Value) == 0); case Metadata.CilElementType.R4: return((float)(constantOperand.Value) == 0); case Metadata.CilElementType.R8: return((double)(constantOperand.Value) == 0); case Metadata.CilElementType.I: goto case Metadata.CilElementType.I4; case Metadata.CilElementType.U: goto case Metadata.CilElementType.U4; default: goto case Metadata.CilElementType.I4; } }
/// <summary> /// Creates a CustomerFeed that will associate the data holder's Feed with /// the ad customizer placeholder type. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="dataHolder">The data holder that contains metadata about /// the customizer Feed.</param> private static void CreateCustomerFeed(AdWordsUser user, CustomizersDataHolder dataHolder) { // Get the CustomerFeedService. CustomerFeedService customerFeedService = (CustomerFeedService)user.GetService( AdWordsService.v201406.CustomerFeedService); CustomerFeed customerFeed = new CustomerFeed(); customerFeed.feedId = dataHolder.FeedId; customerFeed.placeholderTypes = new int[] { PLACEHOLDER_AD_CUSTOMIZER }; // Create a matching function that will always evaluate to true. Function customerMatchingFunction = new Function(); ConstantOperand constOperand = new ConstantOperand(); constOperand.type = ConstantOperandConstantType.BOOLEAN; constOperand.booleanValue = true; customerMatchingFunction.lhsOperand = new FunctionArgumentOperand[] { constOperand }; customerMatchingFunction.@operator = FunctionOperator.IDENTITY; customerFeed.matchingFunction = customerMatchingFunction; // Create an operation to add the customer feed. CustomerFeedOperation customerFeedOperation = new CustomerFeedOperation(); customerFeedOperation.operand = customerFeed; customerFeedOperation.@operator = Operator.ADD; CustomerFeed addedCustomerFeed = customerFeedService.mutate( new CustomerFeedOperation[] { customerFeedOperation }).value[0]; Console.WriteLine("Customer feed for feed ID {0} was added.", addedCustomerFeed.feedId); }
public override bool Equals(object obj) { return(obj switch { T value => this.Equals(value), ConstantOperand <T> operand => this.Equals(operand), _ => false, });
/// <summary> /// /// </summary> /// <param name="ctx"></param> /// <param name="emitter"></param> protected override void Emit(Context ctx, MachineCodeEmitter emitter) { OpCode opCode = ComputeOpCode(ctx.Result, ctx.Operand1, ctx.Operand2); if (ctx.Operand2 is ConstantOperand) { ConstantOperand op = ctx.Operand2 as ConstantOperand; op = new ConstantOperand(new Mosa.Runtime.Metadata.Signatures.SigType(Mosa.Runtime.Metadata.CilElementType.U1), op.Value); emitter.Emit(opCode, ctx.Result, ctx.Operand1, op); } else { emitter.Emit(opCode, ctx.Result, ctx.Operand1, ctx.Operand2); } }
/// <summary> /// Performs stage specific processing on the compiler context. /// </summary> public void Run() { bool remove = false; foreach (BasicBlock block in BasicBlocks) { for (Context ctx = new Context(InstructionSet, block); !ctx.EndOfInstruction; ctx.GotoNext()) { if (ctx.Instruction is IR.MoveInstruction || ctx.Instruction is CIL.StlocInstruction) { if (ctx.Operand1 is ConstantOperand) { // HACK: We can't track a constant through a register, so we keep those moves if (ctx.Result is StackOperand) { Debug.Assert(ctx.Result.Definitions.Count == 1, @"Operand defined multiple times. Instruction stream not in SSA form!"); ctx.Result.Replace(ctx.Operand1, InstructionSet); remove = true; } } } else if (ctx.Instruction is IR.PhiInstruction) { IR.PhiInstruction phi = (IR.PhiInstruction)ctx.Instruction; ConstantOperand co = ctx.Operand2 as ConstantOperand; List <BasicBlock> blocks = ctx.Other as List <BasicBlock>; // FIXME PG / ctx has moved if (co != null && blocks.Count == 1) { // We can remove the phi, as it is only defined once // HACK: We can't track a constant through a register, so we keep those moves if (!ctx.Result.IsRegister) { Debug.Assert(ctx.Result.Definitions.Count == 1, @"Operand defined multiple times. Instruction stream not in SSA form!"); ctx.Result.Replace(co, InstructionSet); remove = true; } } } // Shall we remove this instruction? if (remove) { ctx.Remove(); remove = false; } } } }
/// <summary> /// This function emits a constant variable into the read-only data section. /// </summary> /// <param name="op">The operand to emit as a constant.</param> /// <returns>An operand, which represents the reference to the read-only constant.</returns> /// <remarks> /// This function checks if the given operand needs to be moved into the read-only data /// section of the executable. For x86 this concerns only floating point operands, as these /// can't be specified in inline assembly.<para/> /// This function checks if the given operand needs to be moved and rewires the operand, if /// it must be moved. /// </remarks> protected Operand EmitConstant(Operand op) { ConstantOperand cop = op as ConstantOperand; if (cop != null && (cop.StackType == StackTypeCode.F || cop.StackType == StackTypeCode.Int64)) { int size, alignment; architecture.GetTypeRequirements(cop.Type, out size, out alignment); string name = String.Format("C_{0}", Guid.NewGuid()); using (Stream stream = methodCompiler.Linker.Allocate(name, SectionKind.ROData, size, alignment)) { byte[] buffer; switch (cop.Type.Type) { case CilElementType.R4: buffer = LittleEndianBitConverter.GetBytes((float)cop.Value); break; case CilElementType.R8: buffer = LittleEndianBitConverter.GetBytes((double)cop.Value); break; case CilElementType.I8: buffer = LittleEndianBitConverter.GetBytes((long)cop.Value); break; case CilElementType.U8: buffer = LittleEndianBitConverter.GetBytes((ulong)cop.Value); break; default: throw new NotSupportedException(); } stream.Write(buffer, 0, buffer.Length); } // FIXME: Attach the label operand to the linker symbol // FIXME: Rename the operand to SymbolOperand // FIXME: Use the provided name to link LabelOperand lop = new LabelOperand(cop.Type, name); op = lop; } return(op); }
/// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="gmbEmailAddress">The email address for Google My Business /// account.</param> /// <param name="gmbAccessToken">The OAuth2 access token for Google /// My Business account.</param> /// <param name="businessAccountIdentifier">The account identifier for /// Google My Business account.</param> public void Run(AdWordsUser user, string gmbEmailAddress, string gmbAccessToken, string businessAccountIdentifier) { FeedService feedService = (FeedService)user.GetService(AdWordsService.v201502.FeedService); CustomerFeedService customerFeedService = (CustomerFeedService)user.GetService( AdWordsService.v201502.CustomerFeedService); // Create a feed that will sync to the Google My Business account // specified by gmbEmailAddress. Do not add FeedAttributes to this object, // as AdWords will add them automatically because this will be a // system generated feed. Feed gmbFeed = new Feed(); gmbFeed.name = String.Format("Google My Business feed #{0}", ExampleUtilities.GetRandomString()); PlacesLocationFeedData feedData = new PlacesLocationFeedData(); feedData.emailAddress = gmbEmailAddress; feedData.businessAccountIdentifier = businessAccountIdentifier; OAuthInfo oAuthInfo = new OAuthInfo(); oAuthInfo.httpMethod = "GET"; // Permissions for the AdWords API scope will also cover GMB. oAuthInfo.httpRequestUrl = user.Config.GetDefaultOAuth2Scope(); oAuthInfo.httpAuthorizationHeader = string.Format("Bearer {0}", gmbAccessToken); feedData.oAuthInfo = oAuthInfo; gmbFeed.systemFeedGenerationData = feedData; // Since this feed's feed items will be managed by AdWords, // you must set its origin to ADWORDS. gmbFeed.origin = FeedOrigin.ADWORDS; // Create an operation to add the feed. FeedOperation feedOperation = new FeedOperation(); feedOperation.operand = gmbFeed; feedOperation.@operator = Operator.ADD; try { // Add the feed. Since it is a system generated feed, AdWords will // automatically: // 1. Set up the FeedAttributes on the feed. // 2. Set up a FeedMapping that associates the FeedAttributes of the // feed with the placeholder fields of the LOCATION placeholder // type. FeedReturnValue addFeedResult = feedService.mutate(new FeedOperation[] { feedOperation }); Feed addedFeed = addFeedResult.value[0]; Console.WriteLine("Added GMB feed with ID {0}", addedFeed.id); // Add a CustomerFeed that associates the feed with this customer for // the LOCATION placeholder type. CustomerFeed customerFeed = new CustomerFeed(); customerFeed.feedId = addedFeed.id; customerFeed.placeholderTypes = new int[] { PLACEHOLDER_LOCATION }; // Create a matching function that will always evaluate to true. Function customerMatchingFunction = new Function(); ConstantOperand constOperand = new ConstantOperand(); constOperand.type = ConstantOperandConstantType.BOOLEAN; constOperand.booleanValue = true; customerMatchingFunction.lhsOperand = new FunctionArgumentOperand[] { constOperand }; customerMatchingFunction.@operator = FunctionOperator.IDENTITY; customerFeed.matchingFunction = customerMatchingFunction; // Create an operation to add the customer feed. CustomerFeedOperation customerFeedOperation = new CustomerFeedOperation(); customerFeedOperation.operand = customerFeed; customerFeedOperation.@operator = Operator.ADD; // After the completion of the Feed ADD operation above the added feed // will not be available for usage in a CustomerFeed until the sync // between the AdWords and GMB accounts completes. The loop below // will retry adding the CustomerFeed up to ten times with an // exponential back-off policy. CustomerFeed addedCustomerFeed = null; AdWordsAppConfig config = new AdWordsAppConfig(); config.RetryCount = 10; ErrorHandler errorHandler = new ErrorHandler(config); do { try { CustomerFeedReturnValue customerFeedResult = customerFeedService.mutate(new CustomerFeedOperation[] { customerFeedOperation }); addedCustomerFeed = customerFeedResult.value[0]; Console.WriteLine("Added CustomerFeed for feed ID {0} and placeholder type {1}", addedCustomerFeed.feedId, addedCustomerFeed.placeholderTypes[0]); break; } catch (AdWordsApiException e) { ApiException apiException = (ApiException)e.ApiException; foreach (ApiError error in apiException.errors) { if (error is CustomerFeedError) { if ((error as CustomerFeedError).reason == CustomerFeedErrorReason.MISSING_FEEDMAPPING_FOR_PLACEHOLDER_TYPE) { errorHandler.DoExponentialBackoff(); errorHandler.IncrementRetriedAttempts(); } else { throw; } } } } } while (errorHandler.HaveMoreRetryAttemptsLeft()); // OPTIONAL: Create a CampaignFeed to specify which FeedItems to use at // the Campaign level. This will be similar to the CampaignFeed in the // AddSiteLinks example, except you can also filter based on the // business name and category of each FeedItem by using a // FeedAttributeOperand in your matching function. // OPTIONAL: Create an AdGroupFeed for even more fine grained control // over which feed items are used at the AdGroup level. } catch (Exception e) { throw new System.ApplicationException("Failed to create customer feed.", e); } }
public bool Equals(ConstantOperand <T> other) => other != null && object.Equals(this.Value, other.Value);
/// <summary> /// Decodes the specified instruction. /// </summary> /// <param name="ctx">The context.</param> /// <param name="decoder">The instruction decoder, which holds the code stream.</param> public override void Decode(Context ctx, IInstructionDecoder decoder) { // Decode base classes first base.Decode(ctx, decoder); ConstantOperand constantValueOperand; // Opcode specific handling switch (opcode) { case OpCode.Ldc_i4: { int i = decoder.DecodeInt(); constantValueOperand = new ConstantOperand(new SigType(CilElementType.I4), i); } break; case OpCode.Ldc_i4_s: { sbyte sb = decoder.DecodeSByte(); constantValueOperand = new ConstantOperand(new SigType(CilElementType.I4), sb); } break; case OpCode.Ldc_i8: { long l = decoder.DecodeLong(); constantValueOperand = new ConstantOperand(new SigType(CilElementType.I8), l); } break; case OpCode.Ldc_r4: { float f = decoder.DecodeFloat(); constantValueOperand = new ConstantOperand(new SigType(CilElementType.R4), f); } break; case OpCode.Ldc_r8: { double d = decoder.DecodeDouble(); constantValueOperand = new ConstantOperand(new SigType(CilElementType.R8), d); } break; case OpCode.Ldnull: constantValueOperand = ConstantOperand.GetNull(); break; case OpCode.Ldc_i4_0: constantValueOperand = ConstantOperand.FromValue(0); break; case OpCode.Ldc_i4_1: constantValueOperand = ConstantOperand.FromValue(1); break; case OpCode.Ldc_i4_2: constantValueOperand = ConstantOperand.FromValue(2); break; case OpCode.Ldc_i4_3: constantValueOperand = ConstantOperand.FromValue(3); break; case OpCode.Ldc_i4_4: constantValueOperand = ConstantOperand.FromValue(4); break; case OpCode.Ldc_i4_5: constantValueOperand = ConstantOperand.FromValue(5); break; case OpCode.Ldc_i4_6: constantValueOperand = ConstantOperand.FromValue(6); break; case OpCode.Ldc_i4_7: constantValueOperand = ConstantOperand.FromValue(7); break; case OpCode.Ldc_i4_8: constantValueOperand = ConstantOperand.FromValue(8); break; case OpCode.Ldc_i4_m1: constantValueOperand = ConstantOperand.FromValue(-1); break; default: throw new System.NotImplementedException(); } ctx.Operand1 = constantValueOperand; ctx.Result = decoder.Compiler.CreateTemporary(constantValueOperand.Type); }
/// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="campaignId">Id of the campaign to which targeting criteria /// are added.</param> /// <param name="feedId">ID of a feed that has been configured for location /// targeting, meaning it has an ENABLED FeedMapping with criterionType of /// 77. Feeds linked to a GMB account automatically have this FeedMapping. /// If you don't have such a feed, set this value to null.</param> public void Run(AdWordsUser user, long campaignId, long?feedId) { // Get the CampaignCriterionService. CampaignCriterionService campaignCriterionService = (CampaignCriterionService)user.GetService( AdWordsService.v201506.CampaignCriterionService); // Create language criteria. // See http://code.google.com/apis/adwords/docs/appendix/languagecodes.html // for a detailed list of language codes. Language language1 = new Language(); language1.id = 1002; // French CampaignCriterion languageCriterion1 = new CampaignCriterion(); languageCriterion1.campaignId = campaignId; languageCriterion1.criterion = language1; Language language2 = new Language(); language2.id = 1005; // Japanese CampaignCriterion languageCriterion2 = new CampaignCriterion(); languageCriterion2.campaignId = campaignId; languageCriterion2.criterion = language2; // Target Tier 3 income group near Miami, Florida. LocationGroups incomeLocationGroups = new LocationGroups(); IncomeOperand incomeOperand = new IncomeOperand(); // Tiers are numbered 1-10, and represent 10% segments of earners. // For example, TIER_1 is the top 10%, TIER_2 is the 80-90%, etc. // Tiers 6 through 10 are grouped into TIER_6_TO_10. incomeOperand.tier = IncomeTier.TIER_3; GeoTargetOperand geoTargetOperand1 = new GeoTargetOperand(); geoTargetOperand1.locations = new long[] { 1015116 }; // Miami, FL. incomeLocationGroups.matchingFunction = new Function(); incomeLocationGroups.matchingFunction.lhsOperand = new FunctionArgumentOperand[] { incomeOperand }; incomeLocationGroups.matchingFunction.@operator = FunctionOperator.AND; incomeLocationGroups.matchingFunction.rhsOperand = new FunctionArgumentOperand[] { geoTargetOperand1 }; CampaignCriterion locationGroupCriterion1 = new CampaignCriterion(); locationGroupCriterion1.campaignId = campaignId; locationGroupCriterion1.criterion = incomeLocationGroups; // Target places of interest near Downtown Miami, Florida. LocationGroups interestLocationGroups = new LocationGroups(); PlacesOfInterestOperand placesOfInterestOperand = new PlacesOfInterestOperand(); placesOfInterestOperand.category = PlacesOfInterestOperandCategory.DOWNTOWN; GeoTargetOperand geoTargetOperand2 = new GeoTargetOperand(); geoTargetOperand2.locations = new long[] { 1015116 }; // Miami, FL. interestLocationGroups.matchingFunction = new Function(); interestLocationGroups.matchingFunction.lhsOperand = new FunctionArgumentOperand[] { placesOfInterestOperand }; interestLocationGroups.matchingFunction.@operator = FunctionOperator.AND; interestLocationGroups.matchingFunction.rhsOperand = new FunctionArgumentOperand[] { geoTargetOperand2 }; CampaignCriterion locationGroupCriterion2 = new CampaignCriterion(); locationGroupCriterion2.campaignId = campaignId; locationGroupCriterion2.criterion = interestLocationGroups; CampaignCriterion locationGroupCriterion3 = new CampaignCriterion(); if (feedId.HasValue) { // Distance targeting. Area of 10 miles around targets above. ConstantOperand radius = new ConstantOperand(); radius.type = ConstantOperandConstantType.DOUBLE; radius.unit = ConstantOperandUnit.MILES; radius.doubleValue = 10.0; LocationExtensionOperand distance = new LocationExtensionOperand(); distance.radius = radius; LocationGroups radiusLocationGroups = new LocationGroups(); radiusLocationGroups.matchingFunction = new Function(); radiusLocationGroups.matchingFunction.@operator = FunctionOperator.IDENTITY; radiusLocationGroups.matchingFunction.lhsOperand = new FunctionArgumentOperand[] { distance }; // FeedID should be the ID of a feed that has been configured for location // targeting, meaning it has an ENABLED FeedMapping with criterionType of // 77. Feeds linked to a GMB account automatically have this FeedMapping. radiusLocationGroups.feedId = feedId.Value; locationGroupCriterion3.campaignId = campaignId; locationGroupCriterion3.criterion = radiusLocationGroups; } // Create location criteria. // See http://code.google.com/apis/adwords/docs/appendix/countrycodes.html // for a detailed list of country codes. Location location1 = new Location(); location1.id = 2840; // USA CampaignCriterion locationCriterion1 = new CampaignCriterion(); locationCriterion1.campaignId = campaignId; locationCriterion1.criterion = location1; Location location2 = new Location(); location2.id = 2392; // Japan CampaignCriterion locationCriterion2 = new CampaignCriterion(); locationCriterion2.campaignId = campaignId; locationCriterion2.criterion = location2; // Add a negative campaign keyword. NegativeCampaignCriterion negativeCriterion = new NegativeCampaignCriterion(); negativeCriterion.campaignId = campaignId; Keyword keyword = new Keyword(); keyword.matchType = KeywordMatchType.BROAD; keyword.text = "jupiter cruise"; negativeCriterion.criterion = keyword; List <CampaignCriterion> criteria = new List <CampaignCriterion>( new CampaignCriterion[] { languageCriterion1, languageCriterion2, locationCriterion1, locationCriterion2, negativeCriterion, locationGroupCriterion1, locationGroupCriterion2 }); if (feedId.HasValue) { criteria.Add(locationGroupCriterion3); } List <CampaignCriterionOperation> operations = new List <CampaignCriterionOperation>(); foreach (CampaignCriterion criterion in criteria) { CampaignCriterionOperation operation = new CampaignCriterionOperation(); operation.@operator = Operator.ADD; operation.operand = criterion; operations.Add(operation); } try { // Set the campaign targets. CampaignCriterionReturnValue retVal = campaignCriterionService.mutate(operations.ToArray()); if (retVal != null && retVal.value != null) { // Display campaign targets. foreach (CampaignCriterion criterion in retVal.value) { Console.WriteLine("Campaign criteria of type '{0}' was set to campaign with" + " id = '{1}'.", criterion.criterion.CriterionType, criterion.campaignId); } } } catch (Exception ex) { throw new System.ApplicationException("Failed to set Campaign criteria.", ex); } }
public void StoreField(ConstantOperand<string> operand) { Emit(new Instruction(InstructionType.StFld, operand)); }
public void LoadField(ConstantOperand<string> operand) { Emit(new Instruction(InstructionType.LdFld, operand)); }
/// <summary> /// Determines if the given constant operand is a large constant. /// </summary> /// <remarks> /// Only constants, which have special types or do not fit into an immediate argument /// are large and are moved to memory. /// </remarks> /// <param name="co">The constant operand to check.</param> /// <returns>True if the constant is large and needs to be moved to a literal.</returns> private static bool IsLargeConstant(ConstantOperand co) { return(Array.IndexOf <CilElementType> (_largeCilTypes, co.Type.Type) != -1); }
/// <summary> /// Add a CustomerFeed that associates the feed with this customer for /// the LOCATION placeholder type. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="feed">The GMB feed.</param> void AddCustomerFeed(AdWordsUser user, Feed feed) { using (CustomerFeedService customerFeedService = (CustomerFeedService)user.GetService( AdWordsService.v201710.CustomerFeedService)) { // Add a CustomerFeed that associates the feed with this customer for // the LOCATION placeholder type. CustomerFeed customerFeed = new CustomerFeed(); customerFeed.feedId = feed.id; customerFeed.placeholderTypes = new int[] { PLACEHOLDER_LOCATION }; // Create a matching function that will always evaluate to true. Function customerMatchingFunction = new Function(); ConstantOperand constOperand = new ConstantOperand(); constOperand.type = ConstantOperandConstantType.BOOLEAN; constOperand.booleanValue = true; customerMatchingFunction.lhsOperand = new FunctionArgumentOperand[] { constOperand }; customerMatchingFunction.@operator = FunctionOperator.IDENTITY; customerFeed.matchingFunction = customerMatchingFunction; // Create an operation to add the customer feed. CustomerFeedOperation customerFeedOperation = new CustomerFeedOperation(); customerFeedOperation.operand = customerFeed; customerFeedOperation.@operator = Operator.ADD; // After the completion of the Feed ADD operation above the added feed // will not be available for usage in a CustomerFeed until the sync // between the AdWords and GMB accounts completes. The loop below // will retry adding the CustomerFeed up to ten times with an // exponential back-off policy. CustomerFeed addedCustomerFeed = null; AdWordsAppConfig config = new AdWordsAppConfig(); config.RetryCount = 10; ErrorHandler errorHandler = new ErrorHandler(config); try { do { try { CustomerFeedReturnValue customerFeedResult = customerFeedService.mutate( new CustomerFeedOperation[] { customerFeedOperation }); addedCustomerFeed = customerFeedResult.value[0]; Console.WriteLine("Added CustomerFeed for feed ID {0} and placeholder type {1}", addedCustomerFeed.feedId, addedCustomerFeed.placeholderTypes[0]); break; } catch (AdWordsApiException e) { ApiException apiException = (ApiException)e.ApiException; foreach (ApiError error in apiException.errors) { if (error is CustomerFeedError) { if ((error as CustomerFeedError).reason == CustomerFeedErrorReason.MISSING_FEEDMAPPING_FOR_PLACEHOLDER_TYPE) { errorHandler.DoExponentialBackoff(); errorHandler.IncrementRetriedAttempts(); } else { throw; } } } } } while (errorHandler.HaveMoreRetryAttemptsLeft()); // OPTIONAL: Create a CampaignFeed to specify which FeedItems to use at // the Campaign level. This will be similar to the CampaignFeed in the // AddSiteLinks example, except you can also filter based on the // business name and category of each FeedItem by using a // FeedAttributeOperand in your matching function. // OPTIONAL: Create an AdGroupFeed for even more fine grained control // over which feed items are used at the AdGroup level. } catch (Exception e) { throw new System.ApplicationException("Failed to create customer feed.", e); } } }
/// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="campaignId">Id of the campaign to which targeting criteria /// are added.</param> /// <param name="feedId">ID of a feed that has been configured for location /// targeting, meaning it has an ENABLED FeedMapping with criterionType of /// 77. Feeds linked to a GMB account automatically have this FeedMapping. /// If you don't have such a feed, set this value to null.</param> public void Run(AdWordsUser user, long campaignId, long? feedId) { // Get the CampaignCriterionService. CampaignCriterionService campaignCriterionService = (CampaignCriterionService) user.GetService( AdWordsService.v201509.CampaignCriterionService); // Create language criteria. // See http://code.google.com/apis/adwords/docs/appendix/languagecodes.html // for a detailed list of language codes. Language language1 = new Language(); language1.id = 1002; // French CampaignCriterion languageCriterion1 = new CampaignCriterion(); languageCriterion1.campaignId = campaignId; languageCriterion1.criterion = language1; Language language2 = new Language(); language2.id = 1005; // Japanese CampaignCriterion languageCriterion2 = new CampaignCriterion(); languageCriterion2.campaignId = campaignId; languageCriterion2.criterion = language2; // Target Tier 3 income group near Miami, Florida. LocationGroups incomeLocationGroups = new LocationGroups(); IncomeOperand incomeOperand = new IncomeOperand(); // Tiers are numbered 1-10, and represent 10% segments of earners. // For example, TIER_1 is the top 10%, TIER_2 is the 80-90%, etc. // Tiers 6 through 10 are grouped into TIER_6_TO_10. incomeOperand.tier = IncomeTier.TIER_3; GeoTargetOperand geoTargetOperand1 = new GeoTargetOperand(); geoTargetOperand1.locations = new long[] { 1015116 }; // Miami, FL. incomeLocationGroups.matchingFunction = new Function(); incomeLocationGroups.matchingFunction.lhsOperand = new FunctionArgumentOperand[] { incomeOperand }; incomeLocationGroups.matchingFunction.@operator = FunctionOperator.AND; incomeLocationGroups.matchingFunction.rhsOperand = new FunctionArgumentOperand[] { geoTargetOperand1 }; CampaignCriterion locationGroupCriterion1 = new CampaignCriterion(); locationGroupCriterion1.campaignId = campaignId; locationGroupCriterion1.criterion = incomeLocationGroups; // Target places of interest near Downtown Miami, Florida. LocationGroups interestLocationGroups = new LocationGroups(); PlacesOfInterestOperand placesOfInterestOperand = new PlacesOfInterestOperand(); placesOfInterestOperand.category = PlacesOfInterestOperandCategory.DOWNTOWN; GeoTargetOperand geoTargetOperand2 = new GeoTargetOperand(); geoTargetOperand2.locations = new long[] { 1015116 }; // Miami, FL. interestLocationGroups.matchingFunction = new Function(); interestLocationGroups.matchingFunction.lhsOperand = new FunctionArgumentOperand[] { placesOfInterestOperand }; interestLocationGroups.matchingFunction.@operator = FunctionOperator.AND; interestLocationGroups.matchingFunction.rhsOperand = new FunctionArgumentOperand[] { geoTargetOperand2 }; CampaignCriterion locationGroupCriterion2 = new CampaignCriterion(); locationGroupCriterion2.campaignId = campaignId; locationGroupCriterion2.criterion = interestLocationGroups; CampaignCriterion locationGroupCriterion3 = new CampaignCriterion(); if (feedId.HasValue) { // Distance targeting. Area of 10 miles around targets above. ConstantOperand radius = new ConstantOperand(); radius.type = ConstantOperandConstantType.DOUBLE; radius.unit = ConstantOperandUnit.MILES; radius.doubleValue = 10.0; LocationExtensionOperand distance = new LocationExtensionOperand(); distance.radius = radius; LocationGroups radiusLocationGroups = new LocationGroups(); radiusLocationGroups.matchingFunction = new Function(); radiusLocationGroups.matchingFunction.@operator = FunctionOperator.IDENTITY; radiusLocationGroups.matchingFunction.lhsOperand = new FunctionArgumentOperand[] { distance }; // FeedID should be the ID of a feed that has been configured for location // targeting, meaning it has an ENABLED FeedMapping with criterionType of // 77. Feeds linked to a GMB account automatically have this FeedMapping. radiusLocationGroups.feedId = feedId.Value; locationGroupCriterion3.campaignId = campaignId; locationGroupCriterion3.criterion = radiusLocationGroups; } // Create location criteria. // See http://code.google.com/apis/adwords/docs/appendix/countrycodes.html // for a detailed list of country codes. Location location1 = new Location(); location1.id = 2840; // USA CampaignCriterion locationCriterion1 = new CampaignCriterion(); locationCriterion1.campaignId = campaignId; locationCriterion1.criterion = location1; Location location2 = new Location(); location2.id = 2392; // Japan CampaignCriterion locationCriterion2 = new CampaignCriterion(); locationCriterion2.campaignId = campaignId; locationCriterion2.criterion = location2; // Add a negative campaign keyword. NegativeCampaignCriterion negativeCriterion = new NegativeCampaignCriterion(); negativeCriterion.campaignId = campaignId; Keyword keyword = new Keyword(); keyword.matchType = KeywordMatchType.BROAD; keyword.text = "jupiter cruise"; negativeCriterion.criterion = keyword; List<CampaignCriterion> criteria = new List<CampaignCriterion>( new CampaignCriterion[] {languageCriterion1, languageCriterion2, locationCriterion1, locationCriterion2, negativeCriterion, locationGroupCriterion1, locationGroupCriterion2}); if (feedId.HasValue) { criteria.Add(locationGroupCriterion3); } List<CampaignCriterionOperation> operations = new List<CampaignCriterionOperation>(); foreach (CampaignCriterion criterion in criteria) { CampaignCriterionOperation operation = new CampaignCriterionOperation(); operation.@operator = Operator.ADD; operation.operand = criterion; operations.Add(operation); } try { // Set the campaign targets. CampaignCriterionReturnValue retVal = campaignCriterionService.mutate(operations.ToArray()); if (retVal != null && retVal.value != null) { // Display campaign targets. foreach (CampaignCriterion criterion in retVal.value) { Console.WriteLine("Campaign criteria of type '{0}' was set to campaign with" + " id = '{1}'.", criterion.criterion.CriterionType, criterion.campaignId); } } } catch (Exception e) { throw new System.ApplicationException("Failed to set Campaign criteria.", e); } }
/// <summary> /// Emits an immediate operand. /// </summary> /// <param name="op">The immediate operand to emit.</param> public void EmitImmediate(Operand op) { byte[] imm = null; if (op is LocalVariableOperand) { // Add the displacement StackOperand so = (StackOperand)op; imm = LittleEndianBitConverter.GetBytes(so.Offset.ToInt32()); } else if (op is LabelOperand) { _literals.Add(new Patch((op as LabelOperand).Label, _codeStream.Position)); imm = new byte[4]; } else if (op is MemoryOperand) { // Add the displacement MemoryOperand mo = (MemoryOperand)op; imm = LittleEndianBitConverter.GetBytes(mo.Offset.ToInt32()); } else if (op is ConstantOperand) { // Add the immediate ConstantOperand co = (ConstantOperand)op; switch (op.Type.Type) { case CilElementType.I: try { imm = LittleEndianBitConverter.GetBytes(Convert.ToInt32(co.Value)); } catch (OverflowException) { imm = LittleEndianBitConverter.GetBytes(Convert.ToUInt32(co.Value)); } break; case CilElementType.I1: //imm = LittleEndianBitConverter.GetBytes(Convert.ToSByte(co.Value)); imm = new byte[1] { Convert.ToByte(co.Value) }; break; case CilElementType.I2: imm = LittleEndianBitConverter.GetBytes(Convert.ToInt16(co.Value)); break; case CilElementType.I4: goto case CilElementType.I; case CilElementType.U1: //imm = LittleEndianBitConverter.GetBytes(Convert.ToByte(co.Value)); imm = new byte[1] { Convert.ToByte(co.Value) }; break; case CilElementType.Char: goto case CilElementType.U2; case CilElementType.U2: imm = LittleEndianBitConverter.GetBytes(Convert.ToUInt16(co.Value)); break; case CilElementType.U4: imm = LittleEndianBitConverter.GetBytes(Convert.ToUInt32(co.Value)); break; case CilElementType.I8: imm = LittleEndianBitConverter.GetBytes(Convert.ToInt64(co.Value)); break; case CilElementType.U8: imm = LittleEndianBitConverter.GetBytes(Convert.ToUInt64(co.Value)); break; case CilElementType.R4: imm = LittleEndianBitConverter.GetBytes(Convert.ToSingle(co.Value)); break; case CilElementType.R8: goto default; default: throw new NotSupportedException(); } } else if (op is RegisterOperand) { // Nothing to do... } else { throw new NotImplementedException(); } // Emit the immediate constant to the code if (null != imm) { _codeStream.Write(imm, 0, imm.Length); } }
/// <summary> /// Decodes the specified instruction. /// </summary> /// <param name="ctx">The context.</param> /// <param name="decoder">The instruction decoder, which holds the code stream.</param> public override void Decode(Context ctx, IInstructionDecoder decoder) { // Decode base classes first base.Decode(ctx, decoder); SigType type; object value; // Opcode specific handling switch (_opcode) { case OpCode.Ldc_i4: { int i; decoder.Decode(out i); type = new SigType(CilElementType.I4); value = i; } break; case OpCode.Ldc_i4_s: { sbyte sb; decoder.Decode(out sb); type = new SigType(CilElementType.I4); value = sb; } break; case OpCode.Ldc_i8: { long l; decoder.Decode(out l); type = new SigType(CilElementType.I8); value = l; } break; case OpCode.Ldc_r4: { float f; decoder.Decode(out f); type = new SigType(CilElementType.R4); value = f; } break; case OpCode.Ldc_r8: { double d; decoder.Decode(out d); type = new SigType(CilElementType.R8); value = d; } break; case OpCode.Ldnull: ctx.Result = ConstantOperand.GetNull(); return; case OpCode.Ldc_i4_0: ctx.Result = ConstantOperand.FromValue(0); return; case OpCode.Ldc_i4_1: ctx.Result = ConstantOperand.FromValue(1); return; case OpCode.Ldc_i4_2: ctx.Result = ConstantOperand.FromValue(2); return; case OpCode.Ldc_i4_3: ctx.Result = ConstantOperand.FromValue(3); return; case OpCode.Ldc_i4_4: ctx.Result = ConstantOperand.FromValue(4); return; case OpCode.Ldc_i4_5: ctx.Result = ConstantOperand.FromValue(5); return; case OpCode.Ldc_i4_6: ctx.Result = ConstantOperand.FromValue(6); return; case OpCode.Ldc_i4_7: ctx.Result = ConstantOperand.FromValue(7); return; case OpCode.Ldc_i4_8: ctx.Result = ConstantOperand.FromValue(8); return; case OpCode.Ldc_i4_m1: ctx.Result = ConstantOperand.FromValue(-1); return; default: throw new NotImplementedException(); } ctx.Result = new ConstantOperand(type, value); ctx.Ignore = true; }
private static void createSiteLinksCampaignFeed(AdWordsUser user, SiteLinksDataHolder siteLinksData, long campaignId) { // Get the CampaignFeedService. CampaignFeedService campaignFeedService = (CampaignFeedService)user.GetService(AdWordsService.v201406.CampaignFeedService); // Map the feed item ids to the campaign using an IN operation. RequestContextOperand feedItemRequestContextOperand = new RequestContextOperand(); feedItemRequestContextOperand.contextType = RequestContextOperandContextType.FEED_ITEM_ID; List <FunctionArgumentOperand> feedItemOperands = new List <FunctionArgumentOperand>(); foreach (long feedItemId in siteLinksData.SiteLinkFeedItemIds) { ConstantOperand feedItemOperand = new ConstantOperand(); feedItemOperand.longValue = feedItemId; feedItemOperand.type = ConstantOperandConstantType.LONG; feedItemOperands.Add(feedItemOperand); } Function feedItemfunction = new Function(); feedItemfunction.lhsOperand = new FunctionArgumentOperand[] { feedItemRequestContextOperand }; feedItemfunction.@operator = FunctionOperator.IN; feedItemfunction.rhsOperand = feedItemOperands.ToArray(); // Optional: to target to a platform, define a function and 'AND' it with // the feed item ID link: RequestContextOperand platformRequestContextOperand = new RequestContextOperand(); platformRequestContextOperand.contextType = RequestContextOperandContextType.DEVICE_PLATFORM; ConstantOperand platformOperand = new ConstantOperand(); platformOperand.stringValue = "Mobile"; platformOperand.type = ConstantOperandConstantType.STRING; Function platformFunction = new Function(); platformFunction.lhsOperand = new FunctionArgumentOperand[] { platformRequestContextOperand }; platformFunction.@operator = FunctionOperator.EQUALS; platformFunction.rhsOperand = new FunctionArgumentOperand[] { platformOperand }; // Combine the two functions using an AND operation. FunctionOperand feedItemFunctionOperand = new FunctionOperand(); feedItemFunctionOperand.value = feedItemfunction; FunctionOperand platformFunctionOperand = new FunctionOperand(); platformFunctionOperand.value = platformFunction; Function combinedFunction = new Function(); combinedFunction.@operator = FunctionOperator.AND; combinedFunction.lhsOperand = new FunctionArgumentOperand[] { feedItemFunctionOperand, platformFunctionOperand }; CampaignFeed campaignFeed = new CampaignFeed(); campaignFeed.feedId = siteLinksData.SiteLinksFeedId; campaignFeed.campaignId = campaignId; campaignFeed.matchingFunction = combinedFunction; // Specifying placeholder types on the CampaignFeed allows the same feed // to be used for different placeholders in different Campaigns. campaignFeed.placeholderTypes = new int[] { PLACEHOLDER_SITELINKS }; CampaignFeedOperation operation = new CampaignFeedOperation(); operation.operand = campaignFeed; operation.@operator = Operator.ADD; CampaignFeedReturnValue result = campaignFeedService.mutate(new CampaignFeedOperation[] { operation }); foreach (CampaignFeed savedCampaignFeed in result.value) { Console.WriteLine("Campaign with ID {0} was associated with feed with ID {1}", savedCampaignFeed.campaignId, savedCampaignFeed.feedId); } }
/// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="gmbEmailAddress">The email address for Google My Business /// account.</param> /// <param name="gmbAccessToken">The OAuth2 access token for Google /// My Business account.</param> /// <param name="businessAccountIdentifier">The account identifier for /// Google My Business account.</param> public void Run(AdWordsUser user, string gmbEmailAddress, string gmbAccessToken, string businessAccountIdentifier) { FeedService feedService = (FeedService) user.GetService(AdWordsService.v201601.FeedService); CustomerFeedService customerFeedService = (CustomerFeedService) user.GetService( AdWordsService.v201601.CustomerFeedService); // Create a feed that will sync to the Google My Business account // specified by gmbEmailAddress. Do not add FeedAttributes to this object, // as AdWords will add them automatically because this will be a // system generated feed. Feed gmbFeed = new Feed(); gmbFeed.name = String.Format("Google My Business feed #{0}", ExampleUtilities.GetRandomString()); PlacesLocationFeedData feedData = new PlacesLocationFeedData(); feedData.emailAddress = gmbEmailAddress; feedData.businessAccountIdentifier = businessAccountIdentifier; // Optional: specify labels to filter Google My Business listings. If // specified, only listings that have any of the labels set are // synchronized into FeedItems. feedData.labelFilters = new string[] { "Stores in New York City" }; OAuthInfo oAuthInfo = new OAuthInfo(); oAuthInfo.httpMethod = "GET"; // Permissions for the AdWords API scope will also cover GMB. oAuthInfo.httpRequestUrl = user.Config.GetDefaultOAuth2Scope(); oAuthInfo.httpAuthorizationHeader = string.Format("Bearer {0}", gmbAccessToken); feedData.oAuthInfo = oAuthInfo; gmbFeed.systemFeedGenerationData = feedData; // Since this feed's feed items will be managed by AdWords, // you must set its origin to ADWORDS. gmbFeed.origin = FeedOrigin.ADWORDS; // Create an operation to add the feed. FeedOperation feedOperation = new FeedOperation(); feedOperation.operand = gmbFeed; feedOperation.@operator = Operator.ADD; try { // Add the feed. Since it is a system generated feed, AdWords will // automatically: // 1. Set up the FeedAttributes on the feed. // 2. Set up a FeedMapping that associates the FeedAttributes of the // feed with the placeholder fields of the LOCATION placeholder // type. FeedReturnValue addFeedResult = feedService.mutate(new FeedOperation[] { feedOperation }); Feed addedFeed = addFeedResult.value[0]; Console.WriteLine("Added GMB feed with ID {0}", addedFeed.id); // Add a CustomerFeed that associates the feed with this customer for // the LOCATION placeholder type. CustomerFeed customerFeed = new CustomerFeed(); customerFeed.feedId = addedFeed.id; customerFeed.placeholderTypes = new int[] { PLACEHOLDER_LOCATION }; // Create a matching function that will always evaluate to true. Function customerMatchingFunction = new Function(); ConstantOperand constOperand = new ConstantOperand(); constOperand.type = ConstantOperandConstantType.BOOLEAN; constOperand.booleanValue = true; customerMatchingFunction.lhsOperand = new FunctionArgumentOperand[] { constOperand }; customerMatchingFunction.@operator = FunctionOperator.IDENTITY; customerFeed.matchingFunction = customerMatchingFunction; // Create an operation to add the customer feed. CustomerFeedOperation customerFeedOperation = new CustomerFeedOperation(); customerFeedOperation.operand = customerFeed; customerFeedOperation.@operator = Operator.ADD; // After the completion of the Feed ADD operation above the added feed // will not be available for usage in a CustomerFeed until the sync // between the AdWords and GMB accounts completes. The loop below // will retry adding the CustomerFeed up to ten times with an // exponential back-off policy. CustomerFeed addedCustomerFeed = null; AdWordsAppConfig config = new AdWordsAppConfig(); config.RetryCount = 10; ErrorHandler errorHandler = new ErrorHandler(config); do { try { CustomerFeedReturnValue customerFeedResult = customerFeedService.mutate(new CustomerFeedOperation[] { customerFeedOperation }); addedCustomerFeed = customerFeedResult.value[0]; Console.WriteLine("Added CustomerFeed for feed ID {0} and placeholder type {1}", addedCustomerFeed.feedId, addedCustomerFeed.placeholderTypes[0]); break; } catch (AdWordsApiException e) { ApiException apiException = (ApiException) e.ApiException; foreach (ApiError error in apiException.errors) { if (error is CustomerFeedError) { if ((error as CustomerFeedError).reason == CustomerFeedErrorReason.MISSING_FEEDMAPPING_FOR_PLACEHOLDER_TYPE) { errorHandler.DoExponentialBackoff(); errorHandler.IncrementRetriedAttempts(); } else { throw; } } } } } while (errorHandler.HaveMoreRetryAttemptsLeft()); // OPTIONAL: Create a CampaignFeed to specify which FeedItems to use at // the Campaign level. This will be similar to the CampaignFeed in the // AddSiteLinks example, except you can also filter based on the // business name and category of each FeedItem by using a // FeedAttributeOperand in your matching function. // OPTIONAL: Create an AdGroupFeed for even more fine grained control // over which feed items are used at the AdGroup level. } catch (Exception e) { throw new System.ApplicationException("Failed to create customer feed.", e); } }