>
> #define TABSTART enum{
> #define TABEND ENDTAB};
> #define PSEUDOCOUNTINGMACRO(v) v,
>
> TABSTART
> PSEUDOCOUNTINGMACRO(DEAD_STATE)
> PSEUDOCOUNTINGMACRO(ALIVE_STATE)
> PSEUDOCOUNTINGMACRO(HAPPY_STATE)
> PSEUDOCOUNTINGMACRO(SAD_STATE)
> TABEND
>
> void main(void)
> {
> printf("DEAD is %d
> "
> "ALIVE is %d
> "
> "HAPPY is %d
> "
> "SAD is %d
> ",
> DEAD_STATE,
> ALIVE_STATE,
> HAPPY_STATE,
> SAD_STATE);
> }
>
> ```
Sadly, that won’t work for two reasons:
(1) I’m not actually compiling C or C++ code, I’m just using the preprocessor. And enums are a feature of the language, not the preprocessor.
(2) More importantly, these macros need to be scattered throughout other things, not all sequential, ie:
```auto
COUNTINGMACRO(DEAD)
deadStateThing1
deadStateThing2
COUNTINGMACRO(ALIVE)
happyFunAliveThing(blah blah blah)
COUNTINGMACRO(HAPPY)
```
etc.
---
### Author:  [@ultrafilter](https://boards.straightdope.com/u/ultrafilter)
#### Post date: [June 1, 2005, 10:55pm UTC](https://boards.straightdope.com/t/another-tricky-c-preprocessor-question/306454/11 "2005-06-01T22:55:32Z")
What exactly are you trying to do with this, anyway? There may be a more appropriate solution out there.
---
### Author:  [@MaxTheVool](https://boards.straightdope.com/u/MaxTheVool)
#### Post date: [June 1, 2005, 11:09pm UTC](https://boards.straightdope.com/t/another-tricky-c-preprocessor-question/306454/12 "2005-06-01T23:09:14Z")
> [@ultrafilter](#):
>
> What exactly are you trying to do with this, anyway? There may be a more appropriate solution out there.
As I said, I’ve written a scripting language for the game I’m working on, which is basically fully written and working. However, I’ve just gotten a request to add a new features which allow all the parts of a side mission to be encapsulated together.
Syntactically, I’d like the designers (who use the language) to do something like this:
```auto
BEGIN_SIDE_MISSION(happyMission)
SIDE_MISSION_STATE(TALK_TO_BOB)
//stuff in here relating to TALK_TO_BOB
SIDE_MISSION_STATE(DRINK_A_SODA)
//stuff in here relating to DRINK_A_SODE
END_SIDE_MISSION
```
It’s important that TALK\_TO\_BOB and DRINK\_A\_SODA be #defined, so that later on, language commands can do thinks like IF GETVAR(happyMission\_STATE) == DRINK\_A\_SODA. It’s also important that they be unique and, ideally, sequential.
The more of this work I can get the preprocessor to do for me, the happier I am. The simpler the syntax is (ie, the side missions states defined as they are used, not initially listed in some different place that can get out of sync), the happier the designers are.
---
### Author:  [@Polerius](https://boards.straightdope.com/u/Polerius)
#### Post date: [June 1, 2005, 11:26pm UTC](https://boards.straightdope.com/t/another-tricky-c-preprocessor-question/306454/13 "2005-06-01T23:26:29Z")
> [@MaxTheVool](#):
>
> Oh, and if it helps, I have control over how the preprocessor is called, since this is actually being used for a scripting language. So I could, potentially, call the preprocessor multiple times if that would help.
>
> (I think I have a solution that would work if I ran the preprocessor twice and could figure out how to make a macro resolve with line feeds in it.)
Since you control how the pre-processor is called, why not something like this?
```auto
cpp input_file | perl script.pl | cpp > output_file
```
The first cpp parses all the #includes and #defines
The perl (or other language) script replaces COUNTINGMACRO(x) with #define x
The second cpp takes care of all the #define x
If you don’t have #includes in your input file, you can simply use
```auto
perl script.pl input_file | cpp > output_file
```
The perl script can be a simple one-liner run on the command line. e.g if the input\_file is
```auto
COUNTINGMACRO(DEAD_STATE)
COUNTINGMACRO(ALIVE_STATE)
COUNTINGMACRO(HAPPY_STATE)
int x1 DEAD_STATE;
int x2 ALIVE_STATE;
int x3 HAPPY_STATE;
```
Then
```auto
perl -ne 'if(/COUNTINGMACRO\(([A-Z_]+)\)/) {printf "#define $1 %i
", $counter++} else {print;}' input_file
```
results in
```auto
#define DEAD_STATE 0
#define ALIVE_STATE 1
#define HAPPY_STATE 2
int x1 DEAD_STATE;
int x2 ALIVE_STATE;
int x3 HAPPY_STATE;
```
and the following
```auto
perl -ne 'if(/COUNTINGMACRO\(([A-Z_]+)\)/) {printf "#define $1 %i
", $counter++} else {print;}' input_file | cpp > output_file
```
results in
```auto
int x1 0 ;
int x2 1 ;
int x3 2 ;
```
---
### Author:  [@MaxTheVool](https://boards.straightdope.com/u/MaxTheVool)
#### Post date: [June 1, 2005, 11:33pm UTC](https://boards.straightdope.com/t/another-tricky-c-preprocessor-question/306454/14 "2005-06-01T23:33:17Z")
> [@Polerius](#):
>
> Since you control how the pre-processor is called, why not something like this?
>
> ```auto
>
> cpp input_file | perl script.pl | cpp > output_file
>
> ```
That’s actually almost precisely the approach I think I’m going to have to take… 3 passes. Once through the preprocessor to handle #include files and simple #defines, once through a custom-written preprocessor to expand “special” macros, and then again through the preprocessor to process any #defines generated by the special macros.
Of course, I don’t know Perl, so will have to just write the middle step preprocessor in C++ or something
---
### Author:  [@ultrafilter](https://boards.straightdope.com/u/ultrafilter)
#### Post date: [June 1, 2005, 11:36pm UTC](https://boards.straightdope.com/t/another-tricky-c-preprocessor-question/306454/15 "2005-06-01T23:36:06Z")
> [@MaxTheVool](#):
>
> ```auto
>
> BEGIN_SIDE_MISSION(happyMission)
>
> SIDE_MISSION_STATE(TALK_TO_BOB)
> //stuff in here relating to TALK_TO_BOB
> SIDE_MISSION_STATE(DRINK_A_SODA)
> //stuff in here relating to DRINK_A_SODE
> END_SIDE_MISSION
>
> ```
>
> It’s important that TALK\_TO\_BOB and DRINK\_A\_SODA be #defined, so that later on, language commands can do thinks like IF GETVAR(happyMission\_STATE) == DRINK\_A\_SODA. It’s also important that they be unique and, ideally, sequential.
What about this?
```auto
#define SIDE_MISSION_STATE(x) static int x
```
The values of the various states wouldn’t necessarily be unique (in fact, they’d all be 0), but their addresses would be unique. They may or may not be sequential depending on your compiler.
---
### Author:  [@Polerius](https://boards.straightdope.com/u/Polerius)
#### Post date: [June 1, 2005, 11:38pm UTC](https://boards.straightdope.com/t/another-tricky-c-preprocessor-question/306454/16 "2005-06-01T23:38:10Z")
> [@MaxTheVool](#):
>
> Of course, I don’t know Perl, so will have to just write the middle step preprocessor in C++ or something
You can use the one-liner I showed above, replacing COUNTINGMACRO with whatever macro name you want to use.
Writing this in C++ would be a nightmare, I think.
---
### Author:  [@ultrafilter](https://boards.straightdope.com/u/ultrafilter)
#### Post date: [June 1, 2005, 11:42pm UTC](https://boards.straightdope.com/t/another-tricky-c-preprocessor-question/306454/17 "2005-06-01T23:42:56Z")
Actually, if you’re really hung up on using the values, you can try this:
```auto
#define SIDE_MISSION_STATE(x) const static int x = (int) &x;
```
---
### Author:  [@MaxTheVool](https://boards.straightdope.com/u/MaxTheVool)
#### Post date: [June 2, 2005, 12:19am UTC](https://boards.straightdope.com/t/another-tricky-c-preprocessor-question/306454/18 "2005-06-02T00:19:44Z")
> [@ultrafilter](#):
>
> Actually, if you’re really hung up on using the values, you can try this:
>
> ```auto
>
> #define SIDE_MISSION_STATE(x) const static int x = (int) &x;
>
> ```
Again, that’s a C++ thing, not a C++ _preprocessor_ thing.
There might be something similar and tricky that could be done with the **LINE** macro, but it wouldn’t end up generating things that were sequential.
---
### Author:  [@ultrafilter](https://boards.straightdope.com/u/ultrafilter)
#### Post date: [June 2, 2005, 12:26am UTC](https://boards.straightdope.com/t/another-tricky-c-preprocessor-question/306454/19 "2005-06-02T00:26:52Z")
> [@MaxTheVool](#):
>
> Again, that’s a C++ thing, not a C++ _preprocessor_ thing.
I don’t understand the distinction you’re making. Why won’t that work?
> [@](#):
>
> There might be something similar and tricky that could be done with the **LINE** macro, but it wouldn’t end up generating things that were sequential.
If the statics are all in the same file and no variables are declared in between, your compiler will probably line them up sequentially. I’m 95% sure of that, but of course you’d want to check. In that case, they’d differ by sizeof(int) rather than 1, but you can correct for that easily.
---
### Author:  [@MaxTheVool](https://boards.straightdope.com/u/MaxTheVool)
#### Post date: [June 2, 2005, 1:18am UTC](https://boards.straightdope.com/t/another-tricky-c-preprocessor-question/306454/20 "2005-06-02T01:18:29Z")
> [@ultrafilter](#):
>
> I don’t understand the distinction you’re making. Why won’t that work?
Because the preprocessor won’t touch any of that at all. It will just leave it unchanged. The only things the preprocessor does (in general) are:
-remove comments
-expand macros
-include files
My scripting language uses the preprocessor because all three of those things are generally useful for any language. But once the preprocessor has run, my compiler takes over, and C++ is out the window.
[Next page](https://boards.straightdope.com/t/another-tricky-c-preprocessor-question/306454.md?page=2)