| |
| /* CPP */ |
| header "pre_include_hpp" |
| { |
| /******************************************************************************* |
| * Copyright (c) 2016 CEA LIST. |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and Implementation |
| *******************************************************************************/ |
| |
| #include <string> |
| |
| #include <common/Element.h> |
| #include <common/NamedElement.h> |
| #include <common/BF.h> |
| |
| #include <parser/model/ParserUtil.h> |
| |
| #include <fml/common/LocationElement.h> |
| |
| #include <fml/expression/AvmCode.h> |
| #include <fml/expression/BuiltinArray.h> |
| #include <fml/expression/ExpressionConstructor.h> |
| #include <fml/expression/StatementConstructor.h> |
| |
| #include <fml/operator/Operator.h> |
| #include <fml/operator/OperatorManager.h> |
| |
| #include <fml/workflow/Query.h> |
| #include <fml/workflow/UniFormIdentifier.h> |
| |
| #include <fml/workflow/WObject.h> |
| |
| } |
| |
| |
| options |
| { |
| language = "Cpp"; |
| namespace = "sep"; |
| namespaceStd = "std"; |
| namespaceAntlr = "antlr"; |
| genHashLines = false; // too many compiler warnings when generating #line statements |
| } |
| /* end CPP */ |
| |
| |
| class WorkflowParser extends Parser; |
| |
| options |
| { |
| defaultErrorHandler = true; |
| codeGenMakeSwitchThreshold = 10; |
| |
| // backtrack = true; |
| k = 4; |
| } |
| |
| |
| { |
| |
| |
| private: |
| avm_size_t noOfErrors; |
| |
| WObjectManager * mWObjectManager; |
| |
| |
| public: |
| |
| avm_size_t hasError() const |
| { |
| return( noOfErrors > 0 ); |
| } |
| |
| avm_size_t numberOfErrors() const |
| { |
| return noOfErrors; |
| } |
| |
| void resetErrors() |
| { |
| noOfErrors = 0; |
| } |
| |
| static const std::string versionInfo() |
| { |
| static std::string info = "$Id: LiaParser.g, v 0.1 2005/08/23 Lapitre $"; |
| |
| return info; |
| } |
| |
| |
| protected: |
| |
| void reportError( const std::string & errorMessage ) |
| { |
| reportMessage( errorMessage ); |
| ++noOfErrors; |
| } |
| |
| void reportError( const antlr::RecognitionException & ex ) |
| { |
| AVM_OS_CERR << std::endl << ex.toString().c_str(); |
| ++noOfErrors; |
| } |
| |
| void reportMessage( const std::string & message ) |
| { |
| if( getFilename().length() > 0 ) |
| { |
| AVM_OS_CERR << getFilename() << ":"; |
| } |
| |
| AVM_OS_CERR << LT( 1 ) -> getLine() << ":" << LT( 1 )->getColumn() |
| << " [error] " << message << std::endl; |
| } |
| |
| |
| |
| void setLocation(WObject * wfObject, int bLine, int eLine, |
| int bOffset, int eOffset) |
| { |
| wfObject->setLocation(getFilename(), bLine, eLine); |
| } |
| |
| void setLocation(TraceableElement & aTraceableElement, int bLine, int eLine, |
| int bOffset, int eOffset) |
| { |
| aTraceableElement.setLocation(getFilename(), bLine, eLine); |
| } |
| |
| void setLocation(TraceableElement * aTraceableElement, int bLine, int eLine, |
| int bOffset, int eOffset) |
| { |
| aTraceableElement->setLocation(getFilename(), bLine, eLine); |
| } |
| |
| |
| void setLocation(TraceableElement * aTraceableElement, int bLine, int eLine) |
| { |
| aTraceableElement->setLocation(getFilename(), bLine, eLine); |
| } |
| |
| |
| int getNextTokenLine() |
| { |
| return( LT(1)->getLine() ); |
| } |
| |
| int getNextTokenStartIndex() |
| { |
| return 1;//( LT(1).getLine() ); |
| } |
| |
| int getNextTokenStopIndex() |
| { |
| return 1;//( LT(1).getLine() ); |
| } |
| |
| |
| void addElement(WObject * wfContainer, WObject * wfObject) |
| { |
| if( (wfContainer != WObject::_NULL_) && (wfObject != WObject::_NULL_) ) |
| { |
| wfContainer->append( wfObject ); |
| } |
| } |
| |
| |
| } |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// UNIQ FORM IDENTIFIER |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| qualifiedNameID returns [ std::string qNameID ] |
| : ( "form" |
| ( COLON_SLASH { qNameID = std::string("form") + FQN_ID_SCHEME_PATH_SEPARATOR; } |
| | COLON2 { qNameID = std::string("form") + FQN_ID_ROOT_SEPARATOR; } |
| ) |
| | "meta" |
| ( COLON_SLASH { qNameID = std::string("meta") + FQN_ID_SCHEME_PATH_SEPARATOR; } |
| | COLON2 { qNameID = std::string("meta") + FQN_ID_ROOT_SEPARATOR; } |
| ) |
| |
| | id:Identifier |
| ( COLON_SLASH { qNameID = id->getText() + FQN_ID_SCHEME_PATH_SEPARATOR; } |
| | COLON2 { qNameID = id->getText() + FQN_ID_ROOT_SEPARATOR; } |
| ) |
| |
| | COLON_SLASH { qNameID = FQN_ID_SCHEME_PATH_SEPARATOR; } |
| | COLON2 { qNameID = FQN_ID_ROOT_SEPARATOR; } |
| )? |
| |
| id2:Identifier { qNameID = qNameID + id2->getText(); } |
| |
| ( DOT |
| ( id3:Identifier |
| | kw_public | kw_static |
| | kw_final | kw_volatile |
| | kw_reference | kw_buffered |
| ) |
| { qNameID = qNameID + "." + id3->getText(); } |
| )* |
| ; |
| |
| |
| ufiString returns [ BF bfUFI ] |
| { |
| std::string s; |
| |
| UniFormIdentifier * UFI = new UniFormIdentifier(false); |
| bfUFI = UFI; // for automatic destruction of << UFI >> if need |
| |
| BF ap; |
| |
| int bLine = getNextTokenLine(); |
| int bOffset = getNextTokenStartIndex(); |
| } |
| : ( ( "form" COLON2 { UFI->setLocator( "form" ); UFI->setAbsolute(); } ) |
| | ( "meta" COLON2 { UFI->setLocator( "meta" ); UFI->setAbsolute(); } ) |
| |
| | ( id:Identifier COLON2 |
| { UFI->setLocator( id->getText() ); UFI->setAbsolute(); } ) |
| |
| | COLON2 { UFI->setAbsolute(); } |
| )? |
| |
| id2:Identifier { UFI->appendField( id2->getText() ); } |
| |
| ( DOT |
| ( id3:Identifier { UFI->appendField( id3->getText() ); } |
| | kw_public { UFI->appendField( "public" ); } |
| | kw_static { UFI->appendField( "static" ); } |
| | kw_final { UFI->appendField( "final" ); } |
| | kw_volatile { UFI->appendField( "volatile" ); } |
| | kw_reference { UFI->appendField( "reference" ); } |
| | kw_buffered { UFI->appendField( "buffered" ); } |
| ) |
| |
| | ( LBRACK avmProgram[WObject::_NULL_] RBRACK ) |
| => LBRACK ap=avmProgram[WObject::_NULL_] RBRACK { UFI->appendIndex( ap ); } |
| )* |
| |
| { |
| if( UFI->isPureIdentifier() ) |
| { |
| bfUFI = UFI->popIdentifier(); |
| } |
| else |
| { |
| setLocation(UFI, bLine, bLine, bOffset, getNextTokenStopIndex()); |
| } |
| } |
| ; |
| |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// KEYWORD XLIA |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| |
| kw_public |
| // : { LT(1)->getText() == "public" }? Identifier |
| : "public" |
| ; |
| |
| kw_static |
| // : { LT(1)->getText() == "static" }? Identifier |
| : "static" |
| ; |
| |
| kw_final |
| // : { LT(1)->getText() == "final" }? Identifier |
| : "final" |
| ; |
| |
| kw_reference |
| // : { LT(1)->getText() == "reference" }? Identifier |
| : "reference" |
| ; |
| |
| kw_buffered |
| // : { LT(1)->getText() == "buffered" }? Identifier |
| : "buffered" |
| ; |
| |
| kw_volatile |
| // : { LT(1)->getText() == "volatile" }? Identifier |
| : "volatile" |
| ; |
| |
| |
| kw_form |
| // : { LT(1)->getText() == "form" }? Identifier |
| : "form" |
| ; |
| |
| kw_endform |
| // : { LT(1)->getText() == "endform" }? Identifier |
| : "endform" |
| ; |
| |
| kw_prototype |
| // : { LT(1)->getText() == "prototype" }? Identifier |
| : "prototype" |
| ; |
| |
| kw_endprototype |
| // : { LT(1)->getText() == "endprototype" }? Identifier |
| : "endprototype" |
| ; |
| |
| |
| kw_as |
| // : { LT(1)->getText() == "as" }? Identifier |
| : "as" |
| ; |
| |
| kw_is |
| // : { LT(1)->getText() == "is" }? Identifier |
| : "is" |
| ; |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// GRAMMAR FILE DEFINITION |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| favmProlog |
| : ( Attr_DIVERSITY | Attr_SEW | Attr_FAVM ) |
| LT_ |
| Identifier //( "workflow" | "configuration" ) |
| ( COMMA ( FloatingPointNumber | UFI | EString ) )* |
| GT_COLON |
| ; |
| |
| |
| form_grammar[ WObjectManager & aWObjectManager ] |
| returns [ WObject * wfObject = WObject::_NULL_ ] |
| { |
| mWObjectManager = &( aWObjectManager ); |
| } |
| : ( favmProlog )? |
| ( wfObject=aNormalForm[ &( mWObjectManager->ROOT_WOBJECT ) ] |
| | wfObject=aWorkflow [ &( mWObjectManager->ROOT_WOBJECT ) ] |
| ) |
| { |
| wfObject->setContainer(WObject::_NULL_); |
| |
| if( hasError() ) |
| { |
| AVM_OS_CERR << std::endl; |
| } |
| } |
| ; |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// WORKFLOW CONFIGURATION DEFINITION |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| aWorkflow [ WObject * wfContainer ] |
| returns [ WObject * wfObject = WObject::_NULL_ ] |
| { |
| wfObject = mWObjectManager->newWObject(wfContainer, "", ""); |
| |
| int bLine = getNextTokenLine(); |
| int bOffset = getNextTokenStartIndex(); |
| } |
| : aWorkflowObject[wfContainer, wfObject, bLine, bOffset] |
| ; |
| |
| |
| aWorkflowObject[ WObject * wfContainer , WObject * wfObject , int bLine , int bOffset ] |
| { |
| WObject * wobject = WObject::_NULL_; |
| |
| std::string qnid = "workflow"; |
| } |
| : qnid=qualifiedNameID { wfObject->setQualifiedTypeNameID( qnid ); } |
| |
| ( qnid=qualifiedNameID )? |
| { |
| if( NamedElement::isRelative(qnid) ) |
| { |
| mWObjectManager->registerWObject(wfObject, qnid); |
| |
| qnid = mWObjectManager->makeFQN( wfContainer, qnid ); |
| } |
| wfObject->setFullyQualifiedNameID(qnid); |
| |
| mWObjectManager->registerWObject( wfObject ); |
| } |
| |
| ( dqs:DoubleQuotedString { wfObject->setUnrestrictedName( dqs->getText() ); } |
| | sqs:SingleQuotedString { wfObject->setUnrestrictedName( sqs->getText() ); } |
| )? |
| |
| LCURLY |
| |
| ( wobject=aComponent[wfObject] { addElement(wfObject, wobject); } )* |
| |
| { setLocation(wfObject, bLine, getNextTokenLine(), bOffset, getNextTokenStopIndex()); } |
| RCURLY |
| ; |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// NORMAL FORM DEFINITION |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| formHEADER [ WObject * wfContainer, WObject * wfObject ] |
| { |
| std::string qnid = ""; |
| } |
| : qnid=qualifiedNameID |
| { |
| if( NamedElement::isRelative(qnid) ) { |
| mWObjectManager->registerWObject(wfObject, qnid); |
| |
| qnid = mWObjectManager->makeFQN( wfContainer, qnid ); |
| } |
| wfObject->setFullyQualifiedNameID(qnid); |
| |
| mWObjectManager->registerWObject( wfObject ); |
| } |
| |
| ( dqs:DoubleQuotedString { wfObject->setUnrestrictedName( dqs->getText() ); } |
| | sqs:SingleQuotedString { wfObject->setUnrestrictedName( sqs->getText() ); } |
| )? |
| |
| kw_as ( BAND )? qnid=qualifiedNameID |
| { wfObject->setQualifiedTypeNameID( qnid ); } |
| ; |
| |
| |
| formBODY[ WObject * wfContainer , WObject * wfObject] |
| { |
| WObject * wobject = WObject::_NULL_; |
| } |
| : kw_is ( wobject=aComponent[wfObject] { addElement(wfObject, wobject); } )* |
| ; |
| |
| |
| |
| formDECL [ WObject * wfContainer , WObject * wfObject] |
| : formHEADER[wfContainer, wfObject] |
| |
| { |
| AVM_IF_DEBUG_LEVEL_FLAG( HIGH , PARSING ) |
| AVM_OS_TRACE << INCR_INDENT_TAB << "parsing wfObject :> " |
| << str_header( wfObject ) << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , PARSING ) |
| } |
| |
| ( formBODY[wfContainer, wfObject] )? |
| |
| { |
| AVM_IF_DEBUG_LEVEL_FLAG( HIGH , PARSING ) |
| AVM_OS_TRACE << TAB_DECR_INDENT << "end" << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , PARSING ) |
| } |
| ; |
| |
| |
| aNormalForm[ WObject * wfContainer ] |
| returns [ WObject * wfObject = WObject::_NULL_ ] |
| { |
| wfObject = mWObjectManager->newWObject(wfContainer, "", ""); |
| |
| int bLine = getNextTokenLine(); |
| int bOffset = getNextTokenStartIndex(); |
| } |
| : aForm[wfContainer, wfObject, bLine, bOffset] |
| |
| | aPrototype[wfContainer, wfObject, bLine, bOffset] |
| |
| | aWObject[wfContainer, wfObject, bLine, bOffset] |
| ; |
| |
| |
| aWObject[ WObject * wfContainer , WObject * wfObject , int bLine , int bOffset ] |
| { |
| WObject * wobject = WObject::_NULL_; |
| |
| std::string qnid = ""; |
| } |
| : qnid=qualifiedNameID { wfObject->setQualifiedTypeNameID( qnid ); } |
| |
| ( qnid=qualifiedNameID )? |
| { |
| if( NamedElement::isRelative(qnid) ) { |
| mWObjectManager->registerWObject(wfObject, qnid); |
| |
| qnid = mWObjectManager->makeFQN( wfContainer, qnid ); |
| } |
| wfObject->setFullyQualifiedNameID(qnid); |
| |
| mWObjectManager->registerWObject( wfObject ); |
| } |
| |
| ( dqs:DoubleQuotedString { wfObject->setUnrestrictedName( dqs->getText() ); } |
| | sqs:SingleQuotedString { wfObject->setUnrestrictedName( sqs->getText() ); } |
| )? |
| |
| LCURLY |
| |
| ( wobject=aComponent[wfObject] { addElement(wfObject, wobject); } )* |
| |
| { setLocation(wfObject, bLine, getNextTokenLine(), bOffset, getNextTokenStopIndex()); } |
| RCURLY |
| ; |
| |
| |
| aForm[ WObject * wfContainer , WObject * wfObject , int bLine , int bOffset ] |
| : kw_form |
| |
| formDECL[wfContainer, wfObject] |
| |
| { setLocation(wfObject, bLine, getNextTokenLine(), bOffset, getNextTokenStopIndex()); } |
| kw_endform |
| ; |
| |
| |
| aPrototype[ WObject * wfContainer , WObject * wfObject , int bLine , int bOffset ] |
| : kw_prototype |
| |
| formDECL[wfContainer, wfObject] |
| |
| { setLocation(wfObject, bLine, getNextTokenLine(), bOffset, getNextTokenStopIndex()); } |
| kw_endprototype |
| ; |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// COMPONENT DEFINITION |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| aComponent [ WObject * wfContainer ] |
| returns [ WObject * wfObject = WObject::_NULL_ ] |
| : wfObject=aWProperty[wfContainer] |
| |
| | wfObject=aWSequence[wfContainer] |
| |
| | wfObject=aNormalForm[wfContainer] |
| |
| | wfObject=tagProgram[wfContainer] |
| ; |
| |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| ///// section <% ID %> |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| aSequenceComponent [ WObject * wfContainer ] |
| returns [ WObject * wfObject = WObject::_NULL_ ] |
| : wfObject=aWProperty[wfContainer] |
| |
| | wfObject=aNormalForm[wfContainer] |
| |
| | wfObject=tagProgram[wfContainer] |
| ; |
| |
| |
| aWSequence [ WObject * wfContainer ] returns [ WObject * section = WObject::_NULL_ ] |
| { |
| WObject * wobject = WObject::_NULL_; |
| |
| int bLine = getNextTokenLine(); |
| int bOffset = getNextTokenStartIndex(); |
| } |
| : // lvi:LeftValueIdentifier |
| lvi:Identifier |
| { |
| section = mWObjectManager->newWSequence(wfContainer, lvi->getText()); |
| AVM_IF_DEBUG_LEVEL_FLAG( HIGH , PARSING ) |
| AVM_OS_TRACE << TAB << "=>@section :> " << section->getNameID() << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , PARSING ) |
| } |
| |
| ( dqs:DoubleQuotedString { section->setUnrestrictedName( dqs->getText() ); } |
| | sqs:SingleQuotedString { section->setUnrestrictedName( sqs->getText() ); } |
| )? |
| LBRACK |
| |
| ( wobject=aSequenceComponent[section] { addElement(section, wobject); } )* |
| |
| { setLocation(section, bLine, getNextTokenLine(), bOffset, getNextTokenStopIndex()); } |
| RBRACK |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // DEPRECATED SYNTAX |
| |
| | lvic:Identifier COLON |
| { |
| section = mWObjectManager->newWSequence(wfContainer, lvic->getText()); |
| |
| AVM_IF_DEBUG_LEVEL_FLAG( HIGH , PARSING ) |
| AVM_OS_TRACE << TAB << "=>@section :> " << section->getNameID() << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , PARSING ) |
| } |
| |
| ( wobject=aSequenceComponent[section] { addElement(section, wobject); } )* |
| |
| { setLocation(section, bLine, getNextTokenLine(), bOffset, getNextTokenStopIndex()); } |
| |
| | at_lv:AtLeftValueIdentifier COLON |
| { |
| section = mWObjectManager->newWSequence(wfContainer, at_lv->getText()); |
| |
| AVM_IF_DEBUG_LEVEL_FLAG( HIGH , PARSING ) |
| AVM_OS_TRACE << TAB << "=>@section :> " << section->getNameID() << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , PARSING ) |
| } |
| |
| ( wobject=aSequenceComponent[section] { addElement(section, wobject); } )* |
| |
| { setLocation(section, bLine, getNextTokenLine(), bOffset, getNextTokenStopIndex()); } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // DEPRECATED SYNTAX |
| |
| | "section" id:Identifier |
| { |
| section = mWObjectManager->newWSequence(wfContainer, id->getText()); |
| |
| AVM_IF_DEBUG_LEVEL_FLAG( HIGH , PARSING ) |
| AVM_OS_TRACE << TAB << "=>section :> " << section->getNameID() << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , PARSING ) |
| } |
| |
| ( wobject=aComponent[section] { addElement(section, wobject); } )* |
| |
| { setLocation(section, bLine, getNextTokenLine(), bOffset, getNextTokenStopIndex()); } |
| "endsection" { LT(1)->getText() == id->getText() }? eId:Identifier |
| //{ setLocation(section, bLine, eId.getLine(), bOffset, ((Token) (eId)).getStopIndex()); } |
| ; |
| |
| |
| |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| ///// ATTRIBUT |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| aWProperty [ WObject * wfContainer ] |
| returns [ WObject * wfProperty = WObject::_NULL_ ] |
| { |
| AVM_OPCODE op; |
| |
| int bLine = getNextTokenLine(); |
| int bOffset = getNextTokenStartIndex(); |
| } |
| ///// PREDEFINED ATTRIBUT |
| : ( Attr_UFI EQ wfProperty=aWPropertyValue[wfContainer, "ufi"] |
| |
| | Attr_NAME EQ wfProperty=aWPropertyValue[wfContainer, "name"] |
| |
| | Attr_TYPE EQ wfProperty=aWPropertyValue[wfContainer, "type"] |
| |
| | Attr_DESIGN EQ wfProperty=aWPropertyValue[wfContainer, "design"] |
| |
| |
| | Attr_PUBLIC EQ wfProperty=aWPropertyValue[wfContainer, "public"] |
| |
| | Attr_STATIC EQ wfProperty=aWPropertyValue[wfContainer, "static"] |
| |
| | Attr_FINAL EQ wfProperty=aWPropertyValue[wfContainer, "final"] |
| |
| |
| | Attr_VOLATILE EQ wfProperty=aWPropertyValue[wfContainer, "volatile"] |
| |
| | Attr_REFERENCE EQ wfProperty=aWPropertyValue[wfContainer, "reference"] |
| |
| |
| | "form" op=anAssignOp wfProperty=aWPropertyValue[wfContainer, "form"] |
| { wfProperty->setSpecifierOp( op ); } |
| |
| | "meta" op=anAssignOp wfProperty=aWPropertyValue[wfContainer, "meta"] |
| { wfProperty->setSpecifierOp( op ); } |
| |
| |
| | at_lv:AtLeftValueIdentifier op=anAssignOp |
| wfProperty=aWPropertyValue[wfContainer, at_lv->getText()] |
| { wfProperty->setSpecifierOp( op ); } |
| |
| |
| | lv:Identifier op=anAssignOp |
| wfProperty=aWPropertyValue[wfContainer, lv->getText()] |
| { wfProperty->setSpecifierOp( op ); } |
| ) |
| |
| { setLocation(wfProperty, bLine, getNextTokenLine(), bOffset, getNextTokenStopIndex()); } |
| ( SEMI )? |
| ; |
| |
| |
| anAssignOp returns [ AVM_OPCODE op ] |
| : ASSIGN { op = AVM_OPCODE_ASSIGN; } |
| |
| | EQ { op = AVM_OPCODE_EQ; } |
| | EQEQ { op = AVM_OPCODE_EQ; } |
| | NEQ { op = AVM_OPCODE_NEQ; } |
| |
| | SEQ { op = AVM_OPCODE_SEQ; } |
| | NSEQ { op = AVM_OPCODE_NSEQ; } |
| |
| | BANDEQ { op = AVM_OPCODE_BAND; } |
| | BOREQ { op = AVM_OPCODE_BOR; } |
| | BXOREQ { op = AVM_OPCODE_BXOR; } |
| | BNOTEQ { op = AVM_OPCODE_BNOT; } |
| |
| | PLUSEQ { op = AVM_OPCODE_PLUS; } |
| | MINUSEQ { op = AVM_OPCODE_MINUS; } |
| | MULTEQ { op = AVM_OPCODE_MULT; } |
| | DIVEQ { op = AVM_OPCODE_DIV; } |
| | MODEQ { op = AVM_OPCODE_MOD; } |
| |
| | GT { op = AVM_OPCODE_GT; } |
| | GTE { op = AVM_OPCODE_GTE; } |
| | LT_ { op = AVM_OPCODE_LT; } |
| | LTE { op = AVM_OPCODE_LTE; } |
| ; |
| |
| |
| aWPropertyValue [ WObject * wfContainer , const std::string & aNameID ] |
| returns [ WObject * wfProperty = WObject::_NULL_ ] |
| { |
| BF value; |
| |
| BFCode prog; |
| Operator * op = NULL; |
| BF ap; |
| } |
| // : value=avmProgram[wfContainer] |
| // { wfProperty = mWObjectManager->newWProperty(wfContainer, aNameID, value); } |
| // ; |
| |
| : LPROG op=anOperator { value = prog = StatementConstructor::newCode(op); } |
| |
| ( ap=avmProgram[wfContainer] { prog->append(ap); } )* |
| |
| //{ setLocation(prog, bLine, getNextTokenLine(), bOffset, getNextTokenStopIndex()); } |
| RCURLY |
| { |
| if( prog.invalid() || (op == NULL) ) |
| { |
| //!! PARSE ERROR !! |
| } |
| else if( op->isOpCode( AVM_OPCODE_MINUS ) && (prog->size() == 1) ) |
| { |
| prog->setOperator( OperatorManager::OPERATOR_UMINUS ); |
| } |
| else if( op->isOpCode( AVM_OPCODE_IF ) && (prog->size() == 3) ) |
| { |
| prog->setOperator( OperatorManager::OPERATOR_IFE ); |
| } |
| else if( op->isOpCode( AVM_OPCODE_IFE ) && (prog->size() == 2) ) |
| { |
| prog->setOperator( OperatorManager::OPERATOR_IF ); |
| } |
| |
| wfProperty = mWObjectManager |
| ->newWPropertyExpression(wfContainer, aNameID, value); |
| } |
| |
| | LPAREN value=expression RPAREN |
| { wfProperty = mWObjectManager |
| ->newWPropertyExpression(wfContainer, aNameID, value); } |
| |
| | value=expression_invoke |
| { wfProperty = mWObjectManager |
| ->newWPropertyExpression(wfContainer, aNameID, value); } |
| |
| | "true" |
| { wfProperty = mWObjectManager |
| ->newWPropertyBoolean(wfContainer, aNameID, true); } |
| |
| | "false" |
| { wfProperty = mWObjectManager->newWPropertyBoolean( |
| wfContainer, aNameID, false); } |
| |
| | MINUS mn:IntegerNumber |
| { wfProperty = mWObjectManager |
| ->newWPropertyInteger(wfContainer, aNameID, "-" + mn->getText()); } |
| |
| | PLUS pn:IntegerNumber |
| { wfProperty = mWObjectManager |
| ->newWPropertyInteger(wfContainer, aNameID, pn->getText()); } |
| |
| | n:IntegerNumber |
| { wfProperty = mWObjectManager |
| ->newWPropertyInteger(wfContainer, aNameID, n->getText()); } |
| |
| | MINUS mf:FloatingPointNumber |
| { wfProperty = mWObjectManager |
| ->newWPropertyFloat(wfContainer, aNameID, "-" + mf->getText()); } |
| |
| | PLUS pf:FloatingPointNumber |
| { wfProperty = mWObjectManager |
| ->newWPropertyFloat(wfContainer, aNameID, pf->getText()); } |
| |
| | f:FloatingPointNumber |
| { wfProperty = mWObjectManager |
| ->newWPropertyFloat(wfContainer, aNameID, f->getText()); } |
| |
| | cl:CharacterLiteral |
| { wfProperty = mWObjectManager->newWPropertyCharacter( |
| wfContainer, aNameID, cl->getText().c_str()[0]); } |
| |
| | dqs:DoubleQuotedString |
| { wfProperty = mWObjectManager->newWPropertyDoubleQuoteString( |
| wfContainer, aNameID, dqs->getText()); } |
| |
| | sqs:SingleQuotedString |
| { wfProperty = mWObjectManager->newWPropertySingleQuoteString( |
| wfContainer, aNameID, sqs->getText()); } |
| |
| | value=ufiString |
| { wfProperty = mWObjectManager |
| ->newWPropertyParsedIdentifier(wfContainer, aNameID, value); } |
| |
| | BAND value=ufiString |
| { wfProperty = mWObjectManager |
| ->newWPropertyParsedIdentifier(wfContainer, aNameID, value); } |
| |
| | op=aSymbolOperator |
| { wfProperty = mWObjectManager |
| ->newWPropertyOperator(wfContainer, aNameID, op); } |
| |
| | value=anArrayForm[WObject::_NULL_] |
| { wfProperty = mWObjectManager |
| ->newWPropertyArray(wfContainer, aNameID, value); } |
| ; |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// GENERIC DEFINITION |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| aReference returns [ BF form ] |
| { |
| BF bfUFI; |
| } |
| : BAND bfUFI=ufiString |
| { |
| form = mWObjectManager->bfRegisteredWObject( bfUFI.str() ); |
| if( form.invalid() ) |
| { |
| form = bfUFI; |
| } |
| } |
| ; |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// TAG PROGRAM DEFINITION |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| tagProgram [ WObject * wfContainer ] returns [ WObject * attr = WObject::_NULL_ ] |
| { |
| BF ap; |
| |
| int bLine = getNextTokenLine(); |
| int bOffset = getNextTokenStartIndex(); |
| } |
| : at_lv:AtLeftValueIdentifier LCURLY ap=avmProgram[wfContainer] |
| { attr = mWObjectManager->newWProperty(wfContainer, at_lv->getText(), ap); } |
| |
| { setLocation(attr, bLine, getNextTokenLine(), bOffset, getNextTokenStopIndex()); } |
| RCURLY |
| ; |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// PROGRAM DEFINITION |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| avmProgram [ WObject * wfContainer ]returns [ BF form ] |
| { |
| BFCode prog; |
| Operator * op = NULL; |
| BF ap; |
| |
| // int bLine = getNextTokenLine(); |
| // int bOffset = getNextTokenStartIndex(); |
| } |
| : LPROG op=anOperator { form = prog = StatementConstructor::newCode(op); } |
| |
| ( ap=avmProgram[wfContainer] { prog->append(ap); } )* |
| |
| //{ setLocation(prog, bLine, getNextTokenLine(), bOffset, getNextTokenStopIndex()); } |
| RCURLY |
| { |
| if( prog.invalid() || (op == NULL) ) |
| { |
| //!! PARSE ERROR !! |
| } |
| else if( op->isOpCode( AVM_OPCODE_MINUS ) && (prog->size() == 1) ) |
| { |
| prog->setOperator( OperatorManager::OPERATOR_UMINUS ); |
| } |
| else if( op->isOpCode( AVM_OPCODE_IF ) && (prog->size() == 3) ) |
| { |
| prog->setOperator( OperatorManager::OPERATOR_IFE ); |
| } |
| else if( op->isOpCode( AVM_OPCODE_IFE ) && (prog->size() == 2) ) |
| { |
| prog->setOperator( OperatorManager::OPERATOR_IF ); |
| } |
| } |
| |
| | LPAREN form=expression RPAREN |
| |
| | form=expression_invoke |
| |
| | form=anAtom |
| ; |
| |
| |
| anOperator returns [ Operator * op ] |
| : op=aSymbolOperator |
| |
| | { (op = OperatorManager::getOp(LT(1)->getText())) != NULL }? Identifier |
| ; |
| |
| |
| aSymbolOperator returns [ Operator * op ] |
| : PLUS { op = OperatorManager::OPERATOR_PLUS; } |
| | MINUS { op = OperatorManager::OPERATOR_MINUS; } |
| | MULT { op = OperatorManager::OPERATOR_MULT; } |
| | DIV { op = OperatorManager::OPERATOR_DIV; } |
| | MOD { op = OperatorManager::OPERATOR_MOD; } |
| |
| | POW { op = OperatorManager::OPERATOR_POW; } |
| |
| | EQ { op = OperatorManager::OPERATOR_EQ; } |
| | EQEQ { op = OperatorManager::OPERATOR_EQ; } |
| | NEQ { op = OperatorManager::OPERATOR_NEQ; } |
| |
| | SEQ { op = OperatorManager::OPERATOR_SEQ; } |
| | NSEQ { op = OperatorManager::OPERATOR_NSEQ; } |
| |
| | GT { op = OperatorManager::OPERATOR_GT; } |
| | GTE { op = OperatorManager::OPERATOR_GTE; } |
| | LT_ { op = OperatorManager::OPERATOR_LT; } |
| | LTE { op = OperatorManager::OPERATOR_LTE; } |
| |
| | BNOT { op = OperatorManager::OPERATOR_BNOT; } |
| | BAND { op = OperatorManager::OPERATOR_BAND; } |
| | BOR { op = OperatorManager::OPERATOR_BOR; } |
| | BXOR { op = OperatorManager::OPERATOR_BXOR; } |
| |
| | LSHIFT { op = OperatorManager::OPERATOR_LSHIFT; } |
| | RSHIFT { op = OperatorManager::OPERATOR_RSHIFT; } |
| |
| | LNOT { op = OperatorManager::OPERATOR_NOT; } |
| | LAND { op = OperatorManager::OPERATOR_AND; } |
| | LOR { op = OperatorManager::OPERATOR_OR; } |
| |
| | ASSIGN { op = OperatorManager::OPERATOR_ASSIGN; } |
| |
| | PUSH { op = OperatorManager::OPERATOR_PUSH; } |
| | POP { op = OperatorManager::OPERATOR_POP; } |
| | TOP { op = OperatorManager::OPERATOR_TOP; } |
| | ASSIGN_TOP { op = OperatorManager::OPERATOR_ASSIGN_TOP; } |
| |
| | SEQUENCE { op = OperatorManager::OPERATOR_SEQUENCE; } |
| | SEQUENCE_SIDE { op = OperatorManager::OPERATOR_SEQUENCE_SIDE; } |
| | SEQUENCE_WEAK { op = OperatorManager::OPERATOR_SEQUENCE_WEAK; } |
| |
| | INTERLEAVING { op = OperatorManager::OPERATOR_INTERLEAVING; } |
| |
| | EXCLUSIVE { op = OperatorManager::OPERATOR_EXCLUSIVE; } |
| | NONDETERMINISM { op = OperatorManager::OPERATOR_NONDETERMINISM; } |
| |
| | PRIOR_GT { op = OperatorManager::OPERATOR_PRIOR_GT; } |
| | PRIOR_LT { op = OperatorManager::OPERATOR_PRIOR_LT; } |
| |
| | PARALLEL { op = OperatorManager::OPERATOR_PARALLEL; } |
| | PRODUCT { op = OperatorManager::OPERATOR_PRODUCT; } |
| |
| | ASYNC { op = OperatorManager::OPERATOR_ASYNCHRONOUS; } |
| | STRONG_SYNC { op = OperatorManager::OPERATOR_STRONG_SYNCHRONOUS; } |
| | WEAK_SYNC { op = OperatorManager::OPERATOR_WEAK_SYNCHRONOUS; } |
| ; |
| |
| |
| anAtom returns [ BF form ] |
| { |
| Operator * op = NULL; |
| } |
| : "true" { form = ExpressionConstructor::newBoolean(true); } |
| | "false" { form = ExpressionConstructor::newBoolean(false); } |
| |
| | MINUS mn:IntegerNumber { form = ExpressionConstructor::newInteger( "-" + mn->getText() ); } |
| | PLUS pn:IntegerNumber { form = ExpressionConstructor::newInteger( pn->getText() ); } |
| | n:IntegerNumber { form = ExpressionConstructor::newInteger( n->getText() ); } |
| |
| | MINUS mf:FloatingPointNumber { form = ExpressionConstructor::newFloat( "-" + mf->getText() ); } |
| | PLUS pf:FloatingPointNumber { form = ExpressionConstructor::newFloat( pf->getText() ); } |
| | f:FloatingPointNumber { form = ExpressionConstructor::newFloat( f->getText() ); } |
| |
| | cl:CharacterLiteral { form = ExpressionConstructor::newChar( cl->getText().c_str()[0] ); } |
| |
| | dqs:DoubleQuotedString { form = ExpressionConstructor::newString( |
| dqs->getText() , String::DOUBLE_QUOTE_DELIMITER ); } |
| |
| | sqs:SingleQuotedString { form = ExpressionConstructor::newString( |
| sqs->getText() , String::SINGLE_QUOTE_DELIMITER ); } |
| |
| | form=ufiString |
| |
| | form=aReference |
| |
| | op=aSymbolOperator { form = CONST_BF_OP( op ); } |
| |
| | form=anArrayForm[WObject::_NULL_] |
| ; |
| |
| |
| anArrayForm [WObject * wfContainer] returns [ BF form ] |
| { |
| BFVector array; |
| |
| BF ap; |
| } |
| : LBRACK |
| ( ap=avmProgram[wfContainer] { array.append(ap); } |
| ( COMMA |
| ap=avmProgram[wfContainer] { array.append(ap); } |
| )* |
| )? |
| RBRACK |
| { |
| form = BuiltinArray::create(array); |
| } |
| ; |
| |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// EXPRESSION DEFINITION |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| expression_invoke returns [ BFCode ac ] |
| { |
| BF e; |
| Operator * op = NULL; |
| } |
| : LPAREN_INVOKE |
| e=unaryExpression |
| { ac = ExpressionConstructor::newCode(OperatorManager::OPERATOR_INVOKE_METHOD, e); } |
| ( id:Identifier { ac->append(ParserUtil::getInvokable(e, id->getText())); } |
| | op=aSymbolOperator { ac->append( INCR_BF(op) ); } |
| ) |
| ( e=expression { ac->append(e); } )* |
| ( "provided:" e=expression { ac->append(e); } |
| | "from:" e=unaryExpression { ac->append(e); } |
| | "to:" e=unaryExpression { ac->append(e); } |
| | "activity:" op=anOperator { ac->append( INCR_BF(op) ); } |
| )? |
| RPAREN |
| ; |
| |
| |
| expression returns [ BF expr ] |
| : expr=conditionalExpression |
| ; |
| |
| conditionalExpression returns [ BF expr ] |
| { |
| BF arg1; |
| BF arg2; |
| } |
| : expr=conditionalOrExpression |
| ( QUESTION arg1=expression COLON arg2=expression |
| { expr = ExpressionConstructor::newCode( |
| OperatorManager::OPERATOR_IFE, expr, arg1, arg2); } |
| )? |
| ; |
| |
| conditionalOrExpression returns [ BF expr ] |
| { |
| BF arg; |
| } |
| : expr=conditionalAndExpression |
| ( LOR arg=conditionalAndExpression |
| { expr = ExpressionConstructor::newCodeFlat( |
| OperatorManager::OPERATOR_OR, expr, arg); } |
| )* |
| ; |
| |
| conditionalAndExpression returns [ BF expr ] |
| { |
| BF arg; |
| } |
| : expr=bitwiseOrExpression |
| ( LAND arg=bitwiseOrExpression |
| { expr = ExpressionConstructor::newCodeFlat( |
| OperatorManager::OPERATOR_AND, expr, arg); } |
| )* |
| ; |
| |
| bitwiseOrExpression returns [ BF expr ] |
| { |
| BF arg; |
| } |
| : expr=bitwiseXorExpression |
| ( BOR arg=bitwiseXorExpression |
| { expr = ExpressionConstructor::newCodeFlat( |
| OperatorManager::OPERATOR_BOR, expr, arg); } |
| )* |
| ; |
| |
| bitwiseXorExpression returns [ BF expr ] |
| { |
| BF arg; |
| } |
| : expr=bitwiseAndExpression |
| ( BXOR arg=bitwiseAndExpression |
| { expr = ExpressionConstructor::newCodeFlat( |
| OperatorManager::OPERATOR_BXOR, expr, arg); } |
| )* |
| ; |
| |
| bitwiseAndExpression returns [ BF expr ] |
| { |
| BF arg; |
| } |
| : expr=equalityExpression |
| ( BAND arg=equalityExpression |
| { expr = ExpressionConstructor::newCodeFlat( |
| OperatorManager::OPERATOR_BAND, expr, arg); } |
| )* |
| ; |
| |
| |
| equalityExpression returns [ BF expr ] |
| { |
| Operator * op = NULL; |
| BF arg; |
| } |
| : expr=relationalExpression |
| ( op=equalOp arg=relationalExpression |
| { expr = ExpressionConstructor::newCode(op, expr, arg); } |
| )? |
| ; |
| |
| equalOp returns [ Operator * op ] |
| : EQ { op = OperatorManager::OPERATOR_EQ; } |
| | EQEQ { op = OperatorManager::OPERATOR_EQ; } |
| | NEQ { op = OperatorManager::OPERATOR_NEQ; } |
| | SEQ { op = OperatorManager::OPERATOR_SEQ; } |
| | NSEQ { op = OperatorManager::OPERATOR_NSEQ; } |
| ; |
| |
| |
| relationalExpression returns [ BF expr ] |
| { |
| Operator * op = NULL; |
| BF arg; |
| } |
| : expr=shiftExpression |
| ( op=relationalOp arg=shiftExpression |
| { expr = ExpressionConstructor::newCode(op, expr, arg); } |
| )? |
| ; |
| |
| relationalOp returns [ Operator * op ] |
| : LTE { op = OperatorManager::OPERATOR_LTE; } |
| | GTE { op = OperatorManager::OPERATOR_GTE; } |
| | LT_ { op = OperatorManager::OPERATOR_LT; } |
| | GT { op = OperatorManager::OPERATOR_GT; } |
| ; |
| |
| |
| shiftExpression returns [ BF expr ] |
| { |
| Operator * op = NULL; |
| BF arg; |
| } |
| : expr=additiveExpression |
| ( op=shiftOp arg=additiveExpression |
| { expr = ExpressionConstructor::newCode(op, expr, arg); } |
| )* |
| ; |
| |
| shiftOp returns [ Operator * op ] |
| : LSHIFT { op = OperatorManager::OPERATOR_LSHIFT; } |
| | RSHIFT { op = OperatorManager::OPERATOR_RSHIFT; } |
| ; |
| |
| |
| additiveExpression returns [ BF expr ] |
| { |
| Operator * op = NULL; |
| BF arg; |
| } |
| : expr=multiplicativeExpression |
| ( op=additiveOp arg=multiplicativeExpression |
| { expr = ExpressionConstructor::newCode(op, expr, arg); } |
| )* |
| ; |
| |
| additiveOp returns [ Operator * op ] |
| : PLUS { op = OperatorManager::OPERATOR_PLUS; } |
| | MINUS { op = OperatorManager::OPERATOR_MINUS; } |
| ; |
| |
| |
| multiplicativeExpression returns [ BF expr ] |
| { |
| Operator * op = NULL; |
| BF arg; |
| } |
| : expr=unaryExpression |
| ( op=multiplicativeOp arg=unaryExpression |
| { expr = ExpressionConstructor::newCode(op, expr, arg); } |
| )* |
| ; |
| |
| multiplicativeOp returns [ Operator * op ] |
| : MULT { op = OperatorManager::OPERATOR_MULT; } |
| | DIV { op = OperatorManager::OPERATOR_DIV; } |
| | MOD { op = OperatorManager::OPERATOR_MOD; } |
| ; |
| |
| |
| unaryExpression returns [ BF expr ] |
| : expr=literal |
| |
| /* |
| | PLUS expr=unaryExpression |
| { expr = ExpressionConstructor::newCode(OperatorManager::OPERATOR_PLUS, expr); } |
| |
| | MINUS expr=unaryExpression |
| { expr = ExpressionConstructor::newCode(OperatorManager::OPERATOR_UMINUS, expr); } |
| |
| | INCR expr=unaryExpression |
| { expr = ExpressionConstructor::newCode(OperatorManager::OPERATOR_INCR, expr); } |
| |
| | DECR expr=unaryExpression |
| { expr = ExpressionConstructor::newCode(OperatorManager::OPERATOR_DECR, expr); } |
| */ |
| |
| | LNOT expr=unaryExpression |
| { expr = ExpressionConstructor::newCode(OperatorManager::OPERATOR_NOT, expr); } |
| |
| | BNOT expr=unaryExpression |
| { expr = ExpressionConstructor::newCode(OperatorManager::OPERATOR_BNOT, expr); } |
| |
| |
| // | primary ( INCR | DECR )? |
| |
| |
| | expr=expression_invoke |
| |
| | LPAREN expr=expression RPAREN |
| ; |
| /* |
| primary returns [ BF expr ] |
| : ID |
| ( ( DOT ID ) |
| | ( LBRACKET expression RBRACKET ) |
| | LPAREN ( expression ( COMMA expression )* )? RPAREN |
| )* |
| ; |
| */ |
| |
| literal returns [ BF expr ] |
| { |
| // Operator * op = NULL; |
| } |
| : "true" { expr = ExpressionConstructor::newBoolean(true); } |
| | "false" { expr = ExpressionConstructor::newBoolean(false); } |
| |
| | MINUS mn:IntegerNumber { expr = ExpressionConstructor::newInteger( "-" + mn->getText() ); } |
| | PLUS pn:IntegerNumber { expr = ExpressionConstructor::newInteger( pn->getText() ); } |
| | n:IntegerNumber { expr = ExpressionConstructor::newInteger( n->getText() ); } |
| |
| | MINUS mf:FloatingPointNumber { expr = ExpressionConstructor::newFloat( "-" + mf->getText() ); } |
| | PLUS pf:FloatingPointNumber { expr = ExpressionConstructor::newFloat( pf->getText() ); } |
| | f:FloatingPointNumber { expr = ExpressionConstructor::newFloat( f->getText() ); } |
| |
| | cl:CharacterLiteral { expr = ExpressionConstructor::newChar( cl->getText().c_str()[0] ); } |
| |
| | dqs:DoubleQuotedString { expr = ExpressionConstructor::newString( |
| dqs->getText() , String::DOUBLE_QUOTE_DELIMITER ); } |
| |
| | sqs:SingleQuotedString { expr = ExpressionConstructor::newString( |
| sqs->getText() , String::SINGLE_QUOTE_DELIMITER ); } |
| |
| | expr=ufiString |
| |
| | expr=aReference |
| |
| //| op=aSymbolOperator { expr = CONST_BF_OP( op ); } |
| |
| | expr=anArrayForm[WObject::_NULL_] |
| ; |
| |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| |
| class WorkflowLexer extends Lexer; |
| |
| options |
| { |
| charVocabulary = '\0'..'\377'; |
| k = 6; // four characters of lookahead |
| |
| testLiterals = false; // don't automatically test for literals |
| |
| caseSensitive = true; |
| caseSensitiveLiterals = true; |
| } |
| |
| /* CPP */ |
| { |
| |
| private: |
| |
| avm_size_t noOfErrors; |
| |
| |
| public: |
| |
| avm_size_t hasError() const |
| { |
| return( noOfErrors > 0 ); |
| } |
| |
| avm_size_t numberOfErrors() const |
| { |
| return noOfErrors; |
| } |
| |
| void resetErrors() |
| { |
| noOfErrors = 0; |
| } |
| |
| static const std::string versionInfo() |
| { |
| static std::string info = "$Id: LiaLexer.g, v 0.1 2005/10/20 Lapitre $"; |
| |
| return info; |
| } |
| |
| |
| protected: |
| |
| void reportError( const std::string & errorMessage ) |
| { |
| reportMessage( errorMessage ); |
| ++noOfErrors; |
| } |
| |
| void reportMessage( const std::string & message ) const |
| { |
| if ( getFilename().length() > 0 ) |
| { |
| AVM_OS_CERR << getFilename() << ":"; |
| } |
| |
| AVM_OS_CERR << getLine() << ":" << getColumn() |
| << " [error] " << message << std::endl; |
| } |
| |
| } |
| /* end CPP */ |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// OPERATORS SYMBOLS LITERAL |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| AT : '@' ; |
| |
| PLUS : '+' ; |
| MINUS : '-' ; |
| MOD : '%' ; |
| MULT : '*' ; |
| DIV : '/' ; |
| |
| POW : '^' | "**" ; |
| |
| ASSIGN : ":=" ; |
| |
| PUSH : "<=<" ; |
| ASSIGN_TOP : "^=<" ; |
| TOP : "^=>" ; |
| POP : ">=>" ; |
| |
| EQ : '=' ; |
| |
| BANDEQ : "&=" ; |
| BOREQ : "|=" ; |
| BXOREQ : "^=" ; |
| BNOTEQ : "~=" ; |
| |
| PLUSEQ : "+=" ; |
| MINUSEQ : "-=" ; |
| MULTEQ : "*=" ; |
| DIVEQ : "/=" ; |
| MODEQ : "%=" ; |
| |
| EQEQ : "==" ; |
| NEQ : "!=" ; |
| SEQ : "===" ; |
| NSEQ : "=/=" ; |
| |
| GT : '>' ; |
| GTE : ">=" ; |
| LT_ : '<' ; |
| LTE : "<=" ; |
| |
| BAND : '&' ; |
| BOR : '|' ; |
| BXOR : '^' ; |
| BNOT : '~' ; |
| |
| LSHIFT : "<<" ; |
| RSHIFT : ">>" ; |
| |
| |
| LAND : "&&" ; |
| LOR : "||" ; |
| LNOT : '!' ; |
| |
| LPAREN : '(' ; |
| RPAREN : ')' ; |
| |
| LPAREN_INVOKE : "(:" ; |
| |
| LBRACK : '[' ; |
| RBRACK : ']' ; |
| |
| |
| LCURLY : '{' ; |
| RCURLY : '}' ; |
| |
| LPROG : "${" ; |
| |
| LGENERIC : "<%" ; |
| RGENERIC : "%>" ; |
| |
| COMMA : ',' ; |
| SEMI : ';' ; |
| COLON : ':' ; |
| COLON2 : "::" ; |
| COLON_SLASH : ":/" ; |
| DOT : '.' ; |
| QUESTION : '?' ; |
| |
| GT_COLON : ">:" ; |
| |
| ARROW : "->" ; |
| |
| |
| INTERLEAVING : "|i|" ; |
| |
| ASYNC : "|a|" ; |
| STRONG_SYNC : "|and|" ; |
| WEAK_SYNC : "|or|" ; |
| PARALLEL : "|,|" ; |
| PRODUCT : "|x|" ; |
| |
| EXCLUSIVE : "|xor|" ; |
| NONDETERMINISM : "|/\\|" ; |
| |
| PRIOR_GT : "|>|" ; |
| PRIOR_LT : "|<|" ; |
| |
| SEQUENCE : "|;|" ; |
| SEQUENCE_SIDE : "|/;|" ; |
| SEQUENCE_WEAK : "|;;|" ; |
| |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// ATTRIBUTE LVALUE |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| Attr_PUBLIC |
| : "@public" |
| ; |
| |
| Attr_STATIC |
| : "@static" |
| ; |
| |
| Attr_FINAL |
| : "@final" |
| ; |
| |
| Attr_VOLATILE |
| : "@volatile" |
| ; |
| |
| Attr_REFERENCE |
| : "@reference" |
| ; |
| |
| Attr_UFI |
| : "@ufi" |
| ; |
| |
| Attr_NAME |
| : "@name" |
| ; |
| |
| Attr_TYPE |
| : "@type" |
| ; |
| |
| Attr_DESIGN |
| : "@design" |
| ; |
| |
| Attr_DIVERSITY |
| : "@diversity" |
| ; |
| |
| Attr_FAVM |
| : "@favm" |
| ; |
| |
| Attr_SEW |
| : "@sew" |
| ; |
| |
| |
| |
| |
| AtLeftValueIdentifier |
| : AT ! LeftValueIdentifier |
| ; |
| |
| protected |
| LeftValueIdentifier |
| : ( ~( ':' | '=' | '{' | '[' | ' ' | '\t' | '\f' | '\n' |'\r' ) )+ |
| ; |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// NUMERIC LITERAL |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| |
| // Numeric Constants: |
| |
| protected |
| LongSuffix |
| : 'l' |
| | 'L' |
| ; |
| |
| protected |
| UnsignedSuffix |
| : 'u' |
| | 'U' |
| ; |
| |
| protected |
| FloatSuffix |
| : 'f' |
| | 'F' |
| | 'd' |
| | 'D' |
| ; |
| |
| protected |
| Exponent |
| : |
| ('e'|'E') ('+'|'-')? (Digit)+ |
| ; |
| |
| Number |
| : ( (Digit)+ ('.' | 'e' | 'E') )=> |
| (Digit)+ |
| ( '.' (Digit)* (Exponent)? |
| | Exponent |
| ) |
| (FloatSuffix |
| |LongSuffix |
| )? {_ttype = FloatingPointNumber;} |
| |
| | '.' |
| ( (Digit)+ (Exponent)? |
| (FloatSuffix |
| |LongSuffix |
| )? |
| ) {_ttype = FloatingPointNumber;} |
| |
| | (Digit)+ |
| (LongSuffix |
| |UnsignedSuffix |
| )* {_ttype = IntegerNumber;} |
| ; |
| |
| |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// CHAR STRING LITERAL |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| |
| CharacterLiteral |
| : '\''! CHAR '\''! |
| ; |
| |
| protected |
| CHAR |
| : ( EscapeSequence | ~('\''|'\\') ) |
| ; |
| |
| |
| DoubleQuotedString |
| : '"'! DQS '"'! |
| ; |
| |
| protected |
| DQS |
| : ( EscapeSequence | ~( '\\' | '"' ) )* |
| ; |
| |
| |
| SingleQuotedString |
| : '\''! SQS '\''! |
| ; |
| |
| protected |
| SQS |
| : ( EscapeSequence | ~( '\\' | '\'' ) ) ( EscapeSequence | ~( '\\' | '\'' ) )+ |
| ; |
| |
| |
| protected |
| EscapeSequence |
| : '\\' ('b'|'t'|'n'|'f'|'r'|'\"'|'\''|'\\') |
| | UnicodeEscape |
| | OctalEscape |
| ; |
| |
| protected |
| OctalEscape |
| : '\\' ('0'..'3') ('0'..'7') ('0'..'7') |
| | '\\' ('0'..'7') ('0'..'7') |
| | '\\' ('0'..'7') |
| ; |
| |
| protected |
| UnicodeEscape |
| : '\\' 'u' HexDigit HexDigit HexDigit HexDigit |
| ; |
| |
| protected |
| HexDigit |
| : ( Digit | 'a'..'f' | 'A'..'F' ) |
| ; |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// IDENTIFIER |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| /* |
| UFI |
| : Identifier ( '.' Identifier )+ |
| ; |
| UfiLocator |
| : Letter ( Letter | Digit )* ( '#' ( Digit )+ )? (COLON_SLASH|COLON2)! |
| ; |
| |
| */ |
| |
| |
| Identifier |
| options { testLiterals=true; } |
| : Letter ( Letter | Digit | '#' | '/' )* |
| ; |
| |
| /**I found this char range in JavaCC's grammar, but Letter and Digit overlap. |
| Still works, but... |
| */ |
| protected |
| Letter |
| : 'A'..'Z' |
| | 'a'..'z' |
| |
| | '$' |
| | '_' |
| ; |
| |
| protected |
| Digit |
| : '0'..'9' |
| ; |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// COMMENT RULE |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| // Single-line comments |
| SL_COMMENT |
| : "//" (~('\n'|'\r'))* ('\n'|'\r'('\n')?)? |
| { |
| $setType(antlr::Token::SKIP); |
| newline(); |
| } |
| ; |
| |
| // Multi-line comments |
| COMMENT_MULTI_LINE |
| : "/*" |
| ( options { generateAmbigWarnings=false; } |
| : { LA(2) != '/' }? '*' |
| | '\r' '\n' { newline(); } |
| | '\r' { newline(); } |
| | '\n' { newline(); } |
| | ~('*' | '\n' | '\r') |
| )* |
| "*/" |
| { |
| $setType(antlr::Token::SKIP); |
| } |
| ; |
| |
| COMMENT_MULTI_LINE_2 |
| : "(*" |
| ( options { generateAmbigWarnings=false; } |
| : { LA(2) != ')' }? '*' |
| | '\r' '\n' { newline(); } |
| | '\r' { newline(); } |
| | '\n' { newline(); } |
| | ~('*' | '\n' | '\r') |
| )* |
| "*)" |
| { |
| $setType(antlr::Token::SKIP); |
| } |
| ; |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| ///// WHITESPACE IGNORED |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| WHITESPACE |
| : ( ' ' | '\t' | '\f' | |
| // handle newlines |
| ( |
| "\r\n" // Evil DOS |
| | '\r' // Macintosh |
| | '\n' // Unix (the right way) |
| ) |
| { newline(); } |
| ) |
| { |
| $setType(antlr::Token::SKIP); |
| } |
| ; |
| |
| |