A program that writes code: should it use 'string'?

[Ramon F Herrera]

I am writing a program that generates source code. See a snippet
below. My question is about the use of that growing 'code' variable.
Is it efficient? Is is recommended for this case?

The code generated can grow a lot. Perhaps I should allocate a large
max size in advance?

TIA,

-RFH
-------------

void SynthesizeTextF ield(CompleteFi eld fullTextField)
{
string code;
string baseFieldname = "text";
stringstream ss;
static int subindex = 1;

code = "Field ";
code += baseFieldname;
ss << subindex;
code += ss.str();
code += " ";
code += "doc.FieldCreat e(\"";
code += baseFieldname;
code += ss.str();
code += "\", Field::e_text, \"\", \"\");";

subindex++;
}

[Kai-Uwe Bux]

Ramon F Herrera wrote:

>
I am writing a program that generates source code. See a snippet
below. My question is about the use of that growing 'code' variable.
Is it efficient? Is is recommended for this case?

Recommended is to measure before you optimize. Write the program so that it
is easy to understand. When (and only when) you have a performance problem,
don't guess what the cause might be; instead, use a profiler to identify
the bottleneck and then do something about it.

The code generated can grow a lot. Perhaps I should allocate a large
max size in advance?

[snip]

If profiling shows that appending to the string is too costly, reserving a
certain capacity would be the first thing to try. It's the least intrusive
measure.
Best

Kai-Uwe Bux

[Daniel T.]

Ramon F Herrera <ra***@conexus. netwrote:

I am writing a program that generates source code. See a snippet
below. My question is about the use of that growing 'code' variable.
Is it efficient? Is is recommended for this case?

The code generated can grow a lot. Perhaps I should allocate a large
max size in advance?

A std::string is just a vector<charwith some extra functions that you
probably don't need for this particular variable.

I think your best bet would be to make your own class to represent
"code", implement that class with a string if that makes sense to you.
The nice thing is you can always change the implementation of the class
later as profiling requires, without affecting any other code.

[James Kanze]

On Jun 1, 11:58 pm, Ramon F Herrera <ra...@conexus. netwrote:

I am writing a program that generates source code. See a snippet
below. My question is about the use of that growing 'code' variable.
Is it efficient? Is is recommended for this case?

The code generated can grow a lot. Perhaps I should allocate a large
max size in advance?

-------------

void SynthesizeTextF ield(CompleteFi eld fullTextField)
{
string code;
string baseFieldname = "text";
stringstream ss;
static int subindex = 1;

code = "Field ";
code += baseFieldname;
ss << subindex;
code += ss.str();
code += " ";
code += "doc.FieldCreat e(\"";
code += baseFieldname;
code += ss.str();
code += "\", Field::e_text, \"\", \"\");";

subindex++;
}

For starters, I'd generate (or support generation) directly into
the output stream. Something like:

std::ostream&
SynthesizeTextF ield(
std::ostream& dest,
... )
{
// ...
return dest ;
}

You're formatting here (some of the data is numeric,
apparently), so you might as well treat the entire thing as a
stream. And you'll certainly be outputting it in the end;
there's not much you can do with C++ source code within the
program, so you might as well generate directly into the output
stream, and never build the string at all.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Juha Nieminen]

Ramon F Herrera wrote:

I am writing a program that generates source code. See a snippet
below. My question is about the use of that growing 'code' variable.
Is it efficient? Is is recommended for this case?

I think it's ok. You could also say something like
"code.reserve(1 00*1024);" which allocates 100kB (or any other
amount you feel is about correct) of memory for it so that it
never has to resize (unless you exceed that limit, of course),
which might make it slightly more efficient.

[Pascal J. Bourguignon]

Ramon F Herrera <ra***@conexus. netwrites:

I am writing a program that generates source code. See a snippet
below. My question is about the use of that growing 'code' variable.
Is it efficient? Is is recommended for this case?

The code generated can grow a lot. Perhaps I should allocate a large
max size in advance?
[...]
code += "doc.FieldCreat e(\"";
[...]

No, you should not use strings to generate code. Code is a syntac
tree. You should have a tree of objects:

Lhs* lhs=new Variable("pi_sq uared");
Rhs* rhs=new Variable("pi");
Statement* code=new Assignment(lhs, new Multiply(rhs,rh s));
cout<<code->generate();

would produce:

pi_squared=pi*p i;
--
__Pascal Bourguignon__

[Yannick Tremblay]

In article <7c************ @pbourguignon.a nevia.com>,
Pascal J. Bourguignon <pj*@informatim ago.comwrote:

>
No, you should not use strings to generate code. Code is a syntac
tree. You should have a tree of objects:

