$EXTERN Lexer, Put, Arg, Open, Prout;
$ENTRY Go {
/*= <Open 'w' 2 <Arg 2>><Put 2 <Parser : <Lexer <Arg 1>>>>;*/
= <PrintTree <Semantic <Parser : <Lexer <Arg 1>>>> >;
/* = <Open 'w' 2 <Arg 2>><PrintTree <Parser : <Lexer <Arg 1>>> >;*/
}
Parser {
: eTokens =
<Program
() /* список ошибок */
() /* список функций */
: eTokens
>;
}
/*----------------------- Print Tree -----------*/
PrintTree {
errorList eFunctionList =
<PrintErrors errorList> <PrintFunctions : eFunctionList>;
}
PrintErrors {
() = <Prout 'No errors \n'>;
term :eTerms = <Prout term '\n'><PrintErrors :eTerms >;
= ;
}
PrintFunctions {
(head : eTail) : eTerms = <PrintBody head : eTail ><PrintFunctions :eTerms >;
atom :eTerms = <Prout atom '\n'><PrintFunctions :eTerms >;
= ;
}
PrintBody {
name type position eSentences =
<Prout name type position '\n'> <PrintSentences : eSentences>;
= ;
name type position NoBody =
<Prout name type position NoBody>;
= ;
}
PrintSentences {
eSentense :eTerms = <PrintPR : eSentense '\n' ><PrintSentences :eTerms >;
CALL :eTerms = <Prout '\tCALL\n'> <PrintSentences :eTerms >;
BRACKETS :eTerms = <Prout '\tBRACKETS\n'><PrintSentences :eTerms >;
atom :eTerms = <Prout '\t\t' atom '\n'><PrintSentences :eTerms >;
= ;
}
PrintPR {
pattern result : eTail =
<Prout '\t\t' pattern '\n'>
<Prout '\t\t' result '\n'>;
= ;
atom = <Prout '\t\t' atom '\n'>;
}
/*------------------------------------------------------------------------*/
/*
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 =
<Prout 'Fucking shit! This pattern workss!' ><ExternList tErrorList tFunctions : eTokens>;
tErrorList tFunctions (EOF tPos '!') =
/* Корректное завершение */
tErrorList <Reverse tFunctions>; /* REVERSE */
tErrorList tFunctions tOtherToken : eTokens =
<Program
<AddUnexpectedToken
tErrorList tOtherToken 'function definion or $EXTERN'
>
tFunctions : eTokens
>;
}
/*
ExternList = FunctionName "," ExternList | ";"
*/
ExternList {
tErrorList eFunctions (Name tPosName :eName) (Comma tPosComma ',') : eTokens =
<Prout 'And this works too'><ExternList
tErrorList
((eName tPosName Entry NoBody) : eFunctions) : eTokens
>;
tErrorList eFunctions (Name tPosName :eName)(Semicolon tPos ';') : eTokens =
<Program tErrorList ((eName tPosName Entry NoBody) : eFunctions) : eTokens>;
/*тут ещё будет обработка ошибок (нет имени, нет запятой, внезапный EOF, нет точки с запятой)*/
}
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) : eTokens >;
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 eScanned (Variable posVariable : eVariable) : eTokens =
<Prout 'Variable' eVariable><Pattern tErrorList sentences openBrackets ((Variable posVariable : eVariable) : eScanned) : eTokens>;
tErrorList sentences openBrackets eScanned (Colon posCol : eCol) : eTokens =
<Prout 'Colon' ><Pattern tErrorList sentences openBrackets ((Colon posCol : eCol) : eScanned) : eTokens>;
tErrorList sentences eOpenBrackets scanned (OpenBracket posBracket '(') : eTokens =
<Prout 'OpenBracket'><Pattern tErrorList sentences (scanned : eOpenBrackets) (BRACKETS) : eTokens >;
tErrorList sentences (eScanned : eOpenBrackets) inBrackets (CloseBracket posBracket ')') : eTokens =
<Prout 'CloseBracket'><Pattern tErrorList sentences eOpenBrackets (<ReverseCheckColon inBrackets> : eScanned) : eTokens >;
/* Если образец закончился, то есть мы встретили '=' и стек пуст: ()
значит начинаем разбирать результат */
tErrorList sentences () scanned (Assign posAssgn '=') : eTokens =
<Prout 'Assign'><Result tErrorList sentences <Reverse scanned> () () : eTokens >; /* вызываем Result и ждем пока обработается результат, чтоб все это прикрепить к предложениям */
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 openBrackets eScanned (Colon posCol : eCol) : eTokens =
<Result tErrorList sentences pattern openBrackets ((Colon posCol : eCol) : eScanned) : eTokens>;
tErrorList sentences pattern eOpenBrackets scanned (OpenBracket posBracket '(') : eTokens =
<Result tErrorList sentences pattern (scanned : eOpenBrackets) (BRACKETS) : eTokens >;
tErrorList sentences pattern (eScanned : eOpenBrackets) inBrackets (CloseBracket posBracket ')') : eTokens =
<Result tErrorList sentences pattern eOpenBrackets (<ReverseCheckColon inBrackets> : eScanned) : eTokens >;
tErrorList sentences pattern eOpenBrackets scanned (OpenCall posBracket '<') : eTokens =
<Result tErrorList sentences pattern (scanned : eOpenBrackets) (CALL ) : eTokens >;
tErrorList sentences pattern (eScanned : eOpenBrackets) inBrackets (CloseCall posBracket '>') : eTokens =
<Result tErrorList sentences pattern eOpenBrackets (<ReverseCheckColon 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
>;
}
AddUnexpectedToken {
((token : eMessage) : errorList) token : eMessage =
((token : eMessage) : errorList);
errorList token : eMessage =
((token : eMessage) : errorList);
}
AddExpectedCharacter {
errorList token : eMessage =
((token : eMessage) : errorList);
}
/*===================================== Semantic ======================================*/
Semantic {
myErorList tree =
<SemanticAnalysis myErorList tree tree>;
}
/* SemanticAnalysis(errorList 'tree to analyse' 'tree to compare') */
SemanticAnalysis {
myErorList ((functionName pos mode eFunctionBody) : eOtherFunctions) tree =
<Prout 'begin semantic ' :eFunctionBody>< SemanticAnalysis
<AnalyseFunction myErorList :eFunctionBody tree>
eOtherFunctions
tree
>;
myErorList (otherElem : eOtherFunctions) tree =
<Prout 'continue semantic'><SemanticAnalysis myErorList eOtherFunctions tree>;
myErrorList () tree =
myErrorList tree;
}
AnalyseFunction {
myErorList (pattern result) :eOtherSentences tree =
<Prout 'see pattern and result'><AnalyseFunction
<CheckVariable myErorList pattern result tree>
:eOtherSentences
tree
>;
myErorList atom :eOtherSentences tree =
<Prout 'see atom'><AnalyseFunction
myErorList
:eOtherSentences
tree
>;
myErorList tree = <Prout 'ok'>myErorList;
}
CheckVariable {
T myErrors :eOtherArgs =
<DoCheckVariable myErrors :eOtherArgs>;
myErrors :eOtherArgs =
<DoCheckVariable myErrors :eOtherArgs>;
}
/* CheckVariables(errorList pattern result tree) */
DoCheckVariable {
myErorList pattern ((Variable pos :eName) :eTali) tree =
<Prout 'Start CheckVariable'><CheckVariable
<CheckPattern myErorList pattern (Variable pos :eName) tree>
pattern
eTali
tree
>;
myErorList pattern ((BRACKETS :eBody) :eTali) tree =
<Prout 'CheckVariable see brackets'><CheckVariable
<CheckVariable myErorList pattern (BRACKETS :eBody) tree>
pattern
eTali
tree
>;
myErorList pattern ((CALL functionName :eBody) :eTali) tree =
<Prout 'CheckVariable see call'><CheckVariable
<CheckVariable
<CheckFunction myErorList functionName tree>
pattern
(CALL :eBody)
tree
>
pattern
eTali
tree
>;
myErorList pattern (otherToken :eTali) tree =
<Prout 'CheckVariable see other'><CheckVariable myErorList pattern eTali tree>;
myErorList pattern () tree =
<Prout 'stop CheckVariable'>myErorList;
}
/* CheckPattern(errorList pattern variable tree) */
CheckPattern {
T myErrorList:eOther =
T myErrorList;
myErorList ((Variable pos1 :eName) :eTali) (Variable pos2 :eName) tree
= <Prout '###' (Variable pos1 :eName) '--'(Variable pos2 :eName)'####'> T myErorList;
myErorList ((BRACKETS :eBody) :eTali) (Variable pos :eName) tree =
<Prout '************** is it posible to get in BRACKETS?? ' eBody '--' (Variable pos :eName) '\n'> <CheckPattern
<CheckPatternInside myErorList eBody (Variable pos :eName) tree>
eTali
(Variable pos :eName)
tree
>;
myErorList (otherToken :eTali) (Variable pos :eName) tree =
<CheckPattern
myErorList
eTali
(Variable pos :eName)
tree
>;
myErorList () (Variable pos :eName) tree =
<AddUnexpectedToken myErorList (Variable pos :eName) 'undeclared variable in result on pos'>;
myErorList () (Variable pos :eName) tree =
myErorList;
}
CheckPatternInside {
T myErrorList:eOther =
T myErrorList;
myErorList ((Variable pos1 :eName) :eTali) (Variable pos2 :eName) tree
= <Prout '###' (Variable pos1 :eName) '--'(Variable pos2 :eName)'####'> T myErorList;
myErorList ((BRACKETS :eBody) :eTali) (Variable pos :eName) tree =
<Prout '************** is it posible to get in BRACKETS?? ' eBody '--' (Variable pos :eName) '\n'> <CheckPattern
<CheckPatternInside myErorList eBody (Variable pos :eName) tree>
eTali
(Variable pos :eName)
tree
>;
myErorList (otherToken :eTali) (Variable pos :eName) tree =
<CheckPatternInside
myErorList
eTali
(Variable pos :eName)
tree
>;
myErorList () (Variable pos :eName) tree =
myErorList;
}
/* FunctionName (errorList (functionName) tree) */
CheckFunction {
myErorList functionName () =
<AddUnexpectedToken myErorList functionName 'undeclared function on pos'>;
myErorList (Name pos :eFname) (( eFname : eFunctionBody ) : eFunctions) =
<Prout eFname ' its found!\n'>myErorList;
myErorList functionName (term : eFunctions) =
<CheckFunction myErorList functionName eFunctions>;
}
/*======================================================================================*/