To evaluate this, it starts at the inner parenthesis.

3 7 is 10.

It represents integer.

But here is where the potential ambiguity comes in.

INT string and INT alone.

Neither of these rules makes the grammar ambiguous.

E goes to E plus E or E goes to int.

Now let's dig into this notion of parcing states a little bit more.

Since this one isn't recursive, there are only a finite number of strings in the language

So here's our grammar it has 4 rewrite rules.

This one corresponds to the first int in our input.

One of our grammar rules is A goes to INT string

I want to see if this one string could have been produced by our grammar.

So here the language of our grammar includes things like INT INl, INT INT INT.

It fits with our grammar and it's the input token we saw, and next, we'll want to shift over this (int).

int min minutes

int sec seconds

int alarm minutes before event to send an alarm

Prev

Next

0 Indicates that this event does not recur

1 This event recurs daily

2 This event recurs on a weekly basis

Use DEFAULT 0 instead.

Some of the popular ones are integer, which is for storing integers, float for storing floating point numbers, string for storing strings, and we've got a date for storing dates, we've got time for storing times, and then we've got date times for storing both dates and times.

This time, I'm going to give you the parse tree, and I want you to tell me what the grammar would have to be.

The dot over here is really important.

int id ID of that event.

However, if we were to add a few more INTs, this trick that I've done here of reducing INT goes to INT goes to INT if I had 1, 2, 3, 4, 5, 6 tokens,

We saw the integer token, and we were expecting that because one of our parse states here was

Let's say one of our current states is E goes to dot int, and we actually see that int.

This is consistent with the world that we've been presented.

We've seen two things to the left. There is one thing in our future.

And you put from the current state, state 2.

Alright, how about this?

Then it tries to take the type of 10, which is a type int, then it prints that type int.

Well, one way to view this is to think about the parse tree, which I've kind of drawn here upside down.

So, conceptually, one of the first things we'll do is shift.

So one of our rules is

Take over for lieutenant dualla.

Once we've seen the single int, then we could either be in the middle of parsing

Here's a much simpler grammar to try out this concept on.

So this is the second state that I could be in.

There is nothing to the past. Everything is to the future.

Starting with E, I choose to apply E goes to E plus E.