Thread overview | |||||||
---|---|---|---|---|---|---|---|
|
October 01, 2005 Preprocessing with Build | ||||
---|---|---|---|---|
| ||||
Hi, Is this possible yet? Here's what I would like to do: # void main() { # pragma(include, "foo", "/usr/bin/bar -f"); # } What happens is: 1) "/usr/bin/bar -f foo" is run. 2) The result is #include'd, literally, into main() right there. I took a look at the pragmas already available but I couldn't figure out if what I want to do is doable. Bear in mind, I don't want to LINK anything. I want to #include something after being processed by some arbitrary binary. What's the word on the street? Thanks a ton. --AJG. |
October 01, 2005 Re: Preprocessing with Build | ||||
---|---|---|---|---|
| ||||
Posted in reply to AJG | Hmmm Im not positive, but I dont believe its possible - yet, because it would require creating an intermediate source file and sending that to the compiler. I say 'yet' because I believe he was discussing doing something like that eventually...
AJG wrote:
> Hi,
>
> Is this possible yet? Here's what I would like to do:
>
> # void main() {
> # pragma(include, "foo", "/usr/bin/bar -f"); # }
>
> What happens is:
> 1) "/usr/bin/bar -f foo" is run.
> 2) The result is #include'd, literally, into main() right there.
>
> I took a look at the pragmas already available but I couldn't figure out if what
> I want to do is doable. Bear in mind, I don't want to LINK anything. I want to
> #include something after being processed by some arbitrary binary.
>
> What's the word on the street?
>
> Thanks a ton.
> --AJG.
>
>
|
October 01, 2005 Re: Preprocessing with Build | ||||
---|---|---|---|---|
| ||||
Posted in reply to AJG | On Sat, 1 Oct 2005 07:16:29 +0000 (UTC), AJG wrote: > Hi, > > Is this possible yet? Here's what I would like to do: > > # void main() { > # pragma(include, "foo", "/usr/bin/bar -f"); > # } > > What happens is: > 1) "/usr/bin/bar -f foo" is run. > 2) The result is #include'd, literally, into main() right there. > It's not complete in Build yet. The technique I've selected is to support a new type of source file, that is one that ends with ".dm". These files would be processed with build to expand macros etc... In the case you mention it would be more like this ... [FILE: main.dm] void main() { #insert `/usr/bin/bar -f foo` } and this would generate the file "main.d" which would then be given to the compiler. I'm still finishing off the macro processor which is a general purpose one with lot's of neat (IMHO) features. -- Derek Parnell Melbourne, Australia 2/10/2005 12:38:05 AM |
October 02, 2005 Re: Preprocessing with Build | ||||
---|---|---|---|---|
| ||||
Posted in reply to Derek Parnell | In article <198g9ee8neycf$.inm2kj3k8j26.dlg@40tude.net>, Derek Parnell says... > >On Sat, 1 Oct 2005 07:16:29 +0000 (UTC), AJG wrote: > >> Hi, >> >> Is this possible yet? Here's what I would like to do: >> >> # void main() { >> # pragma(include, "foo", "/usr/bin/bar -f"); >> # } >> >> What happens is: >> 1) "/usr/bin/bar -f foo" is run. >> 2) The result is #include'd, literally, into main() right there. >> >It's not complete in Build yet. The technique I've selected is to support a new type of source file, that is one that ends with ".dm". These files would be processed with build to expand macros etc... > >In the case you mention it would be more like this ... > >[FILE: main.dm] > > void main() { > #insert `/usr/bin/bar -f foo` > } > >and this would generate the file "main.d" which would then be given to the compiler. Awesome! >I'm still finishing off the macro processor which is a general purpose one with lot's of neat (IMHO) features. Indeed! So, what kind of release date are we lookin' at? <g> Cheers, --AJG. |
October 02, 2005 Re: Preprocessing with Build | ||||
---|---|---|---|---|
| ||||
Posted in reply to Derek Parnell | Derek Parnell wrote: > On Sat, 1 Oct 2005 07:16:29 +0000 (UTC), AJG wrote: > > >>Hi, >> >>Is this possible yet? Here's what I would like to do: >> >># void main() { >># pragma(include, "foo", "/usr/bin/bar -f"); # } >> >>What happens is: >>1) "/usr/bin/bar -f foo" is run. >>2) The result is #include'd, literally, into main() right there. >> > > It's not complete in Build yet. The technique I've selected is to support a > new type of source file, that is one that ends with ".dm". These files > would be processed with build to expand macros etc... > > In the case you mention it would be more like this ... > > [FILE: main.dm] > > void main() { > #insert `/usr/bin/bar -f foo` > } > > and this would generate the file "main.d" which would then be given to the > compiler. > > I'm still finishing off the macro processor which is a general purpose one > with lot's of neat (IMHO) features. > Hum... not sure if I like the sound of this. Preprocessor features usually (they sure did for C/C++) add lots of complexity to syntax-based editing features, such as refactoring (renaming, moving,etc.) or even the basic auto code-completion. But I guess this does depend on what exactly are the intended preprocessor features. -- Bruno Medeiros - CS/E student "Certain aspects of D are a pathway to many abilities some consider to be... unnatural." |
Copyright © 1999-2021 by the D Language Foundation