" 

 Andy, do you have a problem with reading? Or understanding what you read? Dyslexia perhaps? Or are you intentionally misreading or ignoring what seems to be clearly written? 

 First of all, you keep confusing the items I provided you about the Forth metacompilers. These are 4 separate items: 

 :Forth  is a computer language, sometimes implemented with its own metacompiler 

 :the Forth Metacompiler  is a metacompiler, completely separate from the Meta family of metacompilers... it makes use of the unique characteristics of the Forth language for its implementation 

 :MetaStic  is a metacompiler derived from the Forth metacompiler which was created to implement Elastic, which is not the same as MetaStic; the first version of MetaStic was the bootstrap version of the MetaStic metacompiler which would only compile itself, clearly stated on that page; it was used to compile successively stronger versions of itself until it was able to implement Elastic 

 :Elastic  is a subsystem of code, originally written in assembly language but later re-written in the MetaStic metalanguage so there could be a Forth version, so it would be more portable... from the MetaStic documentation: 
 ::""Elastic was a subroutine threaded system, hence the STIC as acronym of Subroutine Threaded Interpreter/Compiler. What the ELA was for, i can't remember anymore. Even though MetaStic is not subroutine threaded any more, the ""Stic"" part of the name just stuck."" 

 Why you keep muddling the 4 of them and claiming they are the same thing, I do not know, but I'm beginning to suspect you are trying to avoid the truth that other systems of metacompilers exist. Either that, or you can't read or you are unable to deduce what is obvious and apparent. 

 Next, I don't know why you keep going on about generative grammars vs. analytical parsers etc. etc. I don't think metacompilers have to make a commitment to either one, and frankly I don't care. When I say: 

 :""A metacompiler is defined by a set of grammar productions defining itself"" 

 you seem to think I'm talking about generative grammars and thus excluding Meta-II. I assume you are misreading the term ""grammar production"". 

 :Note: ok, I changed the word ""productions"" to ""production rules"", maybe that clarifies things a little better... the Wikipedia page though is titled ""Production"", not to be confused with ""Production system"", a type of Artificial Intelligence system based on production rules... hmmmm, i wonder if anyone has tried writing a metacompiler as a production system... hmmm...    

 A grammar production is a computer science term referring to rewrite rules (which you would have understood if you had followed the links). This is exactly how the Meta-II family of metacompilers are written: a set of grammar productions. You yourself have included some of them here: 

 :expr = term (('+':ADD|'-':SUB) expr !2 |.empty); 

 That's a grammar production. I said ""set"" of grammar productions because (1) they have to be unique in the set, and (2) they are unordered, that is, you don't have to specify what order they get executed, that is implicit in the grammar itself. 

 For further clarification:  (from the Context-free grammar article) 

 :In formal language theory, a context-free grammar (CFG) is a formal grammar in which every production rule is of the form 

 ::V → w 

 :where V is a single nonterminal symbol, and w is a string of terminals and/or nonterminals (w can be empty).  

 The Meta-II family of metacompilers are context-free grammars as far as I know, but metacompilers in general don't have to be. I myself have written a bootstrap version of Meta-II which was a finite-state grammar (less powerful than context-free), but it didn't require a stack like the usual Meta-II implementations. It worked on the basis of nested rules to handle expression nesting, could only process nesting as deep as I had provided rules (usually around 3 or 4 deep), but was sufficient for light-weight parsing. And that limited balls-cut-off version of Meta-II which I implemented I believe is equivalent to the Regex parsers and that PEG crap you go on about. Which means for real metacompiler usage it sucks donkey balls. 

 But because it was a metacompiler, I could write successively more powerful versions of itself, in its own language, which eventually (within 3 generations of itself) became a full-blown CFG metacompiler with non-limited nesting. (I say non-limited, because theoretically it was unlimited, but due to the reality of the depth of the stack, CFG grammars are always limited by how much stack memory is allocated). 

 But the point is,