is it possible?
i need to send messages with $0 and similar... but
|$0( gets replaced to: 0 (as it should)
|$0( gets replaced to: $0 (like i want it, BUT if saved becomes |$\$0( )
|$\$0( gets replaced to: $\$0 (clearly not what i want!)

and it seems that it is even impossible to generate a message with adddollar and similar to do what i want to

really annoying that i use more time to work around pd than to make nice things

i have attached a example but don't give me a f $0 solution... i need the $0 in a (auto generated) receive!

http://www.pdpatchrepo.info/hurleur/escaping_problem.pd

I once encountered a similar situation. All l could do was creating an abstraction with the $0 stuff inside and call it dynamically to avoid $0's in messages.

yeah but then i need to send the $0 somehow to the abstraction to make it able to communicate with the outside world... and we are back to the same problem

the only possible solution would be to send it into a inlet via a f $0 but then i would need to make direct connections... but again the r $0 would be the problem because you cant change the receive symbol

Do you need several different receives ? If not, I would give the parent's $0 converted to a number as agument of the abstraction. Inside the child, it would be $1 and outside in the parent patch it would be the initial $0. So inside would be connected to [r $0] outside.

Well, of course, this would have to be done every time you open the patch. Not shure it's what you are looking for...

By the way, what kind of complicated thing are you trying to do ?

uhhh... i'm nearly finished building a auto generated sequencer (only a simple pattern sequencer for percussions or similar)...
with variable outlets and such fancy stuff

the problem with using $0 as a number is that the finished patch isn't savable... one application i had in mind was generate the patch then delete the autogen part, save it and then use it normally

also do you know if there is another way to send construction messages to the current patch then to know its exact name? maybe some kind of $this ?

also its really annoying that the auto generated things are taken over to new instances of the abstraction :/

take a look at this i need real $0's at a lot different places if i want the patch to be savable
but for the beginning i made it work like you suggested

I'm not entirely sure I know what you mean, but does this help?

http://www.pdpatchrepo.info/hurleur/dynamicdolloar.pd

All glory to Maelstorm ! Very smart, the makefilename does the escape itself, which seems to be \\, which are dropped characters when coming from the keyboard.

Nice work, slur (and you for the headache;). My only advice would be to separate the generated things in a [pd $0-subpatch] that could be cleared and regenerated, and even graphed on grandparent if needed.

damn... i was even playing around with makefilename but wasn't able to figure this solution out :/
and i'm currently tooo lazy to add this to my sequencer... but its working anyhow
i bet a lot of my solutions were more complicated than necessary too

however
thx .mmb

yeah kyro but sometimes the \ gets through and you get \$0 which is useless

yeah the graph on parent version would be a reasonable change... but the outlets have to be at the lowest layer so its no use anyway
especially because that's the only place i use connect msgs... which screwed not only once my working copy

Ha! I wasn't sure if that would actually work!

Btw, why do you need multiple outlets, anyway? Why not just prepend the message from each track with A, B, C, whatever and let the user just [route] them out? I tried answering the question myself by looking at the patch, but for some reason it's causing Pd-extended to crash every time I try to open it. I can open the help file, but not the actual patch.

I dug up this patch while looking for answers to the old dynamic dollar sign problem. Maelstorm's solution with [makefilename] is clever, but as one member observes it ends up giving you an extra slash if you try to create a symbol with $0 in it.

What I've found does work, though, is this:

36 and 48 being the byte values for "$" and "0".

With this technique you can dynamically create any sort of $0 object, but of course you'll need the moocow library for it to work.

Just to back up a bit...

[42(
|
[send $0-foo]

[loadbang]
|
[f $0]
|
[obj 0 150 receive $1-foo(
|
[send c]
[namecanvas c]

The above patch should dynamically instantiate a [receive] object with the expanded value of "$0" for your patch. If you hook up a [print] to it, it should print out "42" to the console.

In other words, the send-symbol "$0-foo" expands to "1001-foo" (or whatever the value of "$0" happens to be). During runtime you can just send the actual value of "$0" to your abstraction instead of the problematic symbol "$0".

The only caveat is that you can't save the abstraction where you used the expanded value, because the value may change the next time you run Pd.

Oops, I see you really want "$0" in order to save.
Here it is without [makefilename]:

[list $ 0(
|
[obj 0 0 + $1$2(
|
[etc.]

Oh yeah, that's even better!