🚀 go-pugleaf

In article <423cuc$tab@harbinger.cc.monash.edu.au>,
Mr A. Walker <junaid@silas.cc.monash.edu.au> wrote:
>James Kanze US/ESC 60/3/141 #40763 (kanze@lts.sel.alcatel.de) wrote:
>: 
>: Actually, I doubt it.  Normally, the format string in production code
>: will not be a string literal, but rather something read from a
>: configuration file, dependant on the locale setting.
>: 
>: Or do you really think everyone in the world can read English
>: fluently.
>
>	This run-time dynamic behaviour is unique to sprintf() and
>friends. There is no way to implement this using cout, becuase the
>implicit formatting specification is unknown at compile time. There
>for C++ streams are in fact more restrictive than the C lib I/O .
>
>Junaid

I assume you are talking about an interface like

  MessageId.H:
  ------------
	enum { DOOR_LOCKED, MONSTER_SEEN, ... } MessageId;

  Message.H:	
  ----------
	#include "MessageId.H"
	void message(MessageId, const char* fmt, ...)

with some data file that is compiled to produce MessageId.H, and also
a run time database of message formats for various languages.

For C++, I would compile the data file to produce a class definition
for each message, instead of just an enum identifier, e.g.

  Messages.dat:
	FoundObjectMsg(string color, string type) {
	  ENGLISH(There is a %s %s here,1,2)
	  SPANISH(Aqui esta un %s %s,2,1)
	}

  Msg.H:
	class Msg
	{
	  static void setLanguage(Language l) {
	    language = l;
	  }

	protected:
	  void print(int msg, ...) {
	    vprintf(format(msg, language), arglist)
	  }
	private:
	  Language language;
	}
	
  Messages.H: (generated code)
	class IllegalEntryMsg : public Msg 
	{
	private:
	  enum { msg_no = 1717; }
	public:
	  IllegalEntryMsg(const char* field,
			  const char* data)
	  { 
	    print(msg_no, field, data);
	  }
	}

Sorry for my pathetic monolingualism.

This scheme is typesafe, and no more expensive in time or space
than non-typesafe methods.  There is a minimal cost at compile time.

I haven't implemented this yet.  If anyone actually implements
a compiler to convert message definitions into class definitions,
please let me know.

-- 
Kevin Cline