Warning, /kdevelop/kdevelop-pg-qt/examples/fact/fact.g is written in an unsupported language. File is not indexed.

 -----------------------------------------------------------
 -- Global  declarations
 -----------------------------------------------------------
 
 
 [:
 
 #include <QString>
 
 namespace fact
 {
     class Lexer;
 }
 
 :]
 
 ------------------------------------------------------------
 -- Parser class members
 ------------------------------------------------------------
 
 %parserclass (public declaration)
 [:
   /**
    * Transform the raw input into tokens.
    * When this method returns, the parser's token stream has been filled
    * and any parse_*() method can be called.
    */
   void tokenize( const QString& contents );
 
     enum ProblemType {
         Error,
         Warning,
         Info
     };
     void reportProblem( Parser::ProblemType type, const QString& message );
 
     QString tokenText(qint64 begin, qint64 end) const;
 
     void setDebug( bool debug );
 
 :]
 
 %parserclass (private declaration)
 [:
     QString m_contents;
     bool m_debug;
 :]
 
 ------------------------------------------------------------
 -- List of defined tokens
 ------------------------------------------------------------
 
 %token FUNCTION ("function"), VAR ("var"), IF ("if"), ELSE ("else"),
        RETURN ("return") ;;
 
 %token LPAREN ("("), RPAREN (")"), LBRACE ("{"), RBRACE ("}"),
        COMMA (","), SEMICOLON (";") ;;
 
 %token ASSIGN ("="), EQUAL ("=="), STAR ("*"), MINUS ("-") ;;
 
 %token IDENTIFIER ("identifier"), NUMBER ("integer literal") ;;
 
 %token INVALID ("invalid token") ;;
 
 
 
 ------------------------------------------------------------
 -- Start of the actual grammar
 ------------------------------------------------------------
 
 -- Declaration rules
 ----------------------
 
    (#fun=functionDefinition)*
 -> program ;;
 
    FUNCTION id=IDENTIFIER
    LPAREN (#param=IDENTIFIER @ COMMA | 0) RPAREN body=body
 -> functionDefinition ;;
 
    LBRACE (#decl=declaration)* (#stmt=statement)* RBRACE
 -> body ;;
 
    VAR (var=variable @ COMMA) SEMICOLON
 -> declaration ;;
 
    id=IDENTIFIER
 -> variable ;;
 
 
 -- Statement rules
 --------------------
 
    id=IDENTIFIER ASSIGN expr=expression SEMICOLON
 -> assignmentStatement ;;
 
    IF LPAREN cond=condition RPAREN ifStmt=statement
    (ELSE elseStmt=statement | 0)
 -> ifStatement ;;
 
    LBRACE (#stmt=statement)* RBRACE
 -> blockStatement ;;
 
    RETURN expr=expression SEMICOLON
 -> returnStatement ;;
 
    assignStmt=assignmentStatement
  | ifStmt=ifStatement
  | blockStmt=blockStatement
  | returnStmt=returnStatement
 -> statement ;;
 
 
 -- Expression rules
 --------------------
 
    num=NUMBER
  | id=IDENTIFIER (LPAREN (#argument=expression @ COMMA) RPAREN | 0)
 -> primary ;;
 
    leftExpr=primary (STAR rightExpr=primary)*
 -> multExpression ;;
 
    leftExpr=multExpression (MINUS rightExpr=multExpression)*
 -> expression ;;
 
    leftExpr=expression EQUAL rightExpr=expression
 -> condition ;;
 
 
 
 
 -----------------------------------------------------------------
 -- Code segments copied to the implementation (.cpp) file.
 -- If existent, kdevelop-pg's current syntax requires this block
 -- to occur at the end of the file.
 -----------------------------------------------------------------
 
 [:
 #include "factlexer.h"
 #include <QString>
 #include <QDebug>
 
 namespace fact
 {
 
 void Parser::tokenize( const QString& contents )
 {
     m_contents = contents;
     Lexer lexer( this, contents );
 
     int kind = Parser::Token_EOF;
     do
     {
         kind = lexer.nextTokenKind();
 
         if ( !kind ) // when the lexer returns 0, the end of file is reached
             kind = Parser::Token_EOF;
 
         Parser::Token &t = tokenStream->next();
         t.kind = kind;
         if( t.kind == Parser::Token_EOF )
         {
             t.begin = -1;
             t.end = -1;
         }
         else
         {
             t.begin = lexer.tokenBegin();
             t.end = lexer.tokenEnd();
         }
 
         if( m_debug )
         {
             qDebug() << kind << "(" << t.begin << "," << t.end << ")::" << tokenText(t.begin, t.end);
         }
 
     }
     while ( kind != Parser::Token_EOF );
 
     this->yylex(); // produce the look ahead token
 }
 
 QString Parser::tokenText( qint64 begin, qint64 end ) const
 {
     return m_contents.mid((int)begin, (int)end-begin+1);
 }
 
 void Parser::reportProblem( Parser::ProblemType type, const QString& message )
 {
     if (type == Error)
         qDebug() << "** ERROR:" << message;
     else if (type == Warning)
         qDebug() << "** WARNING:" << message;
     else if (type == Info)
         qDebug() << "** Info:" << message;
 }
 
 // custom error recovery
 void Parser::expectedToken(int /*expected*/, qint64 /*where*/, const QString& name)
 {
     reportProblem(
         Parser::Error,
         QString("Expected token \"%1\"").arg(name));
 }
 
 void Parser::expectedSymbol(int /*expected_symbol*/, const QString& name)
 {
     qint64 line;
     qint64 col;
     size_t index = tokenStream->index()-1;
     Token &token = tokenStream->token(index);
     qDebug() << "token starts at:" << token.begin;
     qDebug() << "index is:" << index;
     tokenStream->startPosition(index, &line, &col);
     QString tokenValue = tokenText(token.begin, token.end);
     reportProblem(
         Parser::Error,
         QString("Expected symbol \"%1\" (current token: \"%2\" [%3] at line: %4 col: %5)")
             .arg(name)
             .arg(token.kind != 0 ? tokenValue : "EOF")
             .arg(token.kind)
             .arg(line)
             .arg(col));
 }
 
 void Parser::setDebug( bool debug )
 {
     m_debug = debug;
 }
 
 } // end of namespace fact
 
 :]
 
 -- kate: space-indent on; indent-width 4; tab-width 4; replace-tabs on