AVK>Но грамматика C# КЗ, а С++ КС. Получается что ты опроверг свое первоначальное утверждение .

    int a = 3;
    a = a * 10;

    char *a = "hello, world";
    a = a * 10;

<нетерминал>:
<последовательность терминалов и нетерминалов>

stmt := if expr then stmt
       | if expr then stmt else stmt
       | other

if E1 then if E2 then S1 else S2

stmt           := matched_stmt
                 | unmatched_stmt

matched_stmt   := if expr then matched_stmt else matched_stmt
                 | other

unmatched_stmt := if expr then stmt
                 | if expr then matched_stmt else unmatched_stmt

if-statement:
   if ( boolean-expression ) embedded-statement
   if ( boolean-expression ) embedded-statement else embedded-statement

An else part is associated with the lexically nearest preceding if that is allowed by the syntax.

DOI=1,100
DOWHILE(a>b)
DO10J=1,100,3
...
10CONTINUE
ENDDO
ENDDO

Рассмотрим абстрактный язык L1 = { wcw | w <принадлежит> (a|b)* }. L1 состоит из всех слов, образованных повторяющимися строками из a и b, разделенными символом c, например aabcaab. Можно доказать, что этот язык не является контекстно-свободным. Он абстрагирует проблему проверки объявления переменных до их использования — первое w в wcw представляет объявление переменной, а второе w — ее использование. Из того, что L1 не является контекстно-свободным языком, следует, что языки типа Algol или Pascal не есть контекстно-свободными, т.к. в них требуется объявление переменной до ее использования, а идентификаторы могут иметь произвольную длину.

9.2.1 Lexical grammar The lexical grammar of C# is presented in §9.2.3, §9.4, and §9.5. The terminal symbols of the lexical grammar are the characters of the Unicode character set, and the lexical grammar specifies how characters are combined to form tokens (§9.4), white space (§9.3.3), comments (§9.3.2), and pre-processing directives (§9.5).

9.4 Tokens There are several kinds of tokens: identifiers, keywords, literals, operators, and punctuators. White space and comments are not tokens, though they act as separators for tokens.

token:: 
  identifier 
  keyword 
  integer-literal 
  real-literal 
  character-literal 
  string-literal
  operator-or-punctuator

17.6.2 Accessors
The accessor-declarations of a property specify the executable statements associated with reading and writing that property.

accessor-declarations:
    get-accessor-declaration set-accessor-declarationopt
    set-accessor-declaration get-accessor-declarationopt
get-accessor-declaration:
    attributesopt accessor-modifieropt get accessor-body
set-accessor-declaration:
    attributesopt accessor-modifieropt set accessor-body
    accessor-modifier: 
    protected 
    internal 
    private 
    protected internal 
    internal protected 
accessor-body: 
    block 
;

The accessor declarations consist of a get-accessor-declaration, a set-accessor-declaration, or both. Each accessor declaration consists of the token get or set followed by an accessor-body. For abstract and extern properties, the accessor-body for each accessor specified is simply a semicolon. For the accessors of any non-abstract, non-extern property, the accessor-body is a block which specifies the statements to be executed when the corresponding accessor is invoked.

V>Твой лексер так же "съедает" разделители, ты написал его так, что они не попадают на вход синтаксического анализатора (может поэтому тебе почудился 'g_e_t' ?)

Xxx Yyy
{
  get
  {
    return get;
  }
}

Xxx Yyy
{
  get
  {
    return g;
  }
}

Xxx Yyy
{get{
    returnget; // тут должна быть ошибка!
  }
}

COMPILER Property

    protected Token ProcessPragma(Token curr) { return curr; }
    void BeforeInitTokens() { }


CHARACTERS
    letter  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".

TOKENS
    ident   = letter { letter }.

    space   = " " | "\t" | "\r" | "\n".

PRODUCTIONS

Spaces = { space }.

Property = Spaces ident Spaces ident Spaces 
    "{" Spaces 
        "get" Spaces 
        "{" Spaces 
            "return" Spaces ident Spaces ";" Spaces 
        "}" Spaces 
    "}" Spaces.

END Property.

Calculator         = Expr EOF.
Expr               = UnaryExpr AdditiveExpr.
AdditiveExpr       = MultiplicativeExpr { ("+" | "-") UnaryExpr MultiplicativeExpr }.
MultiplicativeExpr = { ("*" | "/" | "%") UnaryExpr }.
UnaryExpr          = { "+" | "-" } PrimaryExpr.
PrimaryExpr        = literal | "(" Expr ")".

using System;

class get
{
    static get set;

    static get assembly { get { return set; } }


    static void Main()
    {
        set = new get();
    }
}

 A1 a = new B1();

Identificator ::= CommonIdentificator | Keyword_get | Keyword_add и т.д.

GetPropBody ::= Keyword_get '{' Expressions '}'.
SetPropBody ::= Keyword_set '{' Expressions '}'.
GetSetPropBody ::= (GetPropBody SetPropBody) | (SetPropBody GetPropBody).
Property ::= Modifiers TypeIdentificator Identificator '{' (GetPropBody | SetPropBody | GetSetPropBody) '}'.

public class Class1 {
    public class set {}
    public set get { get { return new set(); } }
}

почему грамматика C# КЗ?
какие выражения не удается представить в КС — форме?