Lhs* lhs=new Variable("pi_sq uared");
Rhs* rhs=new Variable("pi");
Statement* code=new Assignment(lhs, new Multiply(rhs,rh s));
cout<<code->generate();

This is C++, not Java, loose the "new" abuse:
// class Variable;
// class Statement;
// class Assignment: public Statement;

Variable lhs("pi_squared ");
Variable rhs("pi");
Assignment code(lhs, Multiply(rhs, rhs);

cout << code.generate() ;

// or
cout << Assignement(Var iable("pi_squar ed"),
Multiply(Variab le("pi"),Variab le("pi")).gener ate();

>would produce:

pi_squared=pi*p i;

Your tree of object approach is probably superior as complexity
increases. For simple problems direct construction in a
string/ostream is likely to be sufficient but if you have a lot of
complex code generation to do, the cost of creating the code object
hierarchy is likely to be worthwhile.

Yannick

[James Kanze]

On Jun 2, 2:38 pm, p...@informatim ago.com (Pascal J. Bourguignon)
wrote:

Ramon F Herrera <ra...@conexus. netwrites:

I am writing a program that generates source code. See a snippet
below. My question is about the use of that growing 'code' variable.
Is it efficient? Is is recommended for this case?

The code generated can grow a lot. Perhaps I should allocate a large
max size in advance?
[...]
code += "doc.FieldCreat e(\"";
[...]

No, you should not use strings to generate code. Code is a
syntac tree.

That depends a lot on the code. The compiler may treat it as a
syntax tree, but most of the time I'm generating code, it's
fairly flat (tables and that sort of stuff). And of course, in
the end, you need text, to feed to the compiler.

You should have a tree of objects:

Lhs* lhs=new Variable("pi_sq uared");
Rhs* rhs=new Variable("pi");
Statement* code=new Assignment(lhs, new Multiply(rhs,rh s));
cout<<code->generate();

would produce:

pi_squared=pi*p i;

I think you've missed the question. The original poster may
actually be already doing that, for all we know. The question
concerned the generation of the code, not the source from which
it was generated. And the code itself must be text (at least as
the question was posed).

Of course, I agree that you don't have to generate that text
entirely in one std::string object. Regardless of the source,
you should (usually) output it directly to an ostream (which
could be an ostringstream *if* you need the text in the process,
but usually, it will be an ofstream, I think).

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[James Kanze]

On Jun 2, 3:41 pm, [e-mail] x.net (Yannick Tremblay) wrote:

In article <7clk1oc8r6.... @pbourguignon.a nevia.com>,
Pascal J. Bourguignon <p...@informati mago.comwrote:

No, you should not use strings to generate code. Code is a syntac
tree. You should have a tree of objects:

Lhs* lhs=new Variable("pi_sq uared");
Rhs* rhs=new Variable("pi");
Statement* code=new Assignment(lhs, new Multiply(rhs,rh s));
cout<<code->generate();

This is C++, not Java, loose the "new" abuse:

He's building a tree. That pretty much required dynamic
allocation.

// class Variable;
// class Statement;
// class Assignment: public Statement;

Variable lhs("pi_squared ");
Variable rhs("pi");
Assignment code(lhs, Multiply(rhs, rhs);

Unless you've got dynamic allocation of the nodes somewhere
hidden in the constructors, this is not going to work. And of
course, it doesn't work if the expression is the result of
parsing some external data either.

cout << code.generate() ;

// or
cout << Assignement(Var iable("pi_squar ed"),
Multiply(Variab le("pi"),Variab le("pi")).gener ate();

would produce:

pi_squared=pi*p i;

Your tree of object approach is probably superior as
complexity increases. For simple problems direct construction
in a string/ostream is likely to be sufficient but if you have
a lot of complex code generation to do, the cost of creating
the code object hierarchy is likely to be worthwhile.

Tree or not, you'll have to either build a string or generate
text directly into an ostream sooner or later. If I understand
the original poster correctly, his question concerned the
efficiency of using a string when the size of the code became
large; he's already solved his problem the source of the code
(tree or otherwise).

I'll admit that I generate a lot of code automatically, and I've
never used a syntax tree to do so. But most of the code is just
tables, or a function with a single switch statement (which is
also a table of sorts). Or the code is generated from a
template (general sense of the word, not a C++ template).

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Juha Nieminen]

Pascal J. Bourguignon wrote:

No, you should not use strings to generate code. Code is a syntac
tree. You should have a tree of objects:

Why make things more complicated than necessary? You converted his
easy-to-read code into a mess of pointers and dynamically allocated
objects. What for?