$EXTERN Lexer, Put, Arg, Open, Prout;

$ENTRY Go {
  = <Open 'w' 2 <Arg 2>><Put 2 <Parser : <Lexer <Arg 1>>>>;
}
Parser {
  : eTokens =
    <Program
      () /* список ошибок */
      () /* список функций */
      : eTokens
    >;
}

/*
Program =
  [$ENTRY] Name FunctionBody Program
  | $EXTERN ExternList Program
  | пусто .
*/

Program {
  tErrorList tFunctions (Directive tPosDir 'ENTRY') (Name tPosName : eName) : eTokens =
    <Program-Function
      tFunctions eName tPosName Entry
      <FunctionBody tErrorList ()() : eTokens>
    >;

  tErrorList tFunctions (Directive tPosDir 'ENTRY') tOtherToken : eTokens =
  <Program
    /* Добавляет сообщение */
    /* «позиция: unexpected token токен, expected function name» */
    /* Позиция и значение неожиданного токена выбирается из tOtherToken */
    <AddUnexpectedToken tErrorList tOtherToken 'function name'>
    tFunctions tOtherToken : eTokens
  >;

  tErrorList tFunctions (Name tPos : eName) : eTokens =
    <Program-Function
      tFunctions eName tPos Local
      <FunctionBody tErrorList : eTokens>
    >;

  tErrorList tFunctions (Directive tPos 'EXTERN') : eTokens =
    <ExternList tErrorList tFunctions : eTokens>;

  tErrorList tFunctions (EOF tPos '!') =
    /* Корректное завершение */
    <SemanticAnalysis tErrorList <Reverse tFunctions>>; /* REVERSE */

  tErrorList tFunctions tOtherToken : eTokens =
    <Program
      <AddUnexpectedToken
        tErrorList tOtherToken 'function definion or $EXTERN'
      >
      tFunctions : eTokens
    >;
}

FunctionBody {
  tErrorList (OpenBlock tposOpenBlock '{') : eTokens = 
    <Pattern tErrorList () () (()()) : eTokens >; 
    
  tErrorList token : eTokens = 
    <Pattern <AddExpectedCharacter tErrorList token 'open function body'> () () (()()) token : eTokens >; /* ErrorList Sentences Stack Scanned :Terms */
}

AddToken {
  tPattern eToken =
    tPattern : eToken; /* раз такой порядок, значит не нужно будет делать reverse */
}

/* ErrorList Sentences Stack Scanned :eTerms */
Pattern {
  tErrorList sentences openBrackets eScanned (Name posName : eName) : eTokens =
    <Prout 'Name'><Pattern tErrorList sentences openBrackets ((Name posName : eName) :eScanned)>;
    
  tErrorList sentences openBrackets eScanned (Char posChar : eChar) : eTokens =
    <Prout 'Char'><Pattern tErrorList sentences openBrackets ((Char posChar : eChar) : eScanned) : eTokens>;
  
  tErrorList sentences openBrackets eScanned (Number posNumber : eNumber) : eTokens =
    <Prout 'Number'><Pattern tErrorList sentences openBrackets ((Number posNumber : eNumber) : eScanned) : eTokens>;
    
  tErrorList sentences openBrackets (type eScanned) (Variable posVariable : eVariable) : eTokens =
    <Prout 'Variable' eVariable><Pattern tErrorList sentences openBrackets (type((Variable posVariable : eVariable) : eScanned)) : eTokens>;    

  tErrorList sentences eOpenBrackets (type eScanned) (OpenBracket posBracket '(') : eTokens =
    <Prout 'OpenBracket'><Pattern tErrorList sentences ((type eScanned) : eOpenBrackets) (BRACKET ())  : eTokens >;
    
  tErrorList sentences ((type eScanned) : eOpenBrackets) (BRACKET eInBrackets) (CloseBracket posBracket ')') : eTokens =
    <Prout 'CloseBracket'><Pattern tErrorList sentences eOpenBrackets (<ReverseCheckColon (BRACKET : eInBrackets ) > type eScanned) : eTokens >;
  

    
  /* Если образец закончился, то есть мы встретили '=' и стек пуст: ()
    значит начинаем разбирать результат */    
  tErrorList sentences () (() eScanned) (Assign posAssgn '=') : eTokens =
    <Prout 'Assign'><Result tErrorList sentences <Reverse eScanned> () () : eTokens >; /* вызываем Result и ждем пока обработается результат, чтоб
    все это прикрепить к предложениям */
  tErrorList sentences () (type eScanned) (Assign posAssgn '=') : eTokens =
    <Prout 'Assign'><Result tErrorList sentences <Reverse (type : eScanned)> () () : eTokens >;
  tErrorList eSentences () () (CloseBlock posCloseBlock '}') : eTokens =
    <Prout 'CloseBlock'><CompleteFunclion tErrorList eSentences : eTokens >;  
}

