Talk:Metacompiler - Knowledge (XXG)

2203:/****************************** _Toknadv *******************************\ * * * THE SIMPLEST FUNCTION HERE * * * * Puts a matched character on the token in the token buffer * * then advances the input stream jumping ti _Advance * * * \************************************************************************/ __declspec(naked) void _Toknadv() {_asm { xchg ecx,dword ptr tokenptr // get tokenptr mov byte ptr ,al // put character in TokenBuf inc ecx // Advanced tokenptr mov byte ptr ,0 // clean display when debuging xchg ecx,dword ptr tokenptr // get tokenptr or TokenFlg,TokenWhiteSkip // disable skip_ch ski ping jmp _Advance // Advance input pointer, At end of input return null // _Advance is parse stream input function }} /************** Set up functions for cc matching function **************\ * * * cc matching function are called by token making and grammar rules to * * match strings and characters in the input stream. * * * * !! This s assembly code in a C++ wrapper !!!! * * * * __savePntrs: * * * * __savePntrs is called on entry by string match function to save the * * input stream state required to Back Track a failed match. Matching * * functions are not re-entrant. States do not need to be stacked. * * Objects are not put on the parse stack or node stack by them. Back * * Tracking is only done when they do not succeed. Only the input * stream state is saved statically. * * * * On success a match function simply returns success. On failure it * * must restore the input stream state. To restore the input stream * * it simply jumps to __rstrPntrs. * * * * jmp __rstrPntrs * * * * __rstrPntrs: * * * * __rstrPntrs is always jumped to on failure by a matching * * function and only restores the input stream state * * * * The tokening skipclass is also affected by matching functions When * * called from a token rule a match will set the partial match flag * * that prevents further skipclass skipping. The flag may only be set * * when a token rule is active. * * * * The input stream is a series of files. An FCB (file control block) * * is used to track files. FCBs are linked in order as given on the * * command line. An FCB basically manages file buffers. File buffers are * * also linked in the order filled. In put file buffers are read from * * files as the parse rules progress through the input. The FCB status * * keeps the file state. Opened and end of file reached. Error flags * * generate a compile error. The stream position is a set of pointers. * * The data pointer points at the current input position in a file * * buffer. The BCB pointer points at the current file buffer. The data * * count holds the number bytes processed. It is needed so as not to * * re-output characters to the print stream. * * * * The token and input stream saved state are as follows: * * * \***********************************************************************/ //__CC_FCBDCB mark0; // saved input steam state __CC_DBCH* markbufr; // buffer header pointer char* markdataptr;// data pointer short markdatacnt;// bytes remaining in buffer; char* marktokenptr; BYTE token_stats; int stream_inputcnt; char* strng_parm; __declspec(naked) void __savePntrs(){_asm{ // crazy stack manipulation!! /***********************************************************************\ * __savePntrs saves input stream state for string match function. * * * * push offset <string address: --> 2216:* * NOTE. __rstrPntrs will restore callers ecx. Do not pop ecx * * * * ecx only need be popped on success before a return. * * pop ecx // needs restoring * * ret // before a successful return * * * * NO POP ECX before: * * jmp __rstrPntrs // ecx will be restored by __rstrPntrs * * * * Input stream state saved. * \***********************************************************************/ }} // ************************************************************** // ********* NEVER EVER CALL THIS FUNCTION EVER NEVER ********* // __declspec(naked) void __rstrPntrs(){_asm{ // match string reset input stream. // !*!*!*!*!*!*!*!*! COMMON FAIL EXIT CODE !*!*!*!*!*!*!*!*! // !*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*! // !*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*! // !*!*!*!*!*!*!*!*!*!*!*!*! NOTE! !*!*!*!*!*!*!*!*!*!*!*!*! // !*!*!*!*!*!*!*!*!*!*!*!*! NOTE! !*!*!*!*!*!*!*!*!*!*!*!*! // !*!*!*! __rstrPntrs is always jumped to with saved !*!*!*! // !*!*!*! ecx left on the stack to restore on exit. !*!*!*! // !*!*!*! THIS FUNCTION IS ALWAYS JMPed to !*!*!*! // !*!*!*! NEVER EVER !! CALLED !! NEVER EVER !*!*!*! // !*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*! // !*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*!*! mov eax,stream_inputcnt mov __inputcnt,eax mov eax,marktokenptr // Restore Token pointer mov tokenptr,eax mov al,token_stats mov TokenFlg,al // State restore includes token flags mov ecx,InPutFCB // point ecx at FCB mov eax,markbufr mov FCB_bufr(ecx),eax // (+2) save buffer pointer mov ax,markdatacnt mov FCB_datacnt(ecx),ax // save data count mov eax,markdataptr // mov FCB_dataptr(ecx),eax // movzx eax,byte ptr pop ecx ret }} 2232:

dgt $ dgt MAKINT; // decmal number char _str_0B = "0B"; char _str_0b = "0b"; char _str_0O = "0O"; char _str_0o = "0o"; char _str_0H = "0H"; char _str_0h = "0h"; char _str_0X = "0X"; char _str_0x = "0x"; __declspec(naked) void integer() { _asm { call _TokenEntry // ("0b"|"0B") bin bin* MAKEBIN() push offset _str_0B // "0b" call _CmpStr je l1 push offset _str_0b // "0B" call _CmpStr jne l5 l1: test CHARCLASS,bin // ('0' | '1') jne l3 cmp esp,0 ret l2: test CHARCLASS,bin // ('0' | '1') je l4 l3: call _Toknadv jmp l2 l4: call MAKEBIN ret l5: push offset _str_0O // "0O" call _CmpStr je OCT push offset _str_0o // "0o" call _CmpStr je OCT push offset _str_0H // "0H" call _CmpStr je HEX push offset _str_0h // "0h" call _CmpStr je HEX push offset _str_0X // "0X" call _CmpStr je HEX push offset _str_0x // "0x" call _CmpStr je HEX l6: test CHARCLASS,dgt // Looking for a digit. jne INTG // If it is a dgt goto INTG test CHARCLASS,skipclass // Not a dgt test if skipclass je l7 // jump is not skipclass call _Advance // advance over skip class jmp l6 // loop looking for first dgt l7: cmp esp,0 // failure return NE status ret o1: call _Toknadv OCT: test CHARCLASS,oct jne o1 jmp MAKEOCT h1: call _Toknadv HEX: test CHARCLASS,hex jne h1 jmp MAKEHEX INTG: call _Toknadv // matched a digit copy to token buffer. test CHARCLASS,dgt // is it a dgt? jne INTG // loop until not a dgt jmp MAKEINT // amd then make a numeric object. }}

1765:

digit string and converting it to binary. And a output routine with a bit a glue code for testing inputting a number and outputting the result. The DEC-10 was a unique machine having 16 36 bit registers. Any of which could be used as a stack pointer. Even as a call stack. So it was a simple mater to write a recursive parser. It basically input numbers and recognizing operators calling functions implementing a recursive decent parser. Anyway he was amazed. That amazement lead him to getting his degree. Years later I visited my old collage and he was teaching their. So we talked a bit. And the old calculator project came up. He said it took years to fully understand it to the point he could do it. He was using it in teaching parsing to his students. He no longer thought it so amazing. A fellow programmer I worked with wrote a binary tree balancer that is almost incomprehensible. This was also on a DEC-10. It used two separate call stacks. It had two co-function that called each other. Each function called the other function or it's self on one of the two stacks depending where it was at in the code. It worked great. I used it. I figured it out but have forgotten the specifics. Now that was mind-bending. Following the code one routine would return on a different stack then it was called on. Now that was really mind bending. But hay it worked.

2193:" * */ void __declspec(naked) _CmpStr(){_asm{ //_CmpStr = "..." call __savePntrs // returns ZF and ecx = char* "..." je l2 // ZF = NOT skipping skipclass cmp byte ptr,0 // if (end of string) jne l4 // then ir's a match jmp l2 // in token match not skipping skipclass l1: test CHARCLASS,skipclass // source stream a skipclass char? je l5 // -skipclass failure if not null string call _Advance // advance over skip class chars jne l6 // unable to advance is failure l2: cmp al,byte ptr // source char match string char jne l1 // if not matched keep looking // ******* matched first character rest of string must now match l3: cmp byte ptr,0 // if (end of string) je l7 // then ir's a match inc ecx // inc string pointer call _Advance // advance input stream next char jne l5 // unable to advance is not success l4: cmp al,byte ptr // source char to string char je l3 // jump of mach l5: cmp byte ptr,0 // if (null string) je l7 // then ir's a match l6: cmp esp,0 // return ne failure jmp __rstrPntrs // got here ne failure l7: test TokenFlg,Token_Going_On // In a token rule? je l8 // If YES -- or TokenFlg,TokenWhiteSkip // Stop skipclass skipping l8: pop ecx // restore user ecx cmp al,al // return == ret // return match eq condign }} 2213:* * * * Stack now as above with ecx *string parameter from on entry * * * \***********************************************************************/ mov strng_parm,ecx // string parameter saved mov ecx,InPutFCB // point ecx at FCB mov eax,FCB_bufr(ecx) // (+2) save buffer pointer mov markbufr,eax mov ax,FCB_datacnt(ecx) // save data count mov markdatacnt,ax mov eax,FCB_dataptr(ecx) // mov markdataptr,eax // mov eax,__inputcnt mov stream_inputcnt,eax // mov al,FCB_status(ecx) // // mov markstatus,al // mov al,TokenFlg // save current flags state mov token_stats,al // so can be restored on fail // Got TokenFlg skipclass state. Matching can not skip skipclass once any // characters have been matched. That state is passed back to the matching // function in the zero status flag by the following test instruction. test al,TokenWhiteSkip // z flag = state of WhitSkip mov eax,tokenptr // Save Token pointer mov marktokenptr,eax // after TokenWhiteSkip mov eax,FCB_dataptr(ecx) // movzx eax,byte ptr // get current BYTE mov ecx,strng_parm // point ecx at string parameter ret /***********************************************************************\ * * * On return to caller: * * * * original <return from _matching function_: --> 2157:

examples _CmpStr was called. The total code involved in that _CmpStr is two pages or more of code. It's not just a simple compare char string function. The meta compiler did not compile the run-time code. So really a metacompiler does not compile it's self into an executable program. There is many more lines of code in the compiler run time library than in the metalanguage source of the metacompiler. I downloaded the ACM CWIC paper. And learned some things about CWIC I did not know. One is that the SYNTAX language compiler was a separate compiler form the generator compiler. SLIC was a single compiler handling all of it's five language forms. The cc compiler is the same. But as I have explained. I no longer consider them to be separate languages. They are no more separate languages then a class declaration is a separate language from C++. An analogy is that syntax is the input description like a record definition is to COBOL. A lot more complicated but still it an input definition.

875:

think he understands it. And on top of that, he constantly misrepresents what I have written with his mish-mash of compiler theory just to prove I'm wrong and I don't know what I'm talking about. I've taken both undergraduate and graduate classes in compiler theory, as well as 2 practicum classes in which we built little mini compilers for the experience and to see how it's really done. And then later I encountered Meta-II and its derived metacompilers, which were barely touched on in my academic classes, and I was overwhelmed how simple and powerful the concept is. I have used metacompiler tools in my software engineering work for the past 30 years. That's why I promote this technology. And that's why I don't want to see the article here muddled by a self-promoting retired tech person who wants to make it about their own personal history.

1783:

separates it from the rest of the so called compiler compilers. It is the metalanguage programming that makes a metacompiler different from say a C++ compiler written in C++. The metalanguage, if designed right, is a readable description of the parsing and code generation processes. There in a language designed to express a readable language compilation. That is amazing. It's amazing that you can control the tree generation. It's a simple matter to generate a right or left handed tree. The difference is in how the rule is written. Using recursion or a loop construct. You do not have to change a complicated parser written in C or some unsuited language for the task. But that may be to specific to Schorre's work. The analytic grammar used in Schorre metacompilers is very readable.

3081:

the first editor summoned, but i expect others were summoned but didn't even try. So i ask both authors to summarize your point of view in less than 500 words, so other editors can assist. Linguistically a metacompiler compiles compilers and a compiler that can compile itself would be an autocompiler. But common usage may have deviated, so both please summarise your arguments for the notability of either definition. Note that I'm no computer scientist, nor should i need to to understand your summary. And please, both of you, don't take this discussion personal.

2078:.SYNTAX PR0GRAM = $ (ST | DECLARATI0N) '.END' ; DECLARATI0N = ID '=' NUM ';' :EQU!2 DECL; ST = ID ':=' EXP ';' :STORE!2 C0MP1LE; EXP = TERM $ ('+' TERM :ADD!2); TERM = FACTOR $ ('*' FACTOR :MPY!2); FACTOR = ID / '(' EXP ')' /NUM; LET: 'A'/ 'B'/ 'C'/ 'D'/ 'E'/ 'F'/ 'G'/ 'H'/ 'I'/ 'J'/ 'K'/ 'L'/ 'M'/ 'N'/ 'O'/ 'P'/ 'Q'/ 'R'/ 'S'/ 'T'/ 'U'/ 'V'/ 'W'/ 'X'/ 'Y'/ 'Z'; DGT: '0'/ '1'/ '2'/ '3'/ '4'/ '5'/ '6'/ '7'/ '8'/ '9'; ALPHNUM: LET / DGT; ID .. LET $ ALPHNUM; NUM .. DGT $ DGT MAKENUMBER; .F1N15H .STOP SETUP PROGRAM 2064:

entirely in CWIC. I changed the CWIC example to use the unparse rules exactly as illustrated in the interpreter example in the ACM document. Well not quite I didn't use vectors. True it is not stated that the CWIC generator is LISP 2. Others at the ACM meeting recognized it and Erwin acknowledged it was. In the TREEMETA document I found some metacompiler history explaining that at CDC BOOK4 and BOOK5 were metacompiler written in LISP 2. In fact TREMETA document has a wealth of information on early metacommpilers.

664:. It has conflicting description with the well known metacompilers and would exclude them as they are analytical parser languages not using a generative parser as stated in the article. All references given are to the analytical parsers, None of the metacompilers talked about here have a generative syntax description language. Our main argument is the idea of a metacompiler compiles it self. There is no example of even one such compiler having a generative syntax language given here. 1341:

definition part pertaining to the meaning of metacompiler. The other uses I did not intend to change. The explanation that meta compilers can be used for other functions would be unchanged. I am not really changing the actual meaning all that much. It's more a rearrangement making the discriminating attribute: taking a metalanguage as input that specifies or directs the transformation the input language into another form, which may be executable code.

2450:. That one link would eliminate most of the existing metacompilers. The statement was that if he keeps that reference there are few if any metacompilers left. It eliminates all of Schorre's metacompilers. They all use analytically grammar. He obviously does not understand the difference between the types of grammars. He thought I was talking code production rules. Really. He made a change to code production. It's here. posted by him. Does 381: 130: 2243:

22: 832:

claiming over and over that we got wrong here, thus nullifying our use of the term "metacompiler". The Forth reference also shows that the Forth community has its own line of metacompilers, satisfying his repeated request to show any other example of metacompilers besides the ones he's pushing. Despite providing this evidence, Steamerandy continues to deny and obfuscate this obvious data countering his claim.

2236:

every alternate is not a skip class character and skip skip skipclass characters before trying to match the first token character. _TokenEntry intercepts the return of the rule calling it. On failure it restores the input stream state. On success it creates a symbol if an interceding conversion function has not been called. MAKEINT, MAKEHEX, etx are conversion function that intercede the making of a symbol.

71: 53: 2200:" All identical to CWIC functions execpt SLIC can match skip_class characters where CWIC first skips skip_class characters, SLIC skips skip_class character while searching for the first character. A skip_class character may be explicitly matched by SLIC and cc. This for example could to match a line break before a symbol. Assembly labels often are anchored to the front of a line. 762:

dragging up a mish-mash of related topics which he claimed refuted what is stated in this article. He keeps throwing in random references to theory articles and concepts which he claims counters what I have written here. He even disputes basic terminology, like metacompiler and bootstrapping, which have been standard terms of art in the computer field for at least 50 years.

2132:

CONTAINS clause to use RECORD where the spec required ('RECORDS' / .EMPTY) In the program the FILE CONTAINS clause was followed by a RECORD CONTAINS clause. The file contains clause took the RECORD of the record contains as being part of the file contains clause and not recognizing CONTAINS produced an error. Less then a 10 min fix. The file contains clause ended matching

450: 817:, this RFC concerns me greatly. He seems intent on imposing his limited views, he won't accept the fact that others have also created metacompilers, and he continues to deny concepts long accepted in Computer Science -- it's almost as if he believes he's the only expert in this field, and if he hasn't heard of something then it must not exist or is bogus. 606:. Both are bacicly formal grammer topics. The production link describes the formal process of build strings of a formal grammar. It is gibberish as there is no semantic process in the description, but is being implied by the phrase "production rules". Many metacompiler take as input analytic grammars and not production (formal) grammars. -- 1774:

thing is the ease in which a compiler or some other language processing application can be written using a metacompiler. And by the way the calculator writing episode happened over 40 years ago. It didn't take me a life time to learn how to write compilers. I have been writing compilers for over 44 years.

2650:

He keeps trying to show that key points in the article are wrong, but as far as I can tell it's based on his misreading of the info and a failure to keep up in this topic over the years, except for his own little narrow slice of the technology -- I have encountered his type before, if he doesn't know

2557:

knows how to flap his jaws showing what he does not know. That is a FORTH FREAK characteristic is it not? One would think that such a learned individual should be able to navigate the web to check out the references they gave. A computer scientist should know about the grammar types should they not?

2421:

WRONG AGAIN. I am most interested in getting rid of this ignorant idea that a meta compiler must compile it's self. It is unfounded in real computer science literature. FORTH is a dead fringe language. Bury it where the sun don't shine!! The only legit definition of metacompiler in the ACM archive is

2231:

void integer(); // .. ("0b"|"0B") bin $ bin MAKBIN // binary number // |("0o"|"0O") oct $ oct MAKOCT // octal number // |("0x"|"0X"|"0h"|"0H") hex $ hex MAKHEX // hex number // |

1798:

link on the metacompiler page. But what it does show is my adversary's lack of understanding of computer science terminology. He just can't seam to grasp what I am talking about. I discovered the problem when doing my proposed change. I check every link I used. My proposed change avoids that problem.

1575:

Note. this is only to replace the first part of Metacompiler topic. The historic content and below is not to be changed. Mote Need to find a more suitable string processing description. For the most part string processing has to do with comparing constant static strings against the input. Symbols are

927:

878:

If you read my comments you will see that I have at times been gruff in my responses, but the guy shows up and immediately insults me on my own Talk page, ridicules the topic and the article, ridicules sincere responses I have posted on this Talk page, and blusters about how everything should be done

761:

I continually tried to respond to Steamerandy's complaints by citing references here on Knowledge (XXG) and elsewhere on the web. His belligerence seemed to escalate. He continually muddled and misrepresented my responses and references. At one point he seemed to start researching on Knowledge (XXG),

656:

A more defining definition should be along the lines of metacompiler compiling a metalanguage. The description of a metacompiler compiling a metalanguage is stated in ACM documents that can be found in the ACM archive. Other document on meta compilers also saying the same are: TREEMETA documents from

488:

been hostile, referring to other editors as their adversaries. This RFC is being closed as no consensus, which means no change to the existing article. Either another RFC should be published, with a question as to whether to include a statement in the article, or the parties can take their issue to

3080:

Summoned by bot. For the amount of text that was written here, the article on metacompilers isn't very well written regardless of the definition. But about this rfc: you can't expect other editors to read through this whole talk page, i might as well read a book on metacompilers. I don't know if I'm

2757:

The first two metacompilers made by Schorre were called "Meta" -- Meta-I and Meta-II. I believe Schorre named his metacompiiler "Meta" after the term "metacompiler", just as Microsoft named their word processing program "Word". It seems Steamerandy believes the opposite, that "metacompiler" is named

2144:

Added a peek ahead that checked for a RECORD CONTAINS clause. All fixed. There was still the problem of the COBOL programmers having not tested their programs using the DEC COBOL compiler. But that is another story. What kind of a parser is this anyway? That was a quick fix to get the project going

1658:

a PASCAL compile, Writing a P-code interpreter from scratch. Hand compiling a PASCAL compiler into p-code. Compiling the PASCAL compiler that was hand coded into P-code using the hand coded compiler. Modifying the PASCAL compiler to generate assembly language and creating a run time support library.

1363:

The misguided idea: "The feature that sets a metacompiler apart from a standard compiler-compiler is that a metacompiler is written in its own language and translates itself." is not a defining feature of a metacompiler. Many many compiler are written in the language they compiler. C++, C, ALGOL and

882:

I appreciate the fact that Steamerandy follows the Knowledge (XXG) rules and is contributing. He is obviously passionate about the topic, albeit in a very narrow-minded tunnel-vision way. I have even offered multiple times to help him with his current project he calls cc (for compiler compiler), and

869:

It's almost as if it's important to him to show that I am somehow wrong about something. His latest attempt at this is this RFC, an attempt at replacing what I and others have written here with his own hacked together parochial view of this topic, with emphasis on his own pet technology, the Meta-II

865:

But additionally, I have seen over and over that he makes mistakes, atrocious mistakes, in his grammar and his spelling and his examples. When I can understand them, there also seem to be flaws in his claims and his arguments. And when provided with facts disputing what he says, he usually denies or

769:

765:

Steamerandy just wants to get his way. He is a very strong proponent of the Schorre family of metacompilers and seems intent on making this article just about that narrow group of metacompilers. There is a long, albeit it thin, line of research and real-world application of metacompilers in Software

757:

I don't mind someone challenging what I write based on superior information, but he seemed intent on denigrating and denying anything I wrote based on my background in Computer Science, which includes Bachelors and Masters degrees in Computer Science. Everything I write here is based on my education

644:

in Computer Science as described by fringe Forth language proponents. I cannot find any reference to the term meta-step in any Computer Science publications. It is only found on some Forth programming sites. When there was a SegForth group in the ACM it was supported by the SegPlan group and made up

2156:

I have given examples here on the talk page of code generation from the syntax language based on my personal knowledge. They illustrate how easy it is to hand compile the analytically syntax rules used in CWIC or TREEMETA into assembly code. The point being: It is not mind bending. In some of those

1790:

Having never written a commercial compiler my adversary keeps trying to dump on me. I am sure there are many game developers around who have used one of my compilers. Kontron development system were used to write many Atari games. Using the 6502 assembler or PASCAL cross compiler. I was head of the

1764:

Years ago I had a student come to me for help with a personal project. A simple command line calculator. It had to handle numeric algebraic expression hierarchy. This was on a DEC-10. So we set down and coded it up in assembly. Took about a half hour explaining exactly every steep. First imputing a

1663:

the original P-code PASCAL compiler into a machine executable compiler. Further modifying the compiler adding linkage declaration making it modular. The PASCAL compiler has got all the same attributes that my adversary claims to make a meta compiler different from other compiler compilers except it

857:

So this is a common pattern: Steamerandy misconstrues or misunderstands what is written in the article or in my responses to him, and then based on that misunderstanding claims it is wrong. He then dredges up a mish-mash of stuff from other Knowledge (XXG) pages, posts it as a response on this Talk

737:

His expertise is largely based on a dead project from 50 years ago, and documentation now classified as secret and therefore unavailable to any of the rest of us. I call it a dead project, because after the government made it Classified, no more information about the project became available to the

2209:

to _matching function_ * * * * rearrange stack: Stack on entry as above * * * * preserving the calling rule's ecx * \***********************************************************************/ xchg ecx, // swap ecx for _matching function_'s return xchg ecx, //

2174:

string match in the syntax specification. (This is some mind-bending assembly code) A lot of stack manipulation going on. Fairly simple compared to re-entrant backtracking function. EBP is used as a backtrack pointer by the syntax rules. Basicly a nested longjmp into the backtracking support code.

2092:

Note I didn't talk about the vectored (#V1) pattern matching used above. Where EVAL matches the ADD and MPY nodes using CWIC vector operator #. It is obvious what the vectors do. Right! Note: CWIC specifies the driving rule with the ".STOP SETUP PROGRAM". SETUP is a MOL-360 function, called first

1782:

I believe that taking metalanguage source as input is the one single differences that separates a metacompiler from the rest. The fact that a metacompiler takes a metalanguage that not only defines the syntax of a language, it also defines the code produced by the language constructs. That is what

874:

made available and accessible too. He continually claims that my description of metacompilers invalidates the Meta-II family of programs he is so fond of, when in fact it is just the opposite. He continually misconstrues the facts, misrepresents the theory and its implications, and frankly I don't

2235:

This is not mind bending. You simply start hand compiling the source into code. In the process you figure out how the code generator needs to work. This hand compiling step is a learning process. I am not even trying to write optimized code. If I were I would recognize that the first character of

2161:

generation is compiled. But like most languages there is a large amount of support code that gets combined to make an executable program. This illustrates to some extent the amount of overhead code that is part of a real meta compiler and in this some complicated stack manipulation for a novice.

2131:

There was an incident with COBOL compiler written in SLIC. The DEC-10 COBOL syntax was used so program testing could be done on the DEC-10. When first released a bug was discovered. As it turned out the DEC compiler had exactly the same bug. DEC had deviated from the language spec allowing a FILE

2063:

I gave a reference to the CWIC ACM paper. There is little if any information about CWIC I have put on the metacompiler page that isn't in that paper. It talks about the generator language being able to manipulate trees before generating code. It has an example of a simple interpreter demo written

1846:

refers to a particular approach to the study of syntax. A generative grammar of a language attempts to give a set of rules that will correctly predict which combinations of words will form grammatical sentences. A formal grammar is a set of rules for rewriting strings, along with a "start symbol"

1340:

But the real jest of that change is relegating the self compiling to a much lower level. As the 40+ year old definition of a metacompiler does not even include compiling it's self. Maybe I wasn't clear in my proposed change. I wasn't proposing to change the other information on the page. Just the

733:

But then he started insisting that this article was wrong, challenged the title and thought it should be called "Meta compiler" instead of as it is now, "Metacompiler" as a single word. He repeatedly provided his biography at length, in several places here on Knowledge (XXG) on the different Talk

487:

NAC: This RFC was poorly constructed because it does not ask a question about the content of the article, and does not exactly even request comments about the content of the article. For that reason, the RFC was not likely to result in rough consensus. In addition, some of the participants have

2242:

2019:

28 Unparse Expressions 28A Syntax 2RB 28Al outexp = subout ('/ outexp / .empty); 28A2 subout = outt (rest / .empty) / rest; 28A3 rest = outt (rest / .empty) / gen (rest / .empty); 28A4 outt = .id ' I '( outexp ') I nsimpl (': (S / L / N / C) / .empty); 28A5 arglst = argmnt (', arglst / .empty) /

1835:

works as well. There are top down analytic rules defining the legal syntax constructs of the language. In the Schorre line of metacompilers there is a main driving syntax rule. Like main in C and c++. In Schorre's compilers there was a statement that specified the driving rule. ".SYNTAX PROGRAM"

1786:

This confusion started with yacc (Yet Another Compiler Compiler) calling it's self a compiler compiler. It really being a parser generator. As most so called compiler compilers are. Maybe yacc and the rest of the parser generators should be kicked out of the compiler compiler club. It would make

1773:

Why did I talk about the student above. I think it explains why my adversary finds writing a compiler from scratch so mind bending. He is like that student seeing it for the first time. Which I think should not be the position from which the metacompiler definition should be written. The amazing

831:

I believe the quotes from that Forth webpage above satisfies that complaint. It clearly states that a metacompiler "is a compiler which processes its own source code, resulting in an executable version of itself". Furthermore, it also disputes his definition of the prefix "meta-", which he keeps

2256:

The point of the above is to show the amount of run-time code compared to the metalanguage source code. All of the parsed or matched entities are allocated objects. The objects created sense a point of backtrack are released on a backtrack failure. Backtracking in the functions above are single

2173:

__declspec(naked) removes all preamble and exit code from the function. There is no code in the function other then that coded in the function source. EAX in most cases contains the current input stream character. The following code is to illustrate the run-time support code needed for a simple

1336:

are used in many of the known metacompilers. I noted this about Schorre languages and there are several web pages also saying the same thing. It does limit metacompilers to a class of parsers. But not to Schorre specificly ss my adversary is saying. I have no objection to changing that specific

770:

after those first programs of Schorre and there is nothing special about the term "metacompiler". He completely denies all the evidence I have produced backing up the idea that "metacompiler" is a basic concept long accepted in Computer Science and Compiler Development and Software Engineering.

749:

Not only that, he also showed up on my User Talk page, giving again his long technical biography, past glories and so on, and then proceeded to imply that I didn't know what I was talking about, and additionally saw fit to insult and belittle myself and my experience. He wrote "Looks like I was

2758:

2260:

The metacompiler this is from is designed to generate binary code for any target machine architecture. So it has a bit more of a run-time library. Numeric values are indefinite precision objects. For example the target processor could be a 32 bit machine and the compiler is running on a 16 bit

2165:

will probably say it doesn't work because he likely wont understand it. Admittedly exchanging a function return address and moving relative to the stack pointer is not commonly done. A majority of my programming has been in assembly. But the minor stack rearranging going here is trivial to the

2160:

This is from a metacompiler I am working on. Basically an updated implementation of SLIC. For the time being I am calling it cc. I am using naked C++ void functions as assembly function containers. The point here is the amount of code not compiled by the compiler compiler. The parsing and code

1620:

I have pointed out to my adversary that his own references talk about metacompilers implemented in other languages. One in assembly and another implemented in PL/1. These were not written in them selves. They do not compiler them selves. The one written in assembly is not a metacompiler but an

1552:

A full development package would include a linker and a run-time support library. Usually a machine oriented language is required for writing the support library. Today C or C++ might be used as a machine oriented language. A library consisting of support functions required for the translation

849:

I believe he misconstrues the meaning of "grammar productions" to mean something having to do with generative grammars instead of analytical grammars. In fact, the term "grammar production" is a term of art from computer science referring to transformation rules, which are used in all kinds of

809:

Here the Forth community uses the term "metacompiler" as it has been accepted for 40 years. Yet Steamerandy seems to claim the Meta family of metacompilers from Schorre are the only metacompilers, and even disputes the word "metacompiler" as a vaild term and concept in Computer Science. When I

802:

A metacompiler is a compiler which processes its own source code, resulting in an executable version of itself. Many Forth-systems have been written as metacompilers. Forth metacompilers can reduce the porting effort, especially to badly supported platforms, by avoiding the need of assemblers,

593:

Sorry if the Forth metacompiler claim above has confused the issue. It seams the originator of this topic is an advocate of the FORTH metacompiler claim. The other part of the RFC was to links used in explaining the self-compiling operation. it followed the FORTH description of a metacompiler.

1372:

process claimed to be so special in the original definition. The real discerning feature is the metalanguage input. In a metacompiler the metalanguage directs the compilation process, defining the syntax of the language and it's transformation to output code. The metalanguage is a programming

861:

I'm also concerned because so far his writing has been atrocious -- he muddles things together, sometimes almost to the point of gibberish. I have degrees in this stuff, and it seems he conflates formal theory and parsing technology, cutting and pasting pieces out of Knowledge (XXG) articles,

3057:

I am here in response to the Request for Consensus. I am not sure where I am meant to give my view – but the above all seems to be an argument about whether there ought to be a request for consensus, so I'll give my view here. This article is, or ought to be, about what most programmers call

1859:

The person filing the RFC, Steamerandy, first started editing this topic 3 weeks ago, and his additions were accepted, even though they appeared to be erroneous. Unfortunately the documentation to challenge his changes is now classified/secret by the US government and therefor unavailable --

717:

2767:

doesn't even know computer science history. We can look back to early books from the late nineteen fifties and sixties and find references to metalanguages. metacompiler shows up in the sixties. And guess where. If there is an earlier meta compiler before META I. What, when and were was it

2566:

When provided with references that counter his claims -- such as the existence of other metacompilers, or examples of the use of "metacompiler" as an accepted concept that exists apart from his own narrow definition -- he ignores or muddles the evidence, or explains them away with muddled

2096:

One of the greatest things about these meta languages is the readability and ease in which they can be extended. And maybe should be one of the defining factors. The above example only handled addition and multiplication. What would it take to extend it to handle subtraction and division?

921:

738:

public. We're pretty sure it still continued as research, but who knows? But others have continued to carry on research into metacompilers over the years since then which isn't classified. Metacompilers play an important part in Domain Analysis and domain-specific languages, for example.

2112:

Almost anybody can understand what I did there. Hell I have spent gobs more time writing the explanation here then it took to change the program lines. It was said that these are recursive decent parser. Were is it in the above example? Does anybody see any recursion there? Don't peek.

1787:

compiler compilers be what it sounds like it should be. A compiler producing an executable compiler from a source language description. If you go back through the early compiler development you find many compiler compilers that actually produced machine code output. Years before yacc.

151: 810:

presented him with 2 examples of the Forth metacompilers, he confused 4 different referenced products and claimed they weren't really metacompilers. In doing so, he completely ignored the reference I included above, which directly contradicts everything he seems to be claiming here.

1653:

All of the metacompilers I have worked with could compile them selves. But so could all of the PASCAL compilers I have written. What is the difference of a PASCAL compiler written in PASCAL compiling it's self and META II compiling it's self. Is there really any difference in

870:

brand of metacompilers -- to the detriment of other equally important and valid technology. It's a way to seek your approval and proof that he is right and I am wrong. For me this is not personal, the only skin I have in this game is that I want to see the work of Schorre

2190:#include "common.h" #include "CCclass.h" #include "CCdata.h" extern void __savePntrs(); extern void __rstrPntrs(); extern void _Advance(); extern BYTE TokenFlg; /****************************************************************************** * * Match a "<string: --> 2869:

community has its own line of metacompilers, satisfying his repeated request to show any other example of metacompilers besides the ones he's pushing. Despite providing this evidence, Steamerandy continues to deny and obfuscate this obvious data countering his

2783:

As mentioned earlier, META II is not presented as a standard language, but as a point of departure from which a user may develop his own META language. The term "META Language," with "META" in capital letters, is used to denote any compiler writing language so

844:

My opinion is that this article is the unsubstantiated opinion of one Damon Simms. It has conflicting description with the well known metacompilers and would exclude them as they are analytical parser languages not using a generative parser as stated in the

2015:

page, admitting knowing little about TREE-META, change all instances of Unparsing to Nonparsing. When unparse is from the TREEMETA manual. Unparse rules disassemble the parser tree thus unparsing the parse tree. FROM the TREEMETA manual the unparse syntax:

734:

pages, as indication that he is qualified to speak for this topic. He claims he has done a lot of work with this technology, a vast amount of expertise. And he began wanting to change everything about the Metacompiler article based on his views of reality.

879:

differently because he has more experience and a high IQ, or something like that. And he writes badly to boot. And from my perspective, is ignorant of all that has gone on in computer science and compiler technology since that dead project 50 years ago.

2816:

as are ALGOL, COBOL, PASCAL, C, MODULA II etc etc. Meta meaning one level above would describe A programming language description (A metalanguage that is a a level above the language) compiled by a metacompiler the result is a compiler for the language

1675:

Writing a pascal from scratch is really no different from writing a metacompiler from scratch. In fact META II was written on a pseudo machine (interrupter) having only four instruction. How hard can it be to write code for a 4 instruction machine.

766:

Engineering. He even proposed changing the title of the article to "Meta programming" to make it solely about that Schorre family of metacompilers. At first I didn't understand where he was coming from, but now I think I understand his confusion.

2227:

And the hand compiled integer token rule: (note the integer rules is expressed in comments) Deviation from CWIC and SLIC which only allowed a single conversion call in a token rule. cc allow conversion call to terminate an outer most alternate..

671:

His response to my suggested changes: "I seriously doubt you understand this topic and associated concepts. Any changes you make to the Metacompiler Knowledge (XXG) page I will consider an act of ignorant vandalism, and will report it as such"

1710:

About a week ago Steamerandy posted some responses on this talk page ridiculing a technical answer I had posted to someone else's question. I responded, based on standard computer science concepts which can be found here on Knowledge (XXG)

741:

729:

A couple weeks passed and I saw he was making changes to other Knowledge (XXG) pages related to this topic. All fine and good, Knowledge (XXG) can always use knowledgeable editors. And he also studied and learned the Knowledge (XXG) rules.

2549:

post links to sites that prove my point and like a little child tries to blame me for using his reference against him. Says I misconstrue is references. I do not see how I am in any way responsible for his posts supporting my arguments.

2219:

The following is the integer token rule. Note there was token rules in the CWIC example from the CWIC ACM paper. TOKEN rules are defined by a .. operator. CWIC character class rules define the character classes used in the interger rule.

3034:"The feature that sets a metacompiler apart from a standard compiler-compiler is that a metacompiler is written in its own language and translates itself." and that it is an unsubstantiated refuted claim and therefore should be removed. 2514:

He cobbles together bits and pieces from related articles on computer theory and research to make his point, but often they don't make sense, at least not to me (hey, what do I know, I just have 2 degrees and 40 years experience in this

915:

2177:

The point is not the specific code. It's the amount and complexity of the code. The metacompler generated code is a very small part of the compiler code. The code here is specifically involved in matching a string against the input.

850:

grammars. It has nothing to do with "generative" anything, as far as I know. I modified that statement in the article to help maybe any future confusion, by changing "grammar productions" to "grammar production rules". See Wiki page

2252:

META II compiled to interpreted code. The interpreter was in 1401 assembly and had many more times the number of lines of code then the metalanguage source. That wasn't automagicly generated. The interpreter was coded by hand.

2715:. If it was such a mind-bending experience. Will that just says it all. He isn't much of a programmer. This mind-bending experience just shows what level of a programmer he is. Writing code from scratch is mind-bending to 1373:

language that actually directs the compiling process. This clamoring about self compilation is detracting from the essence of the elegant solution they offer to compiler writers. I hope the following achieves that goal:

645:

of less then 3% of the SegPlan group. There is a fringe group of Forth fanatics having the misguided conception that forth is a metacompiler. The norm is that most compilers are self hosting, compiling them selves. See

718:

seriously, I'm not making this up, CWIC became a classified project of SDC, System Development Corporation, a research company in Santa Monica that did a lot of work for the military. From Steamerandy's own Talk page:

1860:

940:

Please reject his RFC, as I think it is based on an unwillingness to consider evidence of the work of others, and an insistence on a narrow parochial view which denies anything that falls outside that view. Thanks.

2223:

bin: '0'|'1'; oct: bin | '2' | '3' | '4' | '5' | '6' | '7'; dgt: oct | '8' | '9'; hex: dgt | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f';

1213:

The history of metacompilers is closely tied to the history of SIG/PLAN Working group 1 on Syntax Driven Compilers. The group was started in the. Los Angles area primarily through the effort of Howard Metcalfe.

652:

I feel that this description of a metacompiler is only used the FORTH fringe. And thus all references to self-compiling being the feature that sets metacompilers apart from other compiler compilers be removed.

1504:

can then be compiled by a metacompiler, usually it's self, or hand compiled into an existing computer language. The step of first writing a matacompiler by hand compiling into an existing language is called

1321:

2727:

He keeps posting his own technical history all over Knowledge (XXG), on the Talk pages of related articles -- I assume as proof of his authority in this subject, but I'm not sure and it does make me wonder.

2666:

thinks the norm is mind-bending. It is mind-bending to him that some one can code a compiler from scratch. A newbie reaction to something they have not seen before. I have a vary different back ground than

1598:

My adversary will say that I am changing my position again. Sorry the "dumbshit" "ignoramuses" calling adversary blows so much smoke trying to cover up his real objections: That my definition would exclude

773:

For example, the Forth community has a long history of using their version of a metacompiler to bootstrap their language system onto new hardware. A link to one of the many Forth websites makes that clear:

933:

866:

obfuscates the facts, but sometimes he changes his position, incorporating the new facts as if he had accepted them all along, but then finds other reasons to find fault in the information presented here.

2119:

In the Schorre META grammars recursion is available. Question. Is this really a recursive decent parser? If what you are parsing isn't a nested language construct there would be no reason for recursion.

2020:.empty; 28A6 argmnt = nsimp / '.pound .num; 28A7 nsimpl = 't nsimp I nsimp; 28A8 nsimp = '* .num (': nsimp / .empty); 28A9 genl = (out / comm) (genl / .empty); 28A10 gen = comm / genu / '< / ': --> 1664:

does not take a metalanguage as input. I forgot a step. A P-code assembler had to be written to assembly P-code assembly source into a P_code binary load module. My adversary says I do not understand

835:

As for his second claim in his RFC request, that I am excluding the Meta-II metacompilers, is based on his misunderstanding of well-accepted terminology from compiler theory and practice. He claims:

1064:

When I checked the forth reference here on Knowledge (XXG) I found that forth compiling it's self is not recognized in computer science mainstream as a metacompiler or as doing a meta-compilation.

1823:

where it is described as a production grammar. My adversary is so myopic he fails to understand my objection to that link. There are many compilers that do not use a generative grammar that a

175: 2257:

element backtracking involving only the input stream. Token matching and string matching are similar only restoring the input stream state on a failure. Objects are only created on success.

2187:

classmap is a table indexed by a character code. Bits at the indexed location indicate a characters class membership. Class rules assign the bits used for a class and generate table entries.

1867:"CWIC was developed at SDC a government think tank. It was classified by the government some time in the early 70s. But I got my manual from Erwin at an ACM meeting before it was classified." 722:"CWIC was developed at SDC a government think tank. It was classified by the government some time in the early 70s. But I got my manual from Erwin at an ACM meeting before it was classified." 315: 2861:

Furthermore, it also disputes his definition of the prefix "meta-", which he keeps claiming over and over that we got wrong here, thus nullifying our use of the term "metacompiler". The

1647:

From my own personal experience, writing many compilers, starting from scratch is business-as-usual. Writing any program from scratch were there is no prior art is a more daunting task.

3058:"metacompilers". Some Forth programmers use the term "metacompiler" in an idiosyncratic way. This might be mentioned somewhere in the article, but certainly not in the first paragraph. 2833:

the description "The feature that sets a metacompiler apart from a standard compiler-compiler is that a metacompiler is written in its own language and translates itself" is in question

1595:

In my original proposed change I was not clear on what was to be replaced. There was no intention of replacing the whole of what was there. Just the part that defined a metacompiler.

839:"A metacompiler is defined by a set of grammar productions defining itself" defines a meta compiler as using a generative grammar. A great many meta compilers use analytical grammars. 1839:

I copy the definition here so my advisory might better understand what I was talking about. He misconstrues why I had to resort to that. But just for referance here it is again.

1891:, which appears to be "a system that automatically traverses selected Web sites collecting and analyzing images" and presumably has nothing to do with compilers or metacompilers. 2900:

webpage above satisfies that complaint. It clearly states that a metacompiler "is a compiler which processes its own source code, resulting in an executable version of itself".

2642:

is a metacompiler then so is every other compiler written in it's own language. PASCAL, C, C++ etc. There was a FORTRAN compiler writen in FORTRAN. Lets get LISP into the club.

2239:

The following is the cc grammar rules for a token. The main driver rules has already been posted here. Including the rule that matched the .. operator and calls the token rule.

858:

page, and then claims it proves his point. He then uses that as a basis for wanting to change everything about this article to make it about his own pet projects and interests.

2842:

webpage above satisfies that complaint. It clearly states that a metacompiler "is a compiler which processes its own source code, resulting in an executable version of itself".

2794:

really does not understand metacompiler history. As Val Schorre explains META II was meant as a metalanguage compiler, A base to develop further metalanguage and metacompiles.

232: 170: 746:

was the topic). Not only did he stand by his ridicule of my responses, he posted his technical biography as proof he knew what he was talking about, and to claim I was wrong.

