<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
   <channel>
      <title>Comp.compilers newsgroup</title>
      <link>http://compilers.iecc.com/</link>
      <description>The oldest and most popular online compilers forum.</description>
      <language>en-us</language>
      <generator>Compilers RSS kludge 0.1</generator>
      <managingEditor>compilers-request@iecc.com</managingEditor>
      <webMaster>webmaster@iecc.com</webMaster>
      <item>
         <title>Making semicolons optional moves LALR(1) language to LALR(2)?</title>
	 <pubDate>Sat, 6 Feb 2010 14:59:58 +0000 (UTC)</pubDate>
	 <author>"ng2010" &lt;ng2010@att.invalid&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/10-02-025</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/10-02-025</guid>
	 <description>For a hypothetical programming language that is LALR(1) and uses
semicolons as statement terminators, would a change that makes semicolons
only required on multi-statement lines and using the newline as an
implicit statement terminator make the language LALR(2)?
</description>
      </item>
      <item>
         <title>Infinite look ahead required by C++?</title>
	 <pubDate>Sat, 6 Feb 2010 14:58:38 +0000 (UTC)</pubDate>
	 <author>"ng2010" &lt;ng2010@att.invalid&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/10-02-024</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/10-02-024</guid>
	 <description>What elements of C++ make it so hard to parse? Is it a weakness of
compiler designs rather than a weakness of the language design? I've read
somewhere that the language requires potentially infinite look ahead.
Why? And how do compilers handle it?
[It's ambiguous syntax.  Others can doubtless fill in the details. -John]
</description>
      </item>
      <item>
         <title>Re: An example LL(K) language that is not LL(K-1) ?</title>
	 <pubDate>Sat, 6 Feb 2010 14:57:58 +0000 (UTC)</pubDate>
	 <author>Kaz Kylheku &lt;kkylheku@gmail.com&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/10-02-023</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/10-02-023</guid>
	 <description>On 2010-02-01, Chariton Karamitas &lt;chakaram@auth.gr&gt; wrote:
&gt; Hello,
&gt;
&gt; I don't think your assumption that any LL(k) can be transformed into
&gt; an LL(k-1) is correct. The 'k' in LL(k) is assumed to be the supremum
&gt; of lookahead symbols that you need in order to parse your input. So,
</description>
      </item>
      <item>
         <title>Re: An example LL(K) language that is not LL(K-1) ?</title>
	 <pubDate>Sat, 6 Feb 2010 14:56:12 +0000 (UTC)</pubDate>
	 <author>Chris F Clark &lt;cfc@shell01.TheWorld.com&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/10-02-022</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/10-02-022</guid>
	 <description>SLK Mail &lt;slkpg@cox.net&gt; writes:

&gt; Example:
&gt;
&gt; S -&gt; a A a
&gt; S -&gt; b A b a
&gt; A -&gt; b
&gt; A -&gt;
&gt;
&gt; Can you convert this to LL(1)?

Yes, there is no recursion in this grammar, therefore the language is
trivially regular and thus trivally, LL(1).
</description>
      </item>
      <item>
         <title>Re: An example LL(K) language that is not LL(K-1) ?</title>
	 <pubDate>Fri, 5 Feb 2010 22:33:07 +0000 (UTC)</pubDate>
	 <author>SLK Mail &lt;slkpg@cox.net&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/10-02-020</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/10-02-020</guid>
	 <description>The following is the reference for the original paper on LL(k). It
should have a proof of the superset relationship of k to k-1 for the
LL languages.

Rosenkrantz, D.J. and R.E. Stearns (1970). "Properties of
Deterministic Top-Down Grammars," Inf. and Control, 17 (3), pp
</description>
      </item>
      <item>
         <title>Re: An example LL(K) language that is not LL(K-1) ?</title>
	 <pubDate>Fri, 5 Feb 2010 22:32:32 +0000 (UTC)</pubDate>
	 <author>fortunatus &lt;daniel.eliason@excite.com&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/10-02-019</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/10-02-019</guid>
	 <description>On Feb 2, 6:57 am, klyjikoo &lt;klyji...@gmail.com&gt; wrote:
&gt;
&gt; Thanks to Hans, Consider this example :

You have indeed offered an example of and LL(2) grammar that is
equivalent to an LL(1) grammar.

However both grammars (if the derivation is correct) accept the same
</description>
      </item>
      <item>
         <title>Re: An example LL(K) language that is not LL(K-1) ?</title>
	 <pubDate>Fri, 5 Feb 2010 22:32:14 +0000 (UTC)</pubDate>
	 <author>Kaz Kylheku &lt;kkylheku@gmail.com&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/10-02-018</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/10-02-018</guid>
	 <description>On 2010-02-02, klyjikoo &lt;klyjikoo@gmail.com&gt; wrote:
&gt;
&gt;&gt; I don't think your assumption that any LL(k) can be transformed into
&gt;&gt; an LL(k-1) is correct. The 'k' in LL(k) is assumed to be the supremum
&gt;&gt; of lookahead symbols that you need in order to parse your input. So,
</description>
      </item>
      <item>
         <title>Re: An example LL(K) language that is not LL(K-1) ?</title>
	 <pubDate>Fri, 5 Feb 2010 22:31:52 +0000 (UTC)</pubDate>
	 <author>Chris F Clark &lt;cfc@shell01.TheWorld.com&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/10-02-017</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/10-02-017</guid>
	 <description>Although, I'm not an LL-language expert, I believe the trick to LL(k)
languages that aren't LL(k-1) is to have a (center) recursive rule
that needs k tokens to disambiguate.

Something like:

S := A
A := B C
B := b A d // 1 form of recursion
B := b a A a d // other form of recursion
</description>
      </item>
      <item>
         <title>Re: Detailed algorithms on inline optimization</title>
	 <pubDate>Wed, 3 Feb 2010 04:09:50 +0000 (UTC)</pubDate>
	 <author>anton@mips.complang.tuwien.ac.at (Anton Ertl)</author>
	 <link>http://compilers.iecc.com/comparch/article/10-02-016</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/10-02-016</guid>
	 <description>anton@mips.complang.tuwien.ac.at (Anton Ertl) writes:
&gt;Kaz Kylheku &lt;kkylheku@gmail.com&gt; writes:
&gt;&gt;On 2010-01-25, Anton Ertl &lt;anton@mips.complang.tuwien.ac.at&gt; wrote:
&gt;&gt;&gt; Chris Dodd &lt;cdodd@acm.org&gt; writes:
&gt;&gt;&gt;&gt;unsigned fib(unsigned n) { return n &lt; 2 ? n : fib(n-2) + fib(n-1); }
</description>
      </item>
      <item>
         <title>Re: An example LL(K) language that is not LL(K-1) ?</title>
	 <pubDate>Wed, 3 Feb 2010 04:09:32 +0000 (UTC)</pubDate>
	 <author>klyjikoo &lt;klyjikoo@gmail.com&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/10-02-015</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/10-02-015</guid>
	 <description>
&gt; I don't think your assumption that any LL(k) can be transformed into
&gt; an LL(k-1) is correct. The 'k' in LL(k) is assumed to be the supremum
&gt; of lookahead symbols that you need in order to parse your input. So,
&gt; suppose you have an LL(2) grammar, then you cannot convert it to an
</description>
      </item>
   </channel>
</rss>