Result {
  
  tErrorList sentences pattern openBrackets eScanned (Name posName : eName) : eTokens =
    <Result tErrorList sentences pattern openBrackets ((Name posName : eName) : eScanned) : eTokens>;
    
  tErrorList sentences pattern openBrackets eScanned (Char posChar : eChar) : eTokens =
    <Result tErrorList sentences pattern openBrackets ((Char posChar : eChar) : eScanned) : eTokens>;
  
  tErrorList sentences pattern openBrackets eScanned (Number posNumber : eNumber) : eTokens =
    <Result tErrorList sentences pattern openBrackets ((Number posNumber : eNumber) : eScanned) : eTokens>;
    
  tErrorList sentences pattern openBrackets eScanned (Variable posVariable : eVariable) : eTokens =
    <Result tErrorList sentences pattern openBrackets ((Variable posVariable : eVariable) : eScanned) : eTokens>;
    
  tErrorList sentences pattern eOpenBrackets scanned (OpenBracket posBracket '(') : eTokens =
    <Result tErrorList sentences pattern (scanned : eOpenBrackets) ( )  : eTokens >;
    
  tErrorList sentences pattern (eScanned : eOpenBrackets) inBrackets (CloseBracket posBracket ')') : eTokens =
    <Result tErrorList sentences pattern eOpenBrackets (<ReverseCheckColon tErrorList inBrackets> : eScanned) : eTokens >;
  
  
  tErrorList eSentences pattern () scanned (Semicolon posSemicolon ';') : eTokens =
    <Pattern tErrorList ((pattern <Reverse scanned>) : eSentences) () (()()) : eTokens >; /* ErrorList Sentences Stack Scanned :Terms */
}

CompleteFunclion {
  tErrorList sentences : eTokens = 
    tErrorList <Reverse sentences> : eTokens;
}

ReverseCheckColon {
  ( term (Colon pos ':') :eTerms) = 
    <DoReverseCheck  eTerms (LAST term)>;
  terms = <DoReverseCheck  terms (NIL)>;
  /*tErrorList( term (Colon pos ':') :eTerms) = 
    <DoReverseCheck tErrorList eTerms (LAST term)>;
  tErrorList terms = <DoReverseCheck tErrorList terms (NIL)>;*/
}

DoReverseCheck {
 /* tErrorList ((Colon pos ':') : eTerms) reversed =
    <DoReverseCheck
      <AddUnexpectedToken tErrorList (Colon pos ':') 'colon'>
      eTerms
      reversed
    >;*/
  (term : eTerms) eReversed = 
    <DoReverseCheck eTerms (term : eReversed)>;
  () reversed = reversed;
}

Reverse {
  (term :eTerms) = 
    <DoReverse eTerms (LAST term)>;
  terms = <DoReverse terms (NIL)>;  
}

DoReverse {
  (term : eTerms) eReversed = 
    <DoReverse eTerms (term : eReversed)>;
  () reversed = reversed;
}

Program-Function {
  eFunctions tName tPos sAccess
  tErrorList tFunctionBody : eTokens =
  <Program
    tErrorList
    ((tName sAccess tPos tFunctionBody) : eFunctions) /* PUSH */
    : eTokens
  >;
}

/*
ExternList = FunctionName "," ExternList | ";"
*/

ExternList {
  tErrorList eFunctions (Name tPosName tName) (Comma tPosComma ',') : eTokens =
  <ExternList
    tErrorList
    ((tName Entry tPosName NoBody) : eFunctions) /* PUSH */
    : eTokens
  >;

tErrorList tFunctions (Semicolon tPos ';') : eTokens =
  <Program tErrorList tFunctions : eTokens>;

/*тут ещё будет обработка ошибок (нет имени, нет запятой, внезапный EOF, нет точки с запятой)*/
}

SemanticAnalysis {
  tErrorList functions = tErrorList functions;
}

AddUnexpectedToken {
  errorList token : eMessage = 
    ((token : eMessage) : errorList);
}

AddExpectedCharacter {
  errorList token : eMessage = 
    ((token : eMessage) : errorList);
}