1715:

was the topic). Not only did he stand by his ridicule of my responses, he posted his technical biography as proof he knew what he was talking about, and to claim I was wrong.

758:

and 40 years of experience, both in academia and industry. I maintain contact with experts in the field and and check with them to vet what I have written for this article.

3243: 1690:

is the part that is mind-bending. Unlike other iterative software development which just builds successive improvements and extensions on an existing base of software, in

824:

the description "The feature that sets a metacompiler apart from a standard compiler-compiler is that a metacompiler is written in its own language and translates itself"

3272: 2558:

An experienced programmer who has worked on compilers should not find the initial coding/bootstrap process mind bending. See above. The student who became a professor.

3277: 1617:

lack of understanding of the mark-up language used or his lack of understanding of computer science compiler terminology. He says he knows the lingo and I do not.

1640:

My adversary denies that my experience as head of the language development group at Kontron Electronics were we actually wrote commercial compilers is immaterial.

3282: 87: 2292:

1. "The feature that sets a metacompiler apart from a standard compiler-compiler is that a metacompiler is written in its own language and translates itself."

2470:

Again a lie. This has to do with his ignorance of that a formal grammar is a generative/production grammar. What is an article with no subjects? And sense

2048:

Actually check it out it's here on the talk page. I need to find out how to report someone for vandalism. People do make mistakes. Best for now to figure

