So, I'm working on an interface that will translate gamepad inputs to certain MIDI controls that will control the routing and properties of an audio effects chain in Logic, including loop plugins within logic.
My main patch receives the input and sends it to one of many different subpatches that each deal with the same input in different ways.
For example, if subpatch 1 is active and button 1 is pressed, I want to send MIDI message 1 1 1 to logic, which converts that message in the logic environment to the correct message to, say, start recording loop one. If I want another button on another subpatch to perform the same function (loop one record-on), I would want the same message to be sent to Logic (1 1 1) from a different point in the chain.
Now, to make passing these MIDI messages within my patches easier, I have the digits shifted and parts summed so that MIDI message 1 1 1 would be passed within the patch as 0010101 and 127 5 8 would be passed as 1270508.
I expect to be cranking out more subpatches every week for possible input sets, all leading back to the same output to logic for the same message ("loop one record-on" will be 1 1 1 for every subpatch), and to make writing subpatches more intuitive, I'd like to do some sort of analogous function to #DEFINE in C, such as:
#DEFINE lp1RecOn 0010101
and my subpatches could use the name instead of the number. This also would make it easier to change my MIDI message processing scheme later. If I decide that some other function needs to be 1 1 1, and I change the "loop one record-on" function to use 1 5 4, I would only need to change the definition of the constant in one central reference file (an the routing in logic) instead of crawling through all of my patches, changing every instance of it in them.

Is there any way to #DEFINE constants in Pd?
(Or do something funcitonally equivalent?)

there's probably a whole bunch of ways to do what you want to do.

the first way i can think of is like this:

in your subpatches, you'd have:

[r lp1RcOn]
|
[$1 (
|
[f 0 ]

[r lp1RcOn]
|
[$2 (
|
[f 0 ]

[r lp1RcOn]
|
[$3 (
|
[f 0 ]

and then in your master patch,

[loadbang]
|
[1 1 1(
|

(and then of course, to output the vales, you'd do this:

[t b b b]
| | |
[f 0] [f 0] [f 0]
| | /
[pack 0 0 0]

where the 3 [f 0] objects correspond to the three [f 0] objects in the constructs above.

Another approach might be to store the values you want to send in tables and use [tabread] to recall them in all of your subpatches, with the indexes corresponding to the type of message you want to send. Then if you want to change the message, you could just change the value in the table, thus changing the messages sent by all subpatches.

you could just use symbols, and instead of sending directly to logic from every subpatch, send to a master receiver that converts from the names into the messages you want to send to logic

something like:

subpatch1: ...--"lp1RecOn"--[send LOGIC]
subpatch2: ...--"lp1RecOn"--[send LOGIC]
subpatch3: ...--"lp2RecOn"--[send LOGIC]
subpatch4: ...--"lp2RecOn"--[send LOGIC]
etc

master:

[receive LOGIC]
|
[route lp1RecOn lp2RecOn etc]
| |
"1 1 1" "6 24 100"
| |
... whatever you need to send to logic

(I use [route] instead of [select] here because otherwise you need to have all the identifiers be symbols, like "symbol lp1RecOn", which quickly gets tedious to type)

side note: be careful with the "shifting multiple values into one number" trick, it works until you get to large enough output numbers (about 16 million) at which point rounding errors creep in and it gets ugly, not to mention Pd likes to truncate numbers even more roughly when converting between floats and strings...

Yeah, thanks for all the suggestions guys.
I ended up working a hybrid of them, and I think it works efficiently and is abstracted enough to where I can change things later without reworking the entire solution (which is just the flexibility I need)

I'm also using pack / unpack instead of the digit shifting thing now. I didn't even know about pack until hardoff mentioned it in his solution. Along with route, it's a great solution.

I'm just now starting to think in terms of pd and understand how powerful it can be.

Thanks, guys.