expression      = <
  noexpr        = .
  expression_c      = [bpos: tPosition] [epos: tPosition] <
    qualified_symbol    = [ident: tWIdent] <
      noname        = .
      ident     = .
      alias_ident   = .
      qualification = [pos: tPosition] qualified_symbol .
      generic_symbol    = type_arg_list <
    generic_ident   = .
    generic_member  = [pos: tPosition] qualified_symbol .
      > .
    > .
    aggregate_expr  = expression_list .
    anonymous_expr  = parameter_list: decl_list statement_list .
    assign_expr     = lval: expression_c rval: expression_c
              [Operator: toperator] [pos: tPosition] .
    as_expr     = expression: expression_c type .
    base_expr       = .
    binary_expr     = lop: expression_c rop: expression_c
              [Operator: toperator] [pos: tPosition] .
    call_expr       = expression: expression_c expression_list .
    cast_expr       = type expression: expression_c .
    checked_expr    = expression: expression_c .
    conditional_expr    = condition: expression_c true_expr: expression_c
              false_expr: expression_c .
    default_expr    = type .
    is_expr     = expression: expression_c type .
    member_access_expr  = [ident: tWIdent] [pos: tPosition] type_arg_list <
      ptr_member_expr   = expression: expression_c .
      select_expr   = expression: expression_c .
      type_member_expr  = type .
    > .
    new_array_expr  = type expression .
    new_expr        = type expression_list .
    null_expr       = .
    parentheses_expr    = expression: expression_c .
    sizeof_expr     = type .
    stackalloc_expr = type expression .
    subscript_expr  = base: expression_c expression_list .
    this_expr       = .
    typeof_expr     = type .
    unary_expr      = expression: expression_c
              [Operator: toperator] [pos: tPosition] .
    unchecked_expr  = expression: expression_c .
    literal     = <
      bool_literal  = [value: rbool] .
      sr_literal    = [value: tWStringRef] <
    int_literal = [int_value: us_long] .
    real_literal    = .
    char_literal    = .
    string_literal  = .
      > .
    > .
  > .
> .

FUNCTION TranslateExpression (expression) {Cu2Expression*}

noexpr(...) :- RETURN 0;.

this : qualified_symbol(...) :- RETURN TranslateIdentExpr(this); .

this : aggregate_expr(expression_list := expression_list) :-
    result : {Cu2ListExpr*};
    {
        result = new Cu2ListExpr;
        TranslateExpressionList(expression_list,result);
    };
    RETURN result;
    .

this : anonymous_expr(parameter_list := parameter_list, statement_list := statement_list) :-
    result : {Cu2DelegateImplExpr*};
    {
        result = new Cu2DelegateImplExpr;
        Cu2Operation* pOperation = new Cu2Operation;
        result->m_cslOperation.Set(pOperation);
        TranslateDeclarationList(parameter_list,this,pOperation);
        UnsetAndPushProp(TranslateValueAsExpr);
        TranslateStatementList(statement_list,this,MakeActionContext(pOperation));
        PopContextProp();
    };
    RETURN result;
    .

this : assign_expr(lval := lval, rval := rval, Operator := Operator) :-
    RETURN 
        {           
            MakeBinaryExpr(TranslateExpression(lval),
                           COperatorsMapper\::MapOperator(Operator,true), 
                           TranslateExpression(rval)
                           )
        };
    .    

this : as_expr(expression := expression, type := type) :-
    RETURN MakeAsExpr(TranslateExpression(expression), TranslateType(type));
    .    

this : base_expr (...) :- 
    RETURN {new Cu2BaseExpr() };
    .

и т.д (не могу все показывать, ибо (c) )

this : assign_expr(lval := lval, rval := rval, Operator := Operator) :-

K>У меня тоже времени на разработку собственных идей не хватает. Работа

        // the special case for unary operators
        | TT.TExpr.Call (TT.TExpr.OpCode (name), [parm], _) =>
          append (name);
          append ("(");
          recurse (parm.expr);
          append (")");

        // the special case for infix binary operators
        | TT.TExpr.Call (TT.TExpr.OpCode (name), [parm1, parm2], _) =>
          append ("(");
          recurse (parm1.expr);
          append (" " + name + " ");
          recurse (parm2.expr);
          append (")")

        // pretty print the list constructors
        | TT.TExpr.Call (TT.TExpr.StaticRef (_, mem, _), _, _) when is_list_cons (mem) =>
          print_list_constructors (expr)
              
        // write all the other calls in prefix form 
        | TT.TExpr.Call (func /* PExpr */, parms /* list [Parm] */, _) =>
          recurse (func);
          append (" (");
          print_fun_call_parms (parms);
          append (")")

subst UnicodeEscapeSequence ::=
    "\\u" HexDigit HexDigit HexDigit HexDigit |
    "\\U" HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit;
subst HexDigit ::= "0".."9" | "A".."F" | "a".."f";
Identifier ::= "@"? IdentifierStartCharacter IdentifierPartCharacter*;
subst IdentifierStartCharacter ::= U_Ll | U_Lu | U_Lt | U_Lm | U_Lo | 
        UnicodeEscapeSequence | "_";
subst IdentifierPartCharacter ::=
        U_Nl | U_Ll | U_Lu | U_Lt | U_Lm | U_Lo | U_Nd |
        UnicodeEscapeSequence | U_Mc | U_Mn | "_";

_O_>То, что сам написал пару генераторов, это похвально

expr =
        expr * expr
    | expr / expr
    | expr + expr
    | expr - expr
    | ...

_O_>Когда я учился в универе, мне казалось, что все можно написать за пару ночей (и ведь действительно писалось!) Потом реализм наступил.

_O_>Хочешь задачку, полезную для общества ? — Подумай надо созданием UML Virtual Machine. Т.е. над машиной, которая могла бы интерпретировать UML-модели (только бери последнюю версию стандарта, где action semantics есть). Это позволит симулировать модели без необходимости кодогенерации исполняемого приложения. А симуляция моделей — вещь нужная всяким военным, аэрокосмическим, телекоммуникационным компаниям (правда западным, не нашим).

K>Ну, 2700 — это ещё жить можно Вывод типов в C# — штука несложная, т.к. она производится только для generic'ов. Хотя и алгоритм вывода типов в системе типов Хиндли-Милнера тоже весьма прост. Правда, подобное утверждение верно только для классической системы типов Хиндли-Милнера. Если в неё добавить type classes, перегрузку или что-то в этом роде, написание вывода типов на каком-нибудь C++ превращается в сущий ад.

K>expr =
K>        expr * expr
K>    | expr / expr
K>    | expr + expr
K>    | expr - expr
K>    | ...
K>

(x) -y

A < B, C >>  D  // shift or type arguments ?

K>Не, на мне и так висит несколько задачек, полезных для общества Всякие там генераторы и компиляторы — это исключительно в свободное время

this : as_expr(expression := expression, type := type) :-
    RETURN MakeAsExpr(TranslateExpression(expression), TranslateType(type));
    .

this : as_expr(expression := expression, type := type) :-

MakeAsExpr

TranslateExpression
TranslateType

<[ if ($methodName(..$parms) $rtueExpr else $falseExpr ]>