637: 594:

Computer science terms were used an linked to their topic here on Wiki. The links and description were gibberish. "A metacompiler is defined by a set of

586: 578: 277: 1106:

I misconstrue his references finding that they are either not talking about a metacompile that matches his narrow view or are not a metacompiler at all.

523:

The feature that sets a metacompiler apart from a standard compiler-compiler is that a metacompiler is written in its own language and translates itself

532:

There is some confusion about this RFC. It is basicly about the claim; that that a metacompiler is written in its own language and translates itself.

2992: 2769: 2024: 116: 78: 58: 2991:

There were 2 early metacompilers written at SDC. Book1 and Book2 were written in LISP 2. I assume by Erwin Book. The early history is documented in

1227: 883:

offering links to webpages which can provide him with even more help. But so far he only seems intent on changing what's here and proving me wrong.

1744:

NOTE Again my adversary who does not understand computer science terms keeps saying it is I who does not understand them. Iterative development is

1791:

language development group at Kontron/FutureData. Despite what my adversary says. My experience writing real world compilers are my credentials.

1509:. That is, the programmer pretends to be the metacompiler, parsing its rules and writing the code the metacompiler would generate, if it existed. 2933: 1326:. That is, the programmer pretends to be the metacompiler, parsing its rules and writing the code the metacompiler would generate, if it existed. 1093:

