The second least effort is to use a CPAN module that implements a minilanguage.

Or of course you can write a parser for it (if it's really mini that's going to be easy) and a backend.

The exact approach varies greatly on what you actually want your minilanguage to do.

For a parser I wrote, have a look at How to parse a limited grammar and A parser for a limited grammar. Beware, this was not trivial, and it left me with the greatest respect for language designers.

Clint

"Security implications"? Surely it would be just as secure as everyone's favourite language: Perl.

That aside, here's an implementation (complete with syntax checking) for the mini-est language I can think of.

$_ = <>;
die "Syntax Error\n" unless m/^[10]$/;
die "Syntax Error\n" if defined <>;
exit $_;
[download]

I'll leave it up to you to work out what the valid input is.

--
use JAPH;
print JAPH::asString();

There's a really good book, (free online html or pdf download), on developing a programming language using Perl:

Exploring Programming Language Architecture in Perl by Bill Hails.

There are also a couple of threads around here somewhere that refers to it, but I couldn't find them just now.

billh's writeups works for me. ;-)

HTH,

planetscape

avast claims that the link is malware :(

A Trojan Horse Was Found
...
File name:    http://billhails.net/Book/
Malware name: JS:Agent-AV [Trj]
Malware type: Trojan Horse
VPS version:  090216-1, 16/02/2009
[download]

So take care

The link itself? Something on the page pointed to? Something linked to from the page pointed to?

Google doesn't flag it?

What's "avast"? An how much faith do you have in it?

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

"Too many [] have been sedated by an oppressive environment of political correctness and risk aversion."

One approach I've used for really simple languages is a command hash. The keys of the hash are commands and the value is a code ref that executes the command. This approach is really not very flexible, but it fills the niche below a full scale language implementation.

my %command = (
    foo => \&do_foo,
    bar => sub { print "doing bar with parameters: @_\n"; },
  # ...
);
[download]

If you decide you really need a language, rather than a set of commands, look for parsing modules on CPAN.

The best advice I ever got on this issue was to write some examples of how you would use the language if it worked like you want. Then, go make it look like that.

Without some idea of the complexity of the language you want to implement, it is hard to guess which tool would be the least effort.

action article target "\n"
action ::= "WALK" | "FEED" | "PLAY WITH"
target ::= "DOG" | "CAT" | "CANARY" | "FISH"
article ::= "A" | "THE"
[download]

Language samples would look like this:

  WALK THE DOG
  FEED THE CANARY
  PLAY WITH A FISH
[download]

and a parser (sans error detection) could be as simple as this:

use strict;
use warnings;

while (my $sLine = <DATA>) {

  my @aFields = split(/\s+/, $sLine);

  #the general case
  my $sAction = shift @aFields;
  my $sArticle = shift @aFields;
  my $sTarget = shift @aFields;

  #special cases - PLAY WITH has two tokens
  if ($sAction eq 'PLAY') {
    $sAction .= " $sArticle";  #$sArticle is 'WITH'
    $sArticle = $sTarget;      #$sTarget is an article
    $sTarget = shift @aFields; #target never got read
  }
  doSomethingWithStatement($sAction, $sArticle, $sTarget);
}

sub doSomethingWithStatement {
  my ($sAction, $sArticle, $sTarget) = @_;
  print "action=<$sAction> article=<$sArticle> target=<$sTarget>\n";
}

__DATA__
WALK THE DOG
FEED THE FISH
PLAY WITH A CANARY
[download]

Of course, for production purposes you would probably want to do some error checking. Also you might want to make certain combinations of verbs and targets illegal. For example, it doesn't make much sense to "WALK A FISH". And if you really want to get fancy you can explore the wonderful world of lexers. But hopefully this will illustrate the basic idea.

I wanted to provide you with a link to an easy to understand non-jargon filled article on designing an easy to parse language, but I'm having little luck googling for that. Perhaps another Monk with better search term fu can help you with that.

Best, beth

<geezer_mode><irrelevent_mode>

Some years back (late 70's?) in an issue of Byte (IIRC) there was an amusing article called "Watduzitdo?" (or something similar) in which the author implemented a simplified version of Pilot in a mere 256 bytes of assembler.

I remember spending an amusing afternoon modifying it to run on a brand-new TRS-80...

</irrelevent_mode></geezer_mode>

...roboticus

Anecdotal evidence: I wrote a sort of "miniperl" interpreter that I believed (or lets say hoped) to be secure by transforming and filtering the miniperl into executable perl and using eval to execute it. It operated upon a hierarchical set of hashes and was crippled down to essentially mathematical operations, strings, control structures and calling of functions I allowed or provided.

It was for a local management program for a play-by-mail space opera game, so security was not really necessary, just a bonus so that config files could be exchanged between player and game master without worries

A typical example of what it did:

#bi is population index
planet 'Taurus I' : bi+= 200+10*3 : system.scoutdata='Heavily armed'
system taurus : code { if ( scoutdata eq '' ) { owned=1 }  }

translated to:

$planet{'taurus i'}{'bi'}+= 200+10*3; 
$planet{'system'}{'scoutdata'}= 'Heavily armed';
if ($system{'taurus'}{'scoutdata'} eq '') { $system{'taurus'}{'owned'}
+=1; }
[download]

All the hashes were tied so that the %system-hash of a planet could be reached by simply saying system.something= .... This made it possible to do consitency checks or further actions when a variable was changed. Also if a variable like 'owned' was configured as hierarchical, not only was taurus.owned set to 1 in the example above but also the 'owned' of every planet in this system, i.e. 'taurus i'.owned would have been set too

As you can see I had to exclude most of the special characters from my language, especially all the sigils. Since arrays or hashes couldn't be specified directly, looping was only possible through function calls. No regex was possible

It was fun programming it, but you really have to cripple the language to put perl into a sandbox (and I still can't be completely sure I plugged all holes). While it fitted my needs in this case perfectly, I wouldn't really trust it on a public interface in the web for example

By the way, I used Parse::RecDescent for the parsing of the language (actually it was really two languages that were parsed)

I just came across this article in January's ACM Queue online magazine:

Mike Shapiro: "Purpose-Built Languages."

Tagline:

While often breaking the rules of traditional language design, the growing ecosystem of purpose-built “little” languages is an essential part of systems development.

Here's a blast from the past: Ook interpreter.

if xml is ok as syntax, then I have found using XML::Descent to be simple enough to grok and use.