AVK> грамматика C# КЗ, а С++ КС

In linguistics and computer science, a context-free grammar (CFG) is a formal grammar in which every production rule is of the form

V > w
where V is a non-terminal symbol and w is a string consisting of terminals and/or non-terminals. The term "context-free" comes from the fact that the non-terminal V can always be replaced by w, regardless of in what context it occurs.

V>>как ты думаешь, это синтаксическая или семантическая ошибка?

struct A { int i;}; 
A a1 = { 10 };
A a2 = { 20 };
A a3 = a1 * a2;

inline A operator *(const A& a1, const A& a2) 
{ A tmp = { a1.i * a2.i }; return tmp; }

AVK>Но грамматика C# КЗ, а С++ КС.

context-sensitive language is a formal language that can be defined by a context-sensitive grammar.

The syntaxes of most programming languages are context-free grammars (or very close to it).

V>Контестно-зависимый язык — это язык, порождаемый контекстно-зависимой грамматикой, так гласит теория

Xxx Xxx
{
    g e t
    {
        ...
    }
}

Formal definition
In the classic formalization of generative grammars first proposed by Noam Chomsky in the 1950s, a grammar G consists of the following components:

A finite set N of nonterminal symbols.
A finite set ? of terminal symbols that is disjoint from N.
A finite set P of production rules where a rule is of the form
string in (? U N)* > string in (? U N)*

V>С использованием техники lexer->parser тебе действительно необходимы обходные пути, я полностью это признаю. Но, вроде бы, спорил совсем не с этим?

returnget; // ошибка! Но фортрано-подобный сканер ее не заметит!

return(get);

VD>returnget; // ошибка! Но фортрано-подобный сканер ее не заметит!

чем фортрано-подобный сканер отличается от не-фортрано-подобного? может быть только правилами? тогда может и заметить ;)

VD>return(get);
VD>

DelimiterChar ::= ' ' | '\t' | '\n' | ... и т.д.
Delimiter ::= DelimiterChar | (DelimiterChar Delimiter).

Expression ::= сложные правила для выражений.
Expression ::= [Delimiter] Expression [Delimiter].
Expression ::= '(' Expression ')'.

Identificator ::= Alpha | (Identificator (Alpha | Digit)).
ReturnExpression ::= Keyword_return | (Keyword_return Expression) ';'

AVK> грамматика C# КЗ, а С++ КС

AVK>>Ага, значит КЗ мощнее КС. Но грамматика C# КЗ, а С++ КС. Получается что ты опроверг свое первоначальное утверждение .

F(G<A, B>(1))

F(G<A, B>((1)))

F(G<A, (B > (1)))

a = b is X<Y> 1;

X<Y<A, B>>

V>упрощенно:

V>PopertyDecl ::= GetPropertyDecl
V>PopertyDecl ::= SetPropertyDecl
V>PopertyDecl ::= GetSetPropertyDecl

V>GetProperty ::= TypeID VarID '{' 'get' FuncBody '}'
V>SetProperty ::= TypeID VarID '{' 'set' FuncBody '}'
V>GetSetProperty ::= TypeID VarID '{' 'set' FuncBody 'get' FuncBody '}'
V>GetSetProperty ::= TypeID VarID '{' 'get' FuncBody 'set' FuncBody '}'


V>если представимо в БНФ, то КС

AccessorDecls<RMemberPropertyImpl prop>                        
=
    { AttributeSection<sections> }
    (
            IF (IdentIsGet())
            (                                                  
                identifier                                     
                (
                        Block<prop.GetStatements>              
                    |   WEAK ";"                               
                )
                [                                              
                    { AttributeSection<sections> }             
                    identifier                                 
                    (                                          
                            Block<prop.SetStatements>          
                        |   WEAK ";"                           
                    )
                ]
            )
        |   IF (IdentIsSet())
            (                                                  
                identifier                                     
                (                                           
                        Block<prop.SetStatements>              
                    |   WEAK ";"                               
                )
                [                                              
                    { AttributeSection<sections> }             
                    identifier                                 
                    (
                            Block<prop.GetStatements>          
                        |   WEAK ";"                           
                    )
                ]
            )
        |   identifier   /*отлов ошибок в именовании эксесоров*/                                       
    )
.

Xxx get;

Xxx Xxx
{
    get
    {
        return get;
    }
}

Сами языки программирования, как уже было скзано не могут быть полностью отнесены к типу КС-языков, поскольку предполагают некоторую контекстную зависимость в тексте исходной программы (например, такую, как необходимость предварительного описания переменных). Поэтому кроме синтаксического разбора практически все компиляторы предполагают дополнительный семантический анализ текста исходной программы. Этого можно было бы избежать, если построить компилятор на основе контекстно-зависимого распознавателя, но скорость работы такого компиляторы была бы недопустимо низка, поскольку время разбора в таком варианте будет экспоненциально зависеть от длины исходной программы. Комбинация из распознавателя КС-языка и дополнительного семантического анализатора является более эффективной с точки зрения скорости разбора исходной программы.

V>ReturnExpression ::= Keyword_return | (Keyword_return Expression) [Delimiter] ';'
V>

Мягко контекстно-зависимые грамматики – будучи несколько более мощными, чем КС-грамматики, грамматики данного класса позволяют анализировать большинство типов синтаксически релевантных нелокальных связей.