When PASCAL is coded in PASCAL , the process of building a new PASCAL compiler is called metacompilation. Like most metacompilers, PASCAL has...

1037: 726:

So he made changes based on a manual none of the rest of us have access to, but hey, additional information on this topic is always appreciated.

251: 1984:

The CWIC/360 document does. You might have checked the CWIC reference in the metacompiler that is correct. Seams the ACM document id was wrong.

1880:

So he made changes based on a manual none of the rest of us have access to, but hey, additional information on this topic is always appreciated.

2830:

For example, his first claim from his RFC request above, which he seems to repeat over and over, even after I have presented counter-evidence:

2210:

swap return for char* str /***********************************************************************\ * <return from _matching function_: -->

2166:

backtracking functions. Anyway this is to illustrate the amount of code involved with supporting a simple string match in the syntax language.

820:

For example, his first claim from his RFC request above, which he seems to repeat over and over, even after I have presented counter-evidence:

223: 2997:

It is a fact that extensible language such as LISP and FORTH shear some of the properties of a metacompiler. But they are not metacompilers.

1679:

Read the response made to "Can we remove "and usually mind-bending"" NOTE. it was from an IP. but my adversary has said it was his response.

1104:

I misconstrue his references when I find in his references exactly the opposite of what he says is the defining attribute of a metacompiler.

340: 2502:. It does not analyze a language construct for correctness. Just the opposite. BNF is a production grammar. I have tried to explain this to 2739:

is no authority on metacompilers. Forth is no more a metacompiler then is LISP. They are simply extensible languages. By the way I learned

1946:

In its most general form a metacompiler is a program, written for a machine M which will accept specifications for a Programming language L

1087:

language as input, and is written in forth. How is this different from a PASCAL compiler written in PASCAL, or a C compiler written in C?

204: 2045:

topic and then threatens me. "if you try changing this page to your limited wrong myopic views, we will consider it to be vandalism."

2037:

can change the TREEMETA topic to disagree with termonolgy from the TREEMETA manual? Was it out of ignorance or for some agenda he has?

632:

Defining itself and translating itself this way constitutes the meta-step that sets a metacompiler apart from other compiler-compilers.

2072:

This example is directly form the public available ACM paper on CWIC ($ 15 to non-members, $ 10 to members, and $ 5 student members).

1971: 1892: 1050:* The LMI Metacompiler is written in Forth-B3 and has minimal dependence on the word size or structure of the host or target systems, 2988:

provided links to a site of a metacompiler written in PL/1. And then cries I misconstrue his references. What! Because I read them?

492:

for moderated discussion, where a volunteer moderator might be able to get them to talk to each other rather than past each other.

2205:* * * *__declspec(naked) void _match_function_() {_asm{ * * call __savePntrs * * <return from __savePntrs: --> 2701:

says I have degrees so I am the authority here. Look at his response to the other fellow who posted about his outlandish ideas of

2681:

freak who tries to run down any one that disagrees with him. That is all he has done here. Try to run me down. What arguments has

2600:

system is called metacompilation. Like most metacompilers, ForthOS's has restrictions on what kinds of Forth code are permissable.

1023:

system is called metacompilation. Like most metacompilers, ForthOS's has restrictions on what kinds of Forth code are permissable.

2854: 2850: 2813: 2809: 2300:

supplied site references that were counter to his opinion that A metacompiler is written in their own language. And this is what

646: 1954:, and produce a compiler which runs on Machine M. Source Programs which are the input to this compiler are written in Language L 1737:

There is more there about developing a compiler in one language and then rewriting it in it's own language etc. Just follow the

296: 2413:

He wants to change the article to a more narrow explicit focus that will be about one instance of the technology, his favorite

2246:

procid .. alpha symchr* ?'('; // skipclass skiping is off when peeking for ( following the id. No white space allowed.

900:

He wants to change the article to a more narrow explicit focus that will be about one instance of the technology, his favorite

261: 142: 33: 1513:

may continue incrementally creating more and more powerful compiler by adding features creating a new more powerful compiler.

1468:

program as input and translates that program into a set of instructions. If the input program is a complete description of a

1296:

program as input and translates that program into a set of instructions. If the input program is a complete description of a

2906:

I have already went over this. I misconstrued this by actually digging into the compiler they were talking about and found:

185: 513:

Subsequent comments should be made on the appropriate discussion page. No further edits should be made to this discussion.

469:

on 7 April 2018 and it now redirects there. For the contribution history and old versions of the merged article please see

3259:

Subsequent comments should be made on the appropriate discussion page. No further edits should be made to this discussion.

1188:

I misconstrue his references when I actually study them. Looking at the compiler code. Hours of researching the so called

851: 603: 306: 86:

related articles on Knowledge (XXG). If you would like to participate, please visit the project page, where you can join

2954: 2950: 2946: 2942: 2927: 2922: 2918: 2914: 2897: 2881: 2866: 2862: 2839: 2740: 2694: 2690: 2686: 2678: 2639: 2632: 2628: 2617: 2613: 2602: 2597: 2593: 2584: 2580: 2389: 2377: 2372: 2368: 2364: 2353: 2349: 2345: 2341: 1634: 1625: 1604: 1600: 1584: 1451:

or meaning. English on the other hand is powerful, Yet its informality prohibits its translation into computer programs.

1279:

or meaning. English on the other hand is powerful, Yet its informality prohibits its translation into computer programs.

1197: 1193: 1189: 1183: 1165: 1138: 1134: 1130: 1122: 1084: 1080: 1068: 1056: 1043: 1025: 1020: 1016: 1012: 1003: 999: 995: 987: 966: 582: 681:

I am sorry I have to make this RFC. But with the threat of being reported for vandalism I must seek outside opiniones.

1543:, a metacompiler is itself a prime example of a domain-specific language, designed for the domain of compiler writing. 1383: 435: 402: 397: 271: 2705:

being mind-bending. look at his lack of understanding other computer science terms that I have already pointed out.

1970:

For a reason I posted a few lines above, it appears unlikely that the document linked contains any such definition.

754:). By the way, I am his age and have almost as many years of active work in the computer field as he does, over 40. 675:"I'm tired of ignoramuses coming on here who know a little somethin about something and think they know everything" 2462:

He has even stated the whole article should be deleted based on his insistence that other metacompilers don't exist

1941:

reference was given. Maybe he already knew the ACM document contained a meta compiler definition contrary to his..

1873:

True except for the fact there is the ACM publication that describes CWIC that can be gotten from the ACM archives.

1753: 1333: 910:

He has even stated the whole article should be deleted based on his insistence that other metacompilers don't exist

1749: 1510: 1506: 497: 333: 3229:. Technical Report 160, Department of Information and Computer Sciences, University of California, Irvine, 1980. 2422:

from 1970 given above. That is the first and only definition in ACM publications. Do you not recognize the ACM?

414: 2506:

to no avail. He just can not grasp this most basic concept. I do not see how he got a computer science degree.

1540: 1731:

Bootstrapping can also refer to the development of successively more complex, faster programming environments.

1686:

From my own experience and from interviewing many others in computer and software engineering, the process of

1210:

My adversary keeps saying I wish to narrow this topic to Schorre's work. But has never shown any actual case.

242: 39: 2334:

gave several references to sites where metacompilers were written in PL/1 or assembly that proved my point.

1975: 1896: 21: 1075:

by Forth programmers (although the term doesn't exactly match meta-compilation as it is normally defined)."

535:

There are many metacompilers that are not written in their own language nor do they translates their self.

2123:

To illustrate the power of a metacompiler I am using an example from developing a COBOL compiler in SLIC:

862:

claiming they prove his point, when in fact it is cobbled-together nonsense. How do you respond to that?

3043: 3016: 3008: 2671:, having worked on operatoring systems and compilers for most of the 49 years I have been programming. 1989: 1923: 1349: 1332:

As anyone can see above. Not one thing specific to Schorre meta compilers in the definition I proposed.

948: 703: 689: 619: 611: 567: 2921:

system is called metacompilation. Like most metacompilers, ForthOS's has restrictions on what kinds of

2371:

system is called metacompilation. Like most metacompilers, ForthOS's has restrictions on what kinds of

1436: 1424: 1420: 1264: 1252: 1248: 1137:

system is called metacompilation. Like most metacompilers, ForthOS's has restrictions on what kinds of

2545:. Showing his lack of computer science terminology expertise. Which he so boastfully claimed to have. 2442:

to lie is that he are wrong and blowing smoke tring to make me look bad. That comment was made about

1469: 1297: 1071:"A fully featured Forth system with all source code will compile itself, a technique commonly called 493: 2401:

gave a referance to a blog artical. It was written after the metacompiler topic was first posted by

2100:

We would change EXP and TERM syntax rules to include the new operators and generate nodes for them:

1630:

And no amount of name, "dumbshit" "ignoramuses", calling from my adversary is going to change that.

1530:, they are also useful for generating a wide range of other software engineering and analysis tools. 638:

unsupported claims made by forth programmers that are not supported in main stream Computer Science.

462: 161: 2798:

When forth is coded in forth, the process of building a new forth system is called metacompilation

2651:

about something, then it must not exist, even feeling he can make fun of anyone associated with it

1621:

implementation of forth. Which I discovered by actually reading the reference my adversary gave.

1168:

screens or ordinary text files, Source files may "include" other files, up to 4 levels of nesting.

1059:

screens or ordinary text files, Source files may "include" other files, up to 4 levels of nesting.

928:

about something, then it must not exist, even feeling he can make fun of anyone associated with it

3124: 3086: 2296:

Well the fact is that not all metacompilers compilers are written in their own language. In fact

1843: 1609:

My adversary limits metacompiler to production grammars by his description ignorantly linking to

420: 813:

I usually welcome knowledgeable comments from contributors, but having read Steamerandy's posts

3063: 1566: 1554: 466: 2984:

says he wants to teach metacompilers. I wonder does intend to teach FORTH as a metacompiler?

2874:

Click on the words forth above and see what Knowledge (XXG) forth TOPIC has to say about it.

2323:: I have provided multiple references to counter his claims, which he ignores or misconstrues 2281:

Steamerandy claims this article should be changed because statements in the article are wrong

2103:

EXP = TERM $ (('+':ADD / '-':SUB) TERM !2); TERM = FACTOR $ (('*':MPY / '/':DIV) FACTOR !2);

1173: 1155: 1034: 890:

Steamerandy claims this article should be changed because statements in the article are wrong

750:

programming before you were born" and "You youngsters just think you know everything!!" (see

287: 3206: 3039: 3012: 3004: 3000: 2985: 2981: 2974: 2967: 2961: 2893: 2885: 2877: 2846: 2823: 2791: 2764: 2747: 2736: 2716: 2708: 2698: 2682: 2674: 2668: 2663: 2624: 2609: 2576: 2554: 2546: 2538: 2530: 2526: 2503: 2491: 2487: 2483: 2479: 2471: 2451: 2443: 2439: 2402: 2398: 2337: 2331: 2320: 2301: 2297: 2270: 2162: 2145:

again. After checking to make sure that it was safe to look for CONTAINS it got changed to:

2056: 2049: 2038: 2034: 2030: 2008: 1985: 1919: 1701: 1614: 1580: 1345: 944: 699: 685: 661: 615: 607: 563: 416: 380: 213: 83: 3030:

To sum this up I have listed 6 meta compilers written in languages other then them selves.

1613:. And then claims I am the one who doesn't under the grammar terms. Minor point. But shows 895:

I have provided multiple references to counter his claims, which he ignores or misconstrues

489: 3224: 3137: 2964:

is claiming that any compiler that compiles it's self is a meta compiler. That means that

1553:

process usually rounds out the full metacompiler package. This might for instance include

1072: 667:

So please side with the removal of the Forth fringe misconceived idea of a metacompiler.

657:

Stanford Research Institute. And BOOK1, BOOK2, CWIC from Systems Development Corporation.

1576:

commonly a type of string. Symbols are a type of string and may have string attributes.

2529:

can not comprehend the difference between a generative grammar and an analytic grammar.

2206:* * * * stack on entry: * * _matching function_'s <string address: --> 1151:

and has minimal dependence on the word size or structure of the host or target systems,

3239: 2490:

thinks a production grammar is about producing code. Well you better go back to school

2475: 2447: 2309: 1832: 1828: 1824: 1820: 1810: 1806: 1795: 1748:. Who's the "dumbshit" "ignoramuse" misunderstanding computer science terminology? The 1610: 1527: 1204:

Can it be that my adversary gets his idea of a metacompiler from forth? He did tell me

599: 129: 2934:

Journal of FORTH Application and Research, Volume 4 Issue 2, June 1986 Pages 257 - 258

2169:

void __declspec(naked) function_name(){_asm{ <assembly language coded function: -->

1038:

Journal of FORTH Application and Research, Volume 4 Issue 2, June 1986 Pages 257 - 258

969:

minority definition of metacompiler. What makes me think this is the comment he made:

678:

Note I asked for a list of metacompilers. Didn't get it. No references to his claims.

152:

Requested articles/Applied arts and sciences/Computer science, computing, and Internet

3266: 3082: 2884:

topic here in Knowledge (XXG)? (It proves him wrong) There is no forth metacompiler.

2712: 2702: 2542: 2534: 1745: 1738: 1722: 1712: 1691: 1687: 1669: 1665: 1660: 1655: 1369: 1365: 1323: 743: 636:

The references pointing to forth sites claiming forth to be metacompilers. These are

3059: 1562: 1558: 1501: 1497: 1481: 1465: 1440: 1428: 1416: 1391: 1318: 1314: 1293: 1268: 1256: 1244: 778: 3169:

Dewey, Val Schorre (1964). "META II a syntax-oriented compiler writing language".

2196:

There are four string test types similar to the above _CmpStr for "<string: -->

1170: 1152: 1031: 2212:

to _matching function_ * * ecx _matching function_'s <string address: -->

1477: 598:

defining itself, written in its own specialized language" Grammar was linked to

544:

Meta III,Schneider and Johnson, was implemented completely in assembly language.

2785: 2768:

documented. The TREEMETA document says that META I was the first metacompiler.

2312:. I have explained above. It would not be a problem with my suggested change. 2204:* * call _match_function_ * * <return from _matching function_: --> 2106:

How easy was that. Now we would need to change the vectors in the generator:

1002:

concept of meta compiler is simply a compiler that compiles it's self. From :

803:

compilers or tool chains, in order to get a program running on that platform.

2042: 2012: 1938: 1874: 1587:

from the club. Or any compiler compiler not taking a metalanguage as input.

1448: 1399: 1276: 990:

community uses the term "metacompiler" as it has been accepted for 40 years.

194: 3194: 1914: 70: 52: 3210: 2930: 2605: 2380: 2356:

a meta compiler just because it compiles it's self. FROM WWW.forthos.org:

1633:

To be honest I can not say if my adversary is intentionally biased to the

1176: 1158: 1143: 1028: 751: 2430:

He doesn't even like the article topic, disputing that it is a real topic

2249:

Experimenting with the * repeat operator of more resent meta languages.

1484: 1473: 1432: 1412: 1387: 1301: 1260: 1240: 905:

He doesn't even like the article topic, disputing that it is a real topic

3195:"The CWIC/36O system, a compiler for writing and implementing compilers" 3154:

Dewey, Val Schorre (1963). "A Syntax - Directed SMALGOL for the 1401,".

2779:

From the early META II document written by D. Val Schorre at UCLA 1963:

2523:

It doesn't show. Does it?? I mean his claimed Knowledge and expertise.

1958:. The output of this compiler is object language which runs on machine M 1916:"The CWIC/36O system, a compiler for writing and implementing compilers" 1778:

What Is Unique About Metacompilers That Distinguishes Them From The Rest

418: 1668:. It seams to me that my adversary is the one that does not understand 1461: 1415:(about data). A language that is used to describe other languages is a 1289: 1243:(about data). A language that is used to describe other languages is a 587:

Knowledge (XXG):Manual of Style/Words to watch Unsupported attributions

2583:

into being acknowledged as a metacompiler. But seams to not know that

1206:"Forget about Meta, cast it into Hell... for God's sake, learn Forth." 660:

My opinion is that this article is the unsubstantiated opinion of one

1523: 1444: 1395: 1272: 3090: 3067: 3047: 3020: 1993: 1979: 1927: 1900: 1353: 973:

Forget about Meta, cast it into Hell... for God's sake, learn Forth.

952: 707: 693: 623: 571: 501: 2928:

Forth (programming language)#Self-compilation and cross compilation

2603:

Forth (programming language)#Self-compilation and cross compilation

2378:

Forth (programming language)#Self-compilation and cross compilation

1849:

Therefore, a grammar is usually thought of as a language generator.

1642:

I used my experience as an example of how ludicrous his position is

3117:

On the Syntax Machine and the Construction of a Universal Compiler

2215:* * ecx points at string to match <string address: --> 2003:

OMG!! there is no mention of a metacompiler compiling it's self.

1637:

metacompiler defamation or just did not investigate his sources.

1368:

a self-compiled compiler in any language is no different then the

1102:

My adversary appears to not have investigate his sources. He says

2775:

Val Schorre explains META II was meant as a metalanguage compiler

2719:. A level 1 NB programmer. Give them simple modification tasks. 2214:* * callers saved ecx <must be popped by function: --> 2033:

is blowing smoke. One should doubt anything he says. How is that

1603:

from the metacompiler club. Note the Knowledge (XXG) take in the

1591:

Continued Counter response to adversarial: Response to RFC claims

793:

meta: (greek) A prefix, meaning "one level of description higher"

2211:* * callers saved ecx * * <return from __savePntrs: --> 1394:, description of the target language, that are a combination of 1055:* The input to the (LMI) Metacompiler may be either traditional 965:

The adversary here appears to have their own agenda to push the

2089:#U1 #V =ADD, MPY #U = X + Y, X * Y .F1N15H .STOP SETUP PROGRAM 1069:

Knowledge (XXG): Forth (Self-compilation and cross compilation)

3193:

Erwin Book; Dewey Val Schorre; Steven J. Sherman (June 1970).

2482:

has actually eliminated probably all of them. So nothing fits

1799:

Anyway here is the problem with my adversary use of grammar.

444: 421: 374: 270:

Find pictures for the biographies of computer scientists (see

15: 2474:

think he is so right about grammar and insist on referencing

1694:

you start with nothing and have the software generate itself.

1644:

that "bootstraping a compiler from nothing is mind-bending",

628:

After the RFC was posted references were added to this line:

541:

META I, Val Schorre, hand coded was used to compiler META II.

2405:. So in all probability just repeating what was said here. 2972:

posted links. Oh wait PASCAL is metacompiler. And FORTRAN.

2344:

metacompilers. On reading and recearching I found that the

1831:. I would say that they were PEGs. Which they do fit into. 1476:

for the language. Thus one could say the metacompiler is a

1364:

many compilers have been written in the compiled language.

3003:, Is it really your option that forth is a metacompiler?-- 2061:

The ones I made to the CWIC example that was already there

1752:

topic is controversial. Seams to have more objection then

1337:

limitation. My intention is not to limit the parser type.

1164:* The input to the Metacompiler may be either traditional 583:

Forth (programming language) topic here on Knowledge (XXG)

2261:

machine. Multiprecision arithmetic library is required.

2141:('RECORDS' / -RECORD_CONTAINS_CLAUSE 'RECORD' / .EMPTY) 1827:

is defined as. The Schorre line of meta compilers use an

1672:

and is just mouthing material he does not understanding.

2966:

C and C++ are metacompilers just like forth acording to

2478:

claiming that is the grammar used by all metacompilers.

2109:#V =ADD, SUB, MPY, DIV #U = X + Y, X - Y, X * Y, X / Y 1118:

So what have I found in references my adversary gave:

961:

Counter response to adversarial: Response to RFC claims

581:

claim made by FORTH programmers. It is disputed by the

470: 457: 2953:

to be a meta compiler. The question is why did he not

2086:

DEF:(X) := EVAL(Y); PR1NT(DEF:(X)) EVAL(IDP(X)) =: -->

562:

The following statement has confused the issue here.--

2853:

is a metacompiler because some Forth programmers say

2743:

a long long time ago. And have forgotten most of it.

2689:

to my actual proposed changes? Oh thats right he put

2498:

valid strings of a language. NOTE the action here is

2438:

That is a lie. I like the topic. The only reason for

1192:

metacompiler. Never finding one. Instead I find that

1113:

I misconstrue his references by actually reading them

3171:

Proceedings of the 1964 19th ACM National Conference

82:, a collaborative effort to improve the coverage of 2888:

why don't you go argue with the forth contributors.

1583:might not wont this definition is that it excludes 1496:A metacompiler is, it's self, usually defined in a 1313:A metacompiler is, it's self, usually defined in a 937:I will add more information here if I think of it. 2388:That says it all right there. All references to a 176:Computer science articles needing expert attention 3242:named "FORD" is not used in the content (see the 3119:(Tech. Report No. 2 ed.). Carnegie Inst. of Tech. 2917:is coded in Forth, the process of building a new 2596:is coded in Forth, the process of building a new 2367:is coded in Forth, the process of building a new 1950:; and its equivalent in the language of Machine M 1522:Metacompilers are not only useful for generating 1133:is coded in Forth, the process of building a new 1411:Meta is used to mean about or describing, as in 1239:Meta is used to mean about or describing, as in 1006:, www.forthos.org and other referanced sites : 779:http://www.forthfreak.net/index.cgi?MetaCompiler 2786:"META II D. V. Schorre UCLA Computing Facility" 32:does not require a rating on Knowledge (XXG)'s 2148:('RECORDS' / ('RECORD' -'CONTAINS' \ .EMPTY)) 752:https://en.wikipedia.org/User_talk:Damon_Simms 316:WikiProject Computer science/Unreferenced BLPs 2348:metacompile not to be a metacompiler at all. 2207:* * <return from _matching function_: --> 2197:" other string compares are +"<string: --> 2052:made that TREE-META change out of ignorance. 1419:. English can be considered a metalanguage. 1359:revised proposed change to metacompiler topic 1247:. English can be considered a metalanguage. 1149:* The LMI Metacompiler is written in Forth-B3 429:This page has archives. Sections older than 8: 96:Knowledge (XXG):WikiProject Computer science 2181:The definition of CHARCLASS from CCclass.h 1725:topic here on Knowledge (XXG) have to say: 1605:forth Self-compilation being a metacompiler 556:CGS, Warshall and Shapiro, written in CL-1. 233:Computer science articles without infoboxes 171:Computer science articles needing attention 1836:specified PROGRAM to be the driving rule. 978:My Adversary says FORTH is a metacompiler. 137:Here are some tasks awaiting attention: 111: 47: 3149: 3147: 3110: 3108: 2955:reference the Knowledge (XXG) forth topic 2750:explains Schorre naming his metacompiiler 2533:is awe struck by the normal operation of 2340:gave a number of references to so called 2127:The COBOL RECORD CONTAINS clause Incident 1913:Don't know how that CWIC link was wrong. 3273:Redirect-Class Computer science articles 3053:More RFC Request for Consensus responses 1887:Note that the web page linked is titled 1125:freaks consider ForthOS a meta compiler. 815:and his proposed changes to this article 3278:NA-importance Computer science articles 3104: 2945:sites. Ultimately all turned out to be 2902:They are talking about forth it's self. 2662:The situation seams just the opposite. 49: 3226:Software Construction using Components 3188: 3186: 3184: 3182: 3180: 3133: 3122: 1889:"CWIC: continuous web image collector" 1805:A metacompiler is defined by a set of 1186:sites, thinking they prove his point. 439:when more than 3 sections are present. 3283:WikiProject Computer science articles 2896:said: I believe the quotes from that 2808:When forth is coded in forth it is a 2208:* * <return from __savePntrs: --> 1794:I am not all that concerned with the 99:Template:WikiProject Computer science 76:This redirect is within the scope of 19: 7: 2152:More details on the Run Time Library 1809:... The actual grammar link is to: " 509:The following discussion is closed. 3234: 2977:claims FORTH to be a meta compiler. 2627:I am very sorry to inform you that 2494:. A production grammar is one that 1214: 1182:So my adversary gave referances to 518:Revised 11/3/2014 The description: 38:It is of interest to the following 2635:references up. Leave them buried. 2304:calls misconstrues his referances. 2085:DEF:(X) := Y COMPILE(STORE) =: --> 1760:The Student Who Became a Professor 550:Book2, Erwin Book, written in LISP 547:Bookl, Erwin Book, written in LISP 490:the dispute resolution noticeboard 252:Timeline of computing 2020–present 14: 2308:2. Is a minor point in a link to 2135:('RECORDS' / 'RECORD' / .EMPTY) 1819:Follow the grammar link above to 1741:link and see what it has to say. 1539:Besides being useful for parsing 614:) 23:14, 17 November 2014 (UTC)-- 433:may be automatically archived by 278:Computing articles needing images 3255:The discussion above is closed. 3011:) 08:32, 17 October 2014 (UTC)-- 1019:, the process of building a new 448: 379: 128: 69: 51: 20: 2838:I believe the quotes from that 2394:FORTH IS NOT A METACOMPILER!!!! 2116:In FACTOR you have '(' EXP ')' 602:and production rules linked to 3115:A. Glennie (date July, 1960). 2865:reference also shows that the 2541:Has misused the definition of 1842:In theoretical linguistics, a 640:. There is no such thing as a 1: 3091:07:50, 28 November 2014 (UTC) 3068:08:16, 10 November 2014 (UTC) 3048:23:14, 17 November 2014 (UTC) 3021:00:11, 11 November 2014 (UTC) 2575:Forth is not a metacompiler. 2184:#define CHARCLASS byte ptr 1994:01:46, 1 September 2015 (UTC) 1928:01:39, 1 September 2015 (UTC) 1847:from which rewriting starts. 1579:I think that the only reason 1402:production rules or elements. 852:Production (computer science) 624:13:39, 18 November 2014 (UTC) 604:Production (computer science) 572:13:33, 18 November 2014 (UTC) 502:05:25, 28 December 2014 (UTC) 332:Tag all relevant articles in 90:and see a list of open tasks. 3156:ACM Natl. Conf., Denver,Colo 3026:Unsubstantiated claim proved 2882:Forth (programming language) 2735:It has become apparent that 2289:There are two things wrong. 1443:, for it describes only the 1354:05:52, 19 October 2014 (UTC) 1271:, for it describes only the 1026:Forth (programming language) 1004:Forth (programming language) 953:14:44, 10 October 2014 (UTC) 694:04:46, 4 November 2014 (UTC) 341:WikiProject Computer science 117:WikiProject Computer science 79:WikiProject Computer science 2993:"Tree_Meta for the XDS_940" 2857:(FORTH) is a metacompiler. 2770:"Tree_Meta for the XDS_940" 2084:.GENERATOR DECL(EQU) =: --> 1980:00:18, 31 August 2015 (UTC) 1901:00:18, 31 August 2015 (UTC) 1470:formal programming language 1447:and says nothing about the 1334:Parsing expression grammars 1298:formal programming language 1275:and says nothing about the 1222:tag is missing the closing 708:00:52, 8 October 2014 (UTC) 272:List of computer scientists 3299: 2087:DEF:(X) (NUMBER(X)) =: --> 1754:parsing expression grammar 1431:originally used to define 1259:originally used to define 1035:www.forth.org metacompiler 2693:forth!!! Or should I say 2587:is not a formal grammar. 2579:is just trying to weasel 2055:Exactly what changes was 1750:Bootstrapping (compilers) 1628:is not a meta compiler!!! 1541:domain-specific languages 1382:s are a special class of 781:-- the Forth Metacompiler 334:Category:Computer science 110: 102:Computer science articles 64: 46: 3257:Please do not modify it. 3032:Absolutely proving wrong 2265:More adversary bickering 2191:" * push * ecs -: --> 2093:before calling PROGRAM. 1174:"forth.org metacompiler" 1156:"forth.org metacompiler" 596:grammar production rules 511:Please do not modify it. 336:and sub-categories with 2711:says he has experience 2500:generates valid strings 2199:" and ?"<string: --> 1854:Now my adversary claims 1472:, the translation is a 1300:, the translation is a 579:unsupported attribution 3240:list-defined reference 3132:Check date values in: 2631:is dead. Quit digging 1044:forth meta compilation 994:Ok. So I searched for 713:Response to RFC claims 647:Self-hosting compilers 553:SIMPLE written in PL/I 436:Lowercase sigmabot III 297:Computer science stubs 3211:10.1145/954344.954345 2925:code are permissable. 2855:self-hosting compiler 2851:self-hosting compiler 2814:self-hosting compiler 2810:self-hosting compiler 2616:freak believing that 2454:even have a degree? 2375:code are permissable. 1460:A meta-compiler is a 1288:A meta-compiler is a 1141:code are permissable. 2880:did not link to the 2198:", -"<string: --> 455:The contents of the 115:Things you can help 3199:ACM SIGPLAN Notices 2941:He posted numerous 2659:OMG!! 4COL WABOC!! 2486:narrow definition. 2392:should be removed. 2011:can go muck-up the 1937:This is a lie. The 1398:parsing rules and 1111:It just seams that 1083:metacompiler takes 529:Revised 11/17/2014 2892:So lets see here, 2620:is a metacompiler. 1844:generative grammar 998:metacompiler. The 886:Let me summarize: 698:Orrigional made -- 512: 34:content assessment 2446:ignorant link to 2025:"TREEMETA Manual" 1833:Analytic grammars 1829:Analytic grammars 1567:string processing 1555:memory management 1304:for the language. 1042:Knowledge (XXG): 982:Really he said: 510: 477: 476: 467:Compiler-compiler 443: 442: 408: 407: 371: 370: 367: 366: 363: 362: 359: 358: 355: 354: 3290: 3249: 3248: 3247: 3230: 3223:Neighbors, J.M. 3221: 3215: 3214: 3190: 3175: 3174: 3166: 3160: 3159: 3151: 3142: 3141: 3135: 3130: 3128: 3120: 3112: 2949:freaks claiming 2352:freaks consider 2192:"<string: --> 2138:was changed to 1425:Backus–Naur Form 1253:Backus–Naur Form 1233: 1232: 1231: 1225: 1221: 1200:a meta compiler. 1196:freaks consider 1073:meta-compilation 460: 452: 451: 445: 438: 422: 394: 393: 383: 375: 345: 339: 214:Computer science 143:Article requests 132: 125: 124: 112: 104: 103: 100: 97: 94: 93:Computer science 84:Computer science 73: 66: 65: 59:Computer science 55: 48: 25: 24: 16: 3298: 3297: 3293: 3292: 3291: 3289: 3288: 3287: 3263: 3262: 3261: 3260: 3250: 3237: 3235: 3233: 3222: 3218: 3192: 3191: 3178: 3168: 3167: 3163: 3153: 3152: 3145: 3131: 3121: 3114: 3113: 3106: 3101: 3078: 3055: 3028: 2931:www.forthos.org 2803: 2777: 2752: 2606:www.forthos.org 2381:www.forthos.org 2267: 2247: 2244: 2233: 2225: 2217: 2194: 2185: 2171: 2154: 2129: 2110: 2104: 2090: 2079: 2070: 2059:talking about? 2041:vandalizes the 2022: 2007:How is it that 1961: 1957: 1953: 1949: 1856: 1780: 1771: 1769:The Awe is Gone 1762: 1593: 1528:code generators 1384:Syntax-directed 1361: 1223: 1219: 1217: 1215: 1177:www.forthos.org 1171:"www.forth.org" 1159:www.forthos.org 1153:"www.forth.org" 1144:www.forthos.org 1029:www.forthos.org 980: 963: 786:from that page: 715: 515: 506: 505: 504: 494:Robert McClenon 482: 456: 449: 434: 423: 417: 388: 351: 348: 343: 337: 325:Project-related 320: 301: 282: 256: 237: 218: 199: 180: 156: 101: 98: 95: 92: 91: 12: 11: 5: 3296: 3294: 3286: 3285: 3280: 3275: 3265: 3264: 3254: 3252: 3232: 3231: 3216: 3176: 3161: 3143: 3103: 3102: 3100: 3097: 3095: 3077: 3074: 3072: 3054: 3051: 3037: 3027: 3024: 2939: 2938: 2937: 2936: 2872: 2871: 2849:claims that a 2844: 2843: 2836: 2835: 2834: 2821: 2820: 2819: 2818: 2802: 2796: 2789: 2788: 2776: 2773: 2762: 2761: 2760: 2759: 2751: 2745: 2733: 2732: 2731: 2730: 2729: 2728: 2657: 2656: 2655: 2654: 2653: 2652: 2622: 2621: 2573: 2572: 2571: 2570: 2569: 2568: 2521: 2520: 2519: 2518: 2517: 2516: 2476:formal grammar 2468: 2467: 2466: 2465: 2464: 2463: 2448:formal grammar 2436: 2435: 2434: 2433: 2432: 2431: 2419: 2418: 2417: 2416: 2415: 2414: 2386: 2385: 2384: 2383: 2329: 2328: 2327: 2326: 2325: 2324: 2310:formal grammar 2306: 2305: 2287: 2286: 2285: 2284: 2283: 2282: 2266: 2263: 2245: 2241: 2230: 2222: 2202: 2189: 2183: 2168: 2153: 2150: 2128: 2125: 2108: 2102: 2088:X (#V1) =: --> 2083: 2077: 2069: 2068:A CWIC Example 2066: 2018: 2006: 2001: 2000: 1999: 1998: 1997: 1996: 1965: 1964: 1959: 1955: 1951: 1947: 1935: 1934: 1933: 1932: 1931: 1930: 1906: 1905: 1904: 1903: 1882: 1881: 1871: 1870: 1869: 1868: 1862: 1861: 1855: 1852: 1825:Formal grammar 1821:Formal grammar 1817: 1816: 1815: 1814: 1811:Formal grammar 1779: 1776: 1770: 1767: 1761: 1758: 1735: 1734: 1733: 1732: 1721:What does the 1719: 1718: 1717: 1716: 1699: 1698: 1697: 1696: 1611:formal grammar 1592: 1589: 1573: 1572: 1571: 1570: 1547: 1546: 1545: 1544: 1534: 1533: 1532: 1531: 1517: 1516: 1515: 1514: 1491: 1490: 1489: 1488: 1455: 1454: 1453: 1452: 1427:, is a formal 1406: 1405: 1404: 1403: 1390:. Compiling a 1360: 1357: 1330: 1329: 1328: 1327: 1308: 1307: 1306: 1305: 1283: 1282: 1281: 1280: 1255:, is a formal 1180: 1179: 1161: 1146: 1126: 1100: 1099: 1098: 1097: 1077: 1076: 1062: 1061: 1052: 1047: 992: 991: 979: 976: 975: 974: 962: 959: 957: 935: 934: 930: 929: 924: 923: 918: 917: 912: 911: 907: 906: 902: 901: 897: 896: 892: 891: 847: 846: 841: 840: 829: 828: 826:is in question 807: 806: 805: 804: 797: 796: 795: 794: 788: 787: 783: 782: 724: 723: 714: 711: 670: 634: 633: 600:Formal grammar 591: 590: 560: 559: 558: 557: 554: 551: 548: 545: 542: 527: 526: 516: 507: 486: 485: 484: 483: 481: 478: 475: 474: 453: 441: 440: 428: 425: 424: 419: 415: 413: 410: 409: 406: 405: 400: 390: 389: 384: 378: 369: 368: 365: 364: 361: 360: 357: 356: 353: 352: 350: 349: 347: 346: 329: 321: 319: 318: 312: 302: 300: 299: 293: 283: 281: 280: 275: 267: 257: 255: 254: 248: 238: 236: 235: 229: 219: 217: 216: 210: 200: 198: 197: 191: 181: 179: 178: 173: 167: 157: 155: 154: 148: 136: 134: 133: 121: 120: 108: 107: 105: 88:the discussion 74: 62: 61: 56: 44: 43: 37: 26: 13: 10: 9: 6: 4: 3: 2: 3295: 3284: 3281: 3279: 3276: 3274: 3271: 3270: 3268: 3258: 3253: 3245: 3241: 3228: 3227: 3220: 3217: 3212: 3208: 3204: 3200: 3196: 3189: 3187: 3185: 3183: 3181: 3177: 3172: 3165: 3162: 3157: 3150: 3148: 3144: 3139: 3126: 3118: 3111: 3109: 3105: 3098: 3096: 3093: 3092: 3088: 3084: 3076:Rfc mediation 3075: 3073: 3070: 3069: 3065: 3061: 3052: 3050: 3049: 3045: 3041: 3035: 3033: 3025: 3023: 3022: 3018: 3014: 3010: 3006: 3002: 2998: 2995: 2994: 2989: 2987: 2983: 2979: 2978: 2976: 2971: 2969: 2963: 2958: 2956: 2952: 2948: 2944: 2935: 2932: 2929: 2926: 2924: 2920: 2916: 2911: 2910: 2909: 2908: 2907: 2904: 2903: 2899: 2895: 2890: 2889: 2887: 2883: 2879: 2876:I wonder why 2868: 2864: 2860: 2859: 2858: 2856: 2852: 2848: 2841: 2837: 2832: 2831: 2829: 2828: 2827: 2825: 2815: 2811: 2807: 2806: 2805: 2804: 2801: 2797: 2795: 2793: 2787: 2782: 2781: 2780: 2774: 2772: 2771: 2766: 2756: 2755: 2754: 2753: 2749: 2746: 2744: 2742: 2738: 2726: 2725: 2724: 2723: 2722: 2721: 2720: 2718: 2714: 2713:bootstrapping 2710: 2706: 2704: 2703:bootstrapping 2700: 2696: 2692: 2688: 2684: 2680: 2676: 2672: 2670: 2665: 2660: 2649: 2648: 2647: 2646: 2645: 2644: 2643: 2641: 2636: 2634: 2630: 2626: 2619: 2615: 2611: 2607: 2604: 2601: 2599: 2595: 2590: 2589: 2588: 2586: 2582: 2578: 2565: 2564: 2563: 2562: 2561: 2560: 2559: 2556: 2551: 2548: 2544: 2543:bootstrapping 2540: 2536: 2535:bootstrapping 2532: 2528: 2524: 2513: 2512: 2511: 2510: 2509: 2508: 2507: 2505: 2501: 2497: 2493: 2489: 2485: 2481: 2477: 2473: 2461: 2460: 2459: 2458: 2457: 2456: 2455: 2453: 2449: 2445: 2441: 2429: 2428: 2427: 2426: 2425: 2424: 2423: 2412: 2411: 2410: 2409: 2408: 2407: 2406: 2404: 2400: 2396: 2395: 2391: 2382: 2379: 2376: 2374: 2370: 2366: 2361: 2360: 2359: 2358: 2357: 2355: 2351: 2347: 2343: 2339: 2335: 2333: 2322: 2319: 2318: 2317: 2316: 2315: 2314: 2313: 2311: 2303: 2299: 2295: 2294: 2293: 2290: 2280: 2279: 2278: 2277: 2276: 2275: 2274: 2272: 2269:My adversary 2264: 2262: 2258: 2254: 2250: 2240: 2237: 2229: 2221: 2201: 2188: 2182: 2179: 2175: 2167: 2164: 2158: 2151: 2149: 2146: 2142: 2139: 2136: 2133: 2126: 2124: 2121: 2117: 2114: 2107: 2101: 2098: 2094: 2082: 2076: 2073: 2067: 2065: 2062: 2058: 2053: 2051: 2046: 2044: 2040: 2036: 2032: 2029:It's obvious 2027: 2026: 2017: 2014: 2010: 2004: 1995: 1991: 1987: 1983: 1982: 1981: 1977: 1973: 1969: 1968: 1967: 1966: 1963: 1944: 1943: 1942: 1940: 1929: 1925: 1921: 1918: 1917: 1912: 1911: 1910: 1909: 1908: 1907: 1902: 1898: 1894: 1890: 1886: 1885: 1884: 1883: 1879: 1878: 1877: 1876: 1866: 1865: 1864: 1863: 1858: 1857: 1853: 1851: 1850: 1845: 1840: 1837: 1834: 1830: 1826: 1822: 1812: 1808: 1804: 1803: 1802: 1801: 1800: 1797: 1792: 1788: 1784: 1777: 1775: 1768: 1766: 1759: 1757: 1755: 1751: 1747: 1746:bootstrapping 1742: 1740: 1739:bootstrapping 1730: 1729: 1728: 1727: 1726: 1724: 1723:bootstrapping 1714: 1713:bootstrapping 1709: 1708: 1707: 1706: 1705: 1703: 1695: 1693: 1692:bootstrapping 1689: 1688:bootstrapping 1684: 1683: 1682: 1681: 1680: 1677: 1673: 1671: 1670:bootstrapping 1667: 1666:bootstrapping 1662: 1661:bootstrapping 1657: 1656:bootstrapping 1651: 1650: 1645: 1643: 1638: 1636: 1631: 1629: 1627: 1622: 1618: 1616: 1612: 1607: 1606: 1602: 1596: 1590: 1588: 1586: 1582: 1577: 1568: 1564: 1560: 1556: 1551: 1550: 1549: 1548: 1542: 1538: 1537: 1536: 1535: 1529: 1525: 1521: 1520: 1519: 1518: 1512: 1511:Bootstrapping 1508: 1507:bootstrapping 1503: 1499: 1495: 1494: 1493: 1492: 1486: 1483: 1479: 1475: 1471: 1467: 1464:that reads a 1463: 1459: 1458: 1457: 1456: 1450: 1446: 1442: 1438: 1434: 1430: 1426: 1422: 1418: 1414: 1410: 1409: 1408: 1407: 1401: 1397: 1393: 1389: 1385: 1381: 1378: 1377: 1376: 1375: 1374: 1371: 1370:bootstrapping 1367: 1366:bootstrapping 1358: 1356: 1355: 1351: 1347: 1342: 1338: 1335: 1325: 1324:bootstrapping 1320: 1316: 1312: 1311: 1310: 1309: 1303: 1299: 1295: 1292:that reads a 1291: 1287: 1286: 1285: 1284: 1278: 1274: 1270: 1266: 1262: 1258: 1254: 1250: 1246: 1242: 1238: 1237: 1236: 1235: 1234: 1229: 1224:</ref: --> 1211: 1208: 1207: 1202: 1201: 1199: 1195: 1191: 1185: 1178: 1175: 1172: 1169: 1167: 1162: 1160: 1157: 1154: 1150: 1147: 1145: 1142: 1140: 1136: 1132: 1127: 1124: 1121: 1120: 1119: 1116: 1114: 1109: 1108: 1105: 1096: 1092: 1091: 1090: 1089: 1088: 1086: 1082: 1074: 1070: 1067: 1066: 1065: 1060: 1058: 1053: 1051: 1048: 1046: 1045: 1040:'And here on 1039: 1036: 1033: 1032:www.forth.org 1030: 1027: 1024: 1022: 1018: 1014: 1009: 1008: 1007: 1005: 1001: 997: 989: 985: 984: 983: 977: 972: 971: 970: 968: 960: 958: 955: 954: 950: 946: 942: 938: 932: 931: 926: 925: 920: 919: 914: 913: 909: 908: 904: 903: 899: 898: 894: 893: 889: 888: 887: 884: 880: 876: 873: 867: 863: 859: 855: 853: 843: 842: 838: 837: 836: 833: 827: 823: 822: 821: 818: 816: 811: 801: 800: 799: 798: 792: 791: 790: 789: 785: 784: 780: 777: 776: 775: 771: 767: 763: 759: 755: 753: 747: 745: 744:bootstrapping 739: 735: 731: 727: 721: 720: 719: 712: 710: 709: 705: 701: 696: 695: 691: 687: 682: 679: 676: 673: 668: 665: 663: 658: 654: 650: 648: 643: 639: 631: 630: 629: 626: 625: 621: 617: 613: 609: 605: 601: 597: 588: 584: 580: 576: 575: 574: 573: 569: 565: 555: 552: 549: 546: 543: 540: 539: 538: 537: 536: 533: 530: 524: 521: 520: 519: 514: 503: 499: 495: 491: 479: 472: 468: 464: 459: 454: 447: 446: 437: 432: 427: 426: 412: 411: 404: 401: 399: 396: 395: 392: 391: 387: 382: 377: 376: 373: 342: 335: 331: 330: 328: 326: 322: 317: 314: 313: 311: 309: 308: 303: 298: 295: 294: 292: 290: 289: 284: 279: 276: 273: 269: 268: 266: 264: 263: 258: 253: 250: 249: 247: 245: 244: 239: 234: 231: 230: 228: 226: 225: 220: 215: 212: 211: 209: 207: 206: 201: 196: 193: 192: 190: 188: 187: 182: 177: 174: 172: 169: 168: 166: 164: 163: 158: 153: 150: 149: 147: 145: 144: 139: 138: 135: 131: 127: 126: 123: 122: 118: 114: 113: 109: 106: 89: 85: 81: 80: 75: 72: 68: 67: 63: 60: 57: 54: 50: 45: 41: 35: 31: 27: 23: 18: 17: 3256: 3251: 3236:Cite error: 3225: 3219: 3205:(6): 11–29. 3202: 3198: 3170: 3164: 3155: 3116: 3094: 3079: 3071: 3056: 3036: 3031: 3029: 2999: 2996: 2990: 2980: 2973: 2965: 2959: 2940: 2912: 2905: 2901: 2891: 2875: 2873: 2845: 2822: 2799: 2790: 2778: 2763: 2734: 2707: 2673: 2661: 2658: 2637: 2623: 2591: 2574: 2552: 2525: 2522: 2499: 2495: 2469: 2437: 2420: 2397: 2393: 2387: 2362: 2336: 2330: 2307: 2291: 2288: 2268: 2259: 2255: 2251: 2248: 2238: 2234: 2226: 2218: 2195: 2186: 2180: 2176: 2172: 2159: 2155: 2147: 2143: 2140: 2137: 2134: 2130: 2122: 2118: 2115: 2111: 2105: 2099: 2095: 2091: 2080: 2074: 2071: 2060: 2054: 2047: 2028: 2023: 2005: 2002: 1972:46.13.191.93 1945: 1936: 1915: 1893:46.13.191.93 1888: 1872: 1848: 1841: 1838: 1818: 1793: 1789: 1785: 1781: 1772: 1763: 1743: 1736: 1720: 1700: 1685: 1678: 1674: 1652: 1648: 1646: 1641: 1639: 1632: 1624: 1623: 1619: 1608: 1597: 1594: 1578: 1574: 1563:symbol table 1559:input/output 1502:metalanguage 1498:metalanguage 1482:metalanguage 1466:metalanguage 1441:metalanguage 1429:metalanguage 1417:metalanguage 1392:metalanguage 1380:Metacompiler 1379: 1362: 1343: 1339: 1331: 1319:metalanguage 1315:metalanguage 1294:metalanguage 1269:metalanguage 1257:metalanguage 1245:metalanguage 1220:<ref: --> 1216:Cite error: 1212: 1209: 1205: 1203: 1187: 1181: 1163: 1148: 1128: 1117: 1112: 1110: 1107: 1103: 1101: 1094: 1078: 1063: 1054: 1049: 1041: 1015:is coded in 1010: 993: 981: 964: 956: 943: 939: 936: 885: 881: 877: 871: 868: 864: 860: 856: 848: 834: 830: 825: 819: 814: 812: 808: 772: 768: 764: 760: 756: 748: 740: 736: 732: 728: 725: 716: 697: 683: 680: 677: 674: 669: 666: 659: 655: 651: 641: 635: 627: 595: 592: 561: 534: 531: 528: 522: 517: 508: 458:Metacompiler 430: 385: 372: 324: 323: 307:Unreferenced 305: 304: 286: 285: 260: 259: 241: 240: 222: 221: 203: 202: 184: 183: 160: 159: 141: 140: 77: 40:WikiProjects 29: 3040:Steamerandy 3013:Steamerandy 3005:Steamerandy 2986:Damon Simms 2982:Damon Simms 2975:Damon Simms 2968:Damon Simms 2962:Damon Simms 2894:Damon Simms 2847:Damon Simms 2824:Damon Simms 2812:. C++ is a 2792:Damon Simms 2765:Damon Simms 2748:Damon Simms 2717:Damon Simms 2577:Damon Simms 2555:Damon Simms 2553:Apparently 2547:Damon Simms 2539:Damon Simms 2531:Damon Simms 2527:Damon Simms 2484:Damon Simms 2480:Damon Simms 2472:Damon Simms 2302:Damon Simms 2298:Damon Simms 2050:Damon Simms 2039:Damon Simms 2035:Damon Simms 2009:Damon Simms 1986:Steamerandy 1920:Steamerandy 1702:Damon Simms 1615:Damon Simms 1581:Damon Simms 1478:contraction 1346:Steamerandy 945:Damon Simms 700:Steamerandy 686:Steamerandy 662:Damon Simms 616:Steamerandy 608:Steamerandy 564:Steamerandy 471:its history 3267:Categories 3099:References 2817:described. 2784:developed. 2612:must be a 2075:Figure IV 1569:functions. 1439:is a weak 1267:is a weak 872:and others 461:page were 3244:help page 3125:cite book 2496:generates 2081:Figure V 2043:TREE-META 2013:TREE-META 1649:So what!! 1449:semantics 1386:compiler 1277:semantics 1228:help page 1226:(see the 642:meta-step 403:Archive 2 398:Archive 1 195:Computing 3083:PizzaMan 2826:Stated: 1485:compiler 1474:compiler 1433:ALGOL 60 1413:metadata 1400:semantic 1388:compiler 1302:compiler 1261:ALGOL 60 1241:metadata 845:article. 386:Archives 243:Maintain 186:Copyedit 30:redirect 3060:Maproom 2913:* When 2697:first. 2273:wrote: 1807:grammar 1796:grammar 1524:parsers 1500:. This 1462:program 1317:. This 1290:program 1129:* When 1079:So the 1011:* When 431:14 days 224:Infobox 162:Cleanup 3134:|date= 2870:claim. 2515:stuff) 2444:Damons 1939:"CWIC" 1875:"CWIC" 1704:said: 1565:, and 1445:syntax 1396:syntax 1273:syntax 916:stuff) 585:. See 577:Is an 463:merged 205:Expand 36:scale. 3001:Damon 2951:forth 2947:forth 2943:forth 2923:forth 2919:forth 2915:forth 2898:forth 2886:Damon 2878:Damon 2867:forth 2863:forth 2840:forth 2741:forth 2737:Damon 2709:Damon 2699:Damon 2695:forth 2691:forth 2687:forth 2683:Damon 2679:forth 2677:is a 2675:Damon 2669:Damon 2664:Damon 2640:forth 2633:forth 2629:forth 2625:Damon 2618:forth 2614:forth 2610:Damon 2598:forth 2594:forth 2592:When 2585:forth 2581:forth 2567:logic 2504:Damon 2492:Damon 2488:Damon 2452:Damon 2440:Damon 2403:Damon 2399:Damon 2390:forth 2373:forth 2369:forth 2365:forth 2363:When 2354:forth 2350:forth 2346:forth 2342:forth 2338:Damon 2332:Damon 2321:Damon 2271:Damon 2163:Damon 2057:Damon 2031:Damon 1635:forth 1626:forth 1601:forth 1585:forth 1198:forth 1194:forth 1190:forth 1184:forth 1166:forth 1139:forth 1135:forth 1131:forth 1123:forth 1085:forth 1081:forth 1057:forth 1021:forth 1017:forth 1013:forth 1000:forth 996:forth 988:forth 967:forth 922:logic 465:into 288:Stubs 262:Photo 119:with: 28:This 3138:help 3064:talk 3044:talk 3017:talk 3009:talk 2685:put 1990:talk 1976:talk 1924:talk 1897:talk 1526:and 1350:talk 986:The 949:talk 704:talk 690:talk 620:talk 612:talk 568:talk 498:talk 3207:doi 2960:So 2638:If 2608:So 1480:of 1437:BNF 1421:BNF 1265:BNF 1249:BNF 1095:NOT 480:RFC 3269:: 3246:). 3238:A 3201:. 3197:. 3179:^ 3146:^ 3129:: 3127:}} 3123:{{ 3107:^ 3089:) 3087:♨♨ 3066:) 3046:) 3038:-- 3019:) 2957:? 2537:. 2170:}} 2021:; 1992:) 1978:) 1926:) 1899:) 1756:. 1561:, 1557:, 1435:. 1423:, 1352:) 1344:-- 1263:. 1251:, 1230:). 1218:A 1115:. 951:) 854:. 706:) 692:) 684:-- 649:. 622:) 570:) 500:) 344:}} 338:{{ 3213:. 3209:: 3203:5 3173:. 3158:. 3140:) 3136:( 3085:( 3062:( 3042:( 3015:( 3007:( 2970:. 2800:? 1988:( 1974:( 1962:. 1960:i 1956:i 1952:i 1948:i 1922:( 1895:( 1813:" 1711:( 1487:. 1348:( 947:( 742:( 702:( 688:( 618:( 610:( 589:. 566:( 525:. 496:( 473:. 327:: 310:: 291:: 274:) 265:: 246:: 227:: 208:: 189:: 165:: 146:: 42::

Text is available under the Creative Commons Attribution-ShareAlike License. Additional terms may apply.

Index