I&#39;m starting to use WiX in order to do automated builds to create msi&#39;s of my c# projects and am experiencing the error **&quot;Undefined preprocessor variable &#39;$(var.MyProject.TargetDir)&#39;&quot;**

I am using the latest WiX v3.0.5419. Inside my wxs file I am trying to use pre-processor variables that are listed on this webpage ([**http://blogs.msdn.com/jrock/archive/2008/01/29/complete-list-of-candle-preprocessor-variables.aspx**][1])

    &lt;Component Id=&quot;MyId&quot; Guid=&quot;MyGuid&quot;&gt;
       &lt;File Id=&quot;MyId&quot; Name=&quot;MyName&quot; KeyPath=&quot;yes&quot; 
          Source=&quot;$(var.MyProject.TargetDir)\MyName.dll&quot; /&gt;
    &lt;/Component&gt;

I have added the reference for MyProject to the .wixproj and if I open it up in Notepad I can see the reference.

    &lt;ItemGroup&gt;
      &lt;ProjectReference Include=&quot;..\MyProject.csproj&quot;&gt;
        &lt;Name&gt;MyProject&lt;/Name&gt;
        &lt;Project&gt;{guid}&lt;/Project&gt;
        &lt;Private&gt;True&lt;/Private&gt;
      &lt;/ProjectReference&gt;
    &lt;/ItemGroup&gt;

This is my nant build script that I use to create the msi. Maybe it&#39;s because the .wixproj knows about the project reference which isn&#39;t used in the build?

    &lt;exec basedir=&quot;${tools.wix}&quot; managed=&quot;true&quot; program=&quot;candle.exe&quot;&gt;
      &lt;arg line=&#39;-out &quot;${tools.wix.objfile}&quot;&#39; /&gt;
      &lt;arg value=&quot;../MySetup.wxs&quot; /&gt;
    &lt;/exec&gt;

Can anyone enlighten me on this please?

  [1]: http://blogs.msdn.com/jrock/archive/2008/01/29/complete-list-of-candle-preprocessor-variables.aspx

WiX undefined preprocessor variable

Programming in `C` I used to have code sections only used for debugging purposes (logging commands and the like). Those statements could be completely disabled for production by using `#ifdef` pre-processor directives, like this:

     #ifdef MACRO
     
     controlled text
     
     #endif /* MACRO */

What is the best way to do something similar in `python`?

How do you implement &quot;#ifdef&quot; in python?

I am making an app that processes sensitive credit card data.

If my code is running in debug mode I want to log this data to the console and make some file dumps.   

However on the final appstore version (ie when it is running in release mode) it is essential all of this is disabled (security hazard)!

I will try to answer my question as best I can;  so the question becomes *&#39;Is this solution path the right or best way to do it?&#39;*
  
    // add `IS_DEBUG=1` to your debug build preprocessor settings  
  
    #if( IS_DEBUG )  
    #define MYLog(args...) NSLog(args)  
    #else  
    #define MYLog(args...)  
    #endif  



How to determine whether code is running in DEBUG / RELEASE build?

I am writing my first Razor page today, and can&#39;t figure out how to enter
```
#if debug
...
#else
...
#endif
```

How can I do that in Razor?

Preprocessor directives in Razor

In C/C++/Objective C you can define a macro using compiler preprocessors.
Moreover, you can include/exclude some parts of code using compiler preprocessors.

```c++
#ifdef DEBUG
    // Debug-only code
#endif
```

Is there a similar solution in Swift?


#ifdef replacement in the Swift language

What is the *worst* **real-world** macros/pre-processor abuse you&#39;ve ever come across (please no contrived IOCCC answers \*haha\*)?

Please add a short snippet or story if it is really entertaining. The goal is to teach something instead of always telling people &quot;never use macros&quot;.

---

p.s.: I&#39;ve used macros before... but usually I get rid of them eventually when I have a &quot;real&quot; solution (even if the real solution is inlined so it becomes similar to a macro).

---

**Bonus:** Give an example where the macro was really was better than a not-macro solution.

**Related question:** [When are C++ macros beneficial?](https://stackoverflow.com/questions/96196/when-are-c-macros-beneficial) 

What is the worst real-world macros/pre-processor abuse you&#39;ve ever come across?

How to make printf to show the values of variables which are of an enum type? For instance:

    typedef enum {Linux, Apple, Windows} OS_type; 
    OS_type myOS = Linux;

and what I need is something like 

    printenum(OS_type, &quot;My OS is %s&quot;, myOS);

which must show a string &quot;Linux&quot;, not an integer.

I suppose, first I have to create a value-indexed array of strings. But I don&#39;t know if that is the most beautiful way to do it. Is it possible at all?

How to convert an enum type variable to a string?

I&#39;m using an open source library which seems to have lots of preprocessing directives to support many languages other than C. So that I can study what the library is doing I&#39;d like to see the C code that I&#39;m compiling after preprocessing, more like what I&#39;d write.

Can gcc (or any other tool commonly available in Linux) read this library but output C code that has the preprocessing converted to whatever and is also readable by a human?

Can gcc output C code after preprocessing?

In `Objective-C` it was sometimes useful to use static string constants to define alternate API keys (for example to differentiate between RELEASE and DEBUG keys for analytics packages, like MixPanel, Flurry or Crashlytics):

    #if DEBUG
    static NSString *const API_KEY = @&quot;KEY_A&quot;;
    #else
    static NSString *const API_KEY = @&quot;KEY_B&quot;;
    #endif

and then...

    [Analytics startSession:API_KEY];


How does this translate to Swift, since the Swift compiler no longer uses a preprocessor?

Swift: how to use PREPROCESSOR Flags (like `#if DEBUG`) to implement API keys?

I would like to add some C# &quot;debug only&quot; code that only runs if the person debugging requests it.  In C++, I used to do something similar to the following:

    void foo()
    {   
      // ...
      #ifdef DEBUG
      static bool s_bDoDebugOnlyCode = false;
      if (s_bDoDebugOnlyCode)
      {
          // Debug only code here gets executed when the person debugging 
          // manually sets the bool above to true.  It then stays for the rest
          // of the session until they set it to false.
      }
      #endif
     // ...
    }

I can&#39;t do exactly the same in C# since there is no local statics.

**Question**: What is the best way to accomplish this in C#?

1. Should I use a private class static field with C# preprocessor directives (`#if/#endif DEBUG`)?
2. Should I use the Conditional attribute (to hold the code), and then a private class static field (**not** surrounded by C# preprocessor directives `#if/#endif DEBUG`?).
3. Something else?

&quot;Debug only&quot; code that should run only when &quot;turned on&quot;

With the C pre-processor it&#39;s common to do,

&lt;!-- language: C --&gt;

    #if defined(NDEBUG)
        // release build
    #endif

    #if defined(DEBUG)
        // debug build
    #endif

Cargo&#39;s rough equivalents are:

- `cargo build --release` for release.
- `cargo build` for debug.

How would Rust&#39;s `#[cfg(...)]` attribute or `cfg!(...)` macro be used to do something similar?

I understand that Rust&#39;s pre-processor doesn&#39;t work like C&#39;s. I checked the documentation and [this page lists some attributes][1]. *(assuming this list is comprehensive)*

`debug_assertions` could be checked, but it may be misleading when used to check for the more general debugging case.

I&#39;m not sure if this question should be related to Cargo or not.

  [1]: https://doc.rust-lang.org/reference.html#conditional-compilation

How to check release / debug builds using cfg in Rust?

Which is better to use, and why, on a large project:

    #if DEBUG
        public void SetPrivateValue(int value)
        { ... }
    #endif

or

    [System.Diagnostics.Conditional(&quot;DEBUG&quot;)]
    public void SetPrivateValue(int value)
    { ... }

#if DEBUG vs. Conditional(&quot;DEBUG&quot;)

&gt; ## Alternate titles to aid search
&gt; - Xcode can&#39;t find header 
&gt; - Missing .h in Xcode
&gt; - Xcode .h file not found
&gt; - lexical or preprocessor issue file not found

I&#39;m working on an iOS application project which came from Xcode 3.  I have now moved to Xcode 4 my project builds a number of static libraries.

Those static libraries also declare public headers and those headers are used by the application code. In Xcode 3.x the headers were copied (as a build phase) to the `public headers directory`, then in the application project the `public headers directory` was added to the `headers search list`.

Under Xcode 4 the build directory is moved to `~/Library/Developer/Xcode/DerivedData/my-project`. 

The problem is how do I reference this new location in the headers search settings? It seems that:

- `public headers directory` is relative to `DerivedData` directory, but
- `headers search` directory is relative to something else (possibly the project location)

How should I set up a static library target for iOS development in Xcode 4 that will ensure the header files are made available to the clients that use the static library when trying to compile as a dependancy?

Xcode 4 can&#39;t locate public header files from static library dependency

I&#39;m beginning to program in Java and I&#39;m wondering if the equivalent to the C++ `#define` exists.  
  
A quick search of google says that it doesn&#39;t, but could anyone tell me if something similar exists
in Java? _I&#39;m trying to make my code more readable._     
  
Instead of `myArray[0]` I want to be able to write `myArray[PROTEINS]` for example.



#define in Java

Is there a way to do the following preprocessor directives in Python?

    #if DEBUG
     
    &lt; do some code &gt;
     
    #else
     
    &lt; do some other code &gt;
     
    #endif



How would you do the equivalent of preprocessor directives in Python?

Highly repetitive code is generally a bad thing, and there are design patterns that can help minimize this. However, sometimes it&#39;s simply inevitable due to the constraints of the language itself. Take the following example from `java.util.Arrays`:

    /**
     * Assigns the specified long value to each element of the specified
     * range of the specified array of longs.  The range to be filled
     * extends from index &lt;tt&gt;fromIndex&lt;/tt&gt;, inclusive, to index
     * &lt;tt&gt;toIndex&lt;/tt&gt;, exclusive.  (If &lt;tt&gt;fromIndex==toIndex&lt;/tt&gt;, the
     * range to be filled is empty.)
     *
     * @param a the array to be filled
     * @param fromIndex the index of the first element (inclusive) to be
     *        filled with the specified value
     * @param toIndex the index of the last element (exclusive) to be
     *        filled with the specified value
     * @param val the value to be stored in all elements of the array
     * @throws IllegalArgumentException if &lt;tt&gt;fromIndex &amp;gt; toIndex&lt;/tt&gt;
     * @throws ArrayIndexOutOfBoundsException if &lt;tt&gt;fromIndex &amp;lt; 0&lt;/tt&gt; or
     *	       &lt;tt&gt;toIndex &amp;gt; a.length&lt;/tt&gt;
     */
    public static void fill(long[] a, int fromIndex, int toIndex, long val) {
        rangeCheck(a.length, fromIndex, toIndex);
        for (int i=fromIndex; i&lt;toIndex; i++)
            a[i] = val;
    }


The above snippet appears in the source code 8 times, with very little variation in the documentation/method signature but *exactly the same method body*, one for each of the root array types `int[]`, `short[]`, `char[]`, `byte[]`, `boolean[]`, `double[]`, `float[]`, and `Object[]`.

I believe that unless one resorts to reflection (which is an entirely different subject in itself), this repetition is inevitable. I understand that as a utility class, such high concentration of repetitive Java code is highly atypical, but even with the best practice, **repetition does happen**! Refactoring doesn&#39;t always work because it&#39;s not always possible (the obvious case is when the repetition is in the documentation).

Obviously maintaining this source code is a nightmare. A slight typo in the documentation, or a minor bug in the implementation, is multiplied by however many repetitions was made. In fact, the best example happens to involve this exact class:

&lt;a href=&quot;http://googleresearch.blogspot.com/2006/06/extra-extra-read-all-about-it-nearly.html&quot;&gt;Google Research Blog - Extra, Extra - Read All About It: Nearly All Binary Searches and Mergesorts are Broken (by Joshua Bloch, Software Engineer)&lt;/a&gt;

The bug is a surprisingly subtle one, occurring in what many thought to be just a simple and straightforward algorithm.

        // int mid =(low + high) / 2; // the bug
        int mid = (low + high) &gt;&gt;&gt; 1; // the fix

The above line **appears 11 times in the source code**!

So my questions are:

  * How are these kinds of repetitive Java code/documentation handled in practice? How are they developed, maintained, and tested?
     * Do you start with &quot;the original&quot;, and make it as mature as possible, and then copy and paste as necessary and hope you didn&#39;t make a mistake?
     * And if you did make a mistake in the original, then just fix it everywhere, unless you&#39;re comfortable with deleting the copies and repeating the whole replication process?
     * And you apply this same process for the testing code as well?
  * Would Java benefit from some sort of limited-use source code preprocessing for this kind of thing?
     * Perhaps Sun has their own preprocessor to help write, maintain, document and test these kind of repetitive library code?

---

A comment requested another example, so I pulled this one from Google Collections: &lt;a href=&quot;http://code.google.com/p/google-collections/source/browse/trunk/src/com/google/common/base/Predicates.java&quot;&gt;com.google.common.base.Predicates&lt;/a&gt; lines 276-310 (`AndPredicate`) vs lines 312-346 (`OrPredicate`).

The source for these two classes are identical, except for:

 * `AndPredicate` vs `OrPredicate` (each appears 5 times in its class)
 * `&quot;And(&quot;` vs `Or(&quot;` (in the respective `toString()` methods)
 * `#and` vs `#or` (in the `@see` Javadoc comments)
 * `true` vs `false` (in `apply`; `!` can be rewritten out of the expression)
 * `-1 /* all bits on */` vs `0 /* all bits off */` in `hashCode()`
 * `&amp;=` vs `|=` in `hashCode()`

Managing highly repetitive code and documentation in Java

I have a structure that *must* pad out to 64K to fit perfectly in an embedded project, so that it fills out a flash block. So there is a `#define` that adds up the elements in the structure using `sizeof()` and determines how big the `pad[]` at the end needs to be to cause the total size to be 64K.

For example :

    #define SIZE_OF_MY_PAD (0x10000 - (sizeof(uint16_t) + sizeof(uint8_t)*32 + ... ))

    typedef struct {
      uint16_t firstElement;
      uint8_t  secondElementArray[32];
      ...
      uint8_t pad[SIZE_OF_MY_PAD];
    };

This has worked great for a long time until suddenly we don&#39;t need the pad at all in certain build configurations because it is already exactly 64k.  This causes the code to fail because our compiler (not GCC) does not allow `pad[0]`.

I have tried various ways to create a preprocessor value that I can use in an `#if` statement when this is detected, but it always fails because although `sizeof()` is legal in `#define`, it is not legal in `#if`.




I need a way in a C preprocessor #if to test if a value will create a 0-size array

Is there a preprocessor macro that will let me know NDK is compiling my code? I could manually define my own, but I&#39;d rather not if possible.

All Preprocessor Solutions on Gang of Coders

Total of 18 Preprocessor Solutions

WiX undefined preprocessor variable

How do you implement "#ifdef" in python?

How to determine whether code is running in DEBUG / RELEASE build?

Preprocessor directives in Razor

#ifdef replacement in the Swift language

What is the worst real-world macros/pre-processor abuse you've ever come across?

How to convert an enum type variable to a string?

Can gcc output C code after preprocessing?

Swift: how to use PREPROCESSOR Flags (like `#if DEBUG`) to implement API keys?

"Debug only" code that should run only when "turned on"

How to check release / debug builds using cfg in Rust?

#if DEBUG vs. Conditional("DEBUG")

Xcode 4 can't locate public header files from static library dependency

#define in Java

How would you do the equivalent of preprocessor directives in Python?

Managing highly repetitive code and documentation in Java

I need a way in a C preprocessor #if to test if a value will create a 0-size array

How to detect compilation by Android NDK in a C/C++ file?