BNF Grammar: Difference between revisions
Line 4,749: | Line 4,749: | ||
=={{header|Dc}}== |
=={{header|Dc}}== |
||
=={{header|Delphi}}== |
=={{header|Delphi}}== |
||
<pre> |
|||
! ----------------------------------------------------------------------- |
|||
! Delphi 7.0 Object Pascal Grammar |
|||
! ----------------------------------------------------------------------- |
|||
! (c) Rob F.M. van den Brink - the Netherlands, 2006 - R.F.M.vandenBrink@hccnet.nl |
|||
! Version V1.1, Aug 2006 |
|||
! |
|||
! This grammar parses almost everything of the language, except for a few issues |
|||
! that are probably beyond the capabilities of Gold parser. |
|||
! Known limitations: |
|||
! (1) Cannot handle comment directives like {$ifdef Windows} ... {$endif} |
|||
! When parts of the source code is uncommented in this way, the grammer will |
|||
! still read it, and may fail. |
|||
! (2) The parser consumes all assembler statements, but is too tolerant in accepting |
|||
! input. Groups of several <AsmItem> does not belong to a single <AsmInstruction> |
|||
! because a 'newline' is regarded as whitespace while it should be a terminator here. |
|||
! (3) Lexemes like 'protected' , 'forward' can be both a keyword as well as an identifier |
|||
! in Delphi (even in the same object declaration), and when these lexemes should mean |
|||
! an identifier, the current grammar cannot handle it correctly. |
|||
! For several of them a workaround was created, but a better solution should be |
|||
! developped. |
|||
! (4) Strings with characters above #127 cannot be handled by the current Grammar. |
|||
! This should be very simple, but if the grammar defines string characters |
|||
! as the range {#32 .. #255}, Goldparser also adds {#376} and {#956}. |
|||
! This looks like a bug in Gold Parser. |
|||
! (5) The inclusion of an adequate number of error productions (SynError) is still |
|||
! to be done. |
|||
! (6) constructs that are considered (for the timebeing) as too weird, are not |
|||
! supported; see below. |
|||
! ----------------------------------------------------------------------- |
|||
! This grammar supports also most of 'weird' constructs that Borland has added |
|||
! to Delphi. This refers to the inconsistent syntax for several directives |
|||
! like in <CallConvention> and <MethodDirective>. Sometimes these directives have |
|||
! to be separated by an ';' sometimes not and somtimes both is alowed. |
|||
! An example of a syntax that was considered as too weird to be covered by this |
|||
! grammar was found in library routine "IdSSLOpenSSLHeaders.pas" (comes with Delphi) |
|||
! VAR |
|||
! IdSslCtxSetVerifyDepth : procedure(ctx: PSSL_CTX; depth: Integer); cdecl = nil; |
|||
! IdSslCtxGetVerifyDepth : function (ctx: PSSL_CTX):Integer; cdecl = nil; |
|||
! In a consistent syntax, cdecl should refer to some variable that is set to "nil', but |
|||
! the ';' does not close the <TypeSpec> and the rest is still part of the syntax |
|||
! |
|||
! ----------------------------------------------------------------------- |
|||
! Version history |
|||
! V1.0 - June 2006, derived from scratch, using Delphi 7.0 help and code files |
|||
! V1.1 - Aug 2006, lots of refinements to cover almost evberything of the language |
|||
! Consumes assembler code as well. |
|||
! ----------------------------------------------------------------------- |
|||
"Name" = 'ObjectPascal' |
|||
"Version" = '1.1, Aug 2006' |
|||
"Author" = 'Rob F.M. van den Brink' |
|||
"About" = 'Derived from scratch, from Delphi 7.0 help and experiments with code files' |
|||
"Start Symbol" = <ObjectPascal> |
|||
!------------------------------------------------------------------------------ |
|||
"Case Sensitive" = False |
|||
"Virtual Terminals" = SynError CommentStart2 CommentEnd2 |
|||
Comment Line = '//' |
|||
Comment Start = '{' |
|||
Comment End = '}' |
|||
CommentStart1 = '(*' |
|||
CommentEnd1 = '*)' |
|||
{Hex Digit} = {Digit} + [abcdefABCDEF] |
|||
{Id Head} = {Letter} + [_] |
|||
{Id Tail} = {Id Head} + {Digit} |
|||
!{String Ch} = {#32 .. #255} - [''] + {HT} !WHY DOES GOLS ADD character #376 and #956 ?? |
|||
{String Ch} = {printable} - [''] + {HT} |
|||
DecLiteral = {digit}+ |
|||
HexLiteral = '$'{Hex Digit}+ |
|||
FloatLiteral = {Digit}+.{Digit}+ |
|||
RealLiteral = {Digit}+ ('.' {Digit}* | {Digit}*) ('E' '+' | 'E' '-' | 'E') {digit}+ |
|||
StringLiteral = ( '' {String Ch}* '' | '#' {digit}+ | '#' '$' {hex digit}+ | '''' )+ |
|||
!StringLiteral = ( ( '' {String Ch}* '' ) |
|||
! | ( '#' {digit}+ ) |
|||
! | ( '#' '$' {hex digit}+ ) |
|||
! | ( '''' ) |
|||
! )+ |
|||
id = {Id Head}{Id Tail}* |
|||
<LCONST> ::= DecLiteral |
|||
<ICONST> ::= DecLiteral |
|||
| HexLiteral |
|||
<RCONST> ::= FloatLiteral |
|||
| RealLiteral |
|||
<SCONST> ::= StringLiteral |
|||
| '^' id ! handles characters like ^H and ^V |
|||
!------------------------------------------------------------------------------ |
|||
!<UnitId> ::= id |
|||
<IdList> ::= <IdList> ',' <RefId> |
|||
| <RefId> |
|||
<LabelId> ::= id |
|||
<TypeId> ::= id |
|||
! | id '.' <RefId> |
|||
| NAME |
|||
<TypeName> ::= <TypeId> |
|||
| id '.' <RefId> !!accepts UnitId.Id as well |
|||
<TypeList> ::= <TypeName> |
|||
| <TypeList> ',' <TypeName> |
|||
<RefId> ::= id |
|||
| AT | ON | READ | WRITE | READLN | WRITELN | NAME | INDEX |
|||
| VIRTUAL | ABSOLUTE | MESSAGE | DEFAULT | OVERRIDE | ABSTRACT |
|||
| DISPID | REINTRODUCE |
|||
| REGISTER | PASCAL | CDECL | STDCALL | SAFECALL |
|||
| STRING | WIDESTRING | ANSISTRING |
|||
| VARIANT | OLEVARIANT |
|||
| READONLY | IMPLEMENTS | NODEFAULT | STORED |
|||
| OVERLOAD | LOCAL | VARARGS |
|||
| FORWARD |
|||
| CONTAINS | PACKAGE | REQUIRES | LIBRARY |
|||
| IMPORT | EXPORT |
|||
| PLATFORM | DEPRECATED |
|||
| EXTERNAL |
|||
! PROTECTED | PUBLISHED | PRIVATE | PUBLIC !THIS FAILS IN FIELDS |
|||
<FieldDesignator> ::= <RefId> |
|||
| <FieldDesignator> '.' <RefId> |
|||
!* predefined identifiers are no part of a syntax |
|||
<RealTypeId> ::= REAL48 |
|||
| REAL |
|||
| SINGLE |
|||
| DOUBLE |
|||
| EXTENDED |
|||
| CURRENCY |
|||
| COMP |
|||
<OrdTypeId> ::= SHORTINT |
|||
| SMALLINT |
|||
| INTEGER |
|||
| BYTE |
|||
| LONGINT |
|||
| INT64 |
|||
| WORD |
|||
| BOOLEAN |
|||
| CHAR |
|||
| WIDECHAR |
|||
| LONGWORD |
|||
| PCHAR |
|||
*! |
|||
!------------------------------------------------------------------------------ |
|||
! M O D U L E S |
|||
!------------------------------------------------------------------------------ |
|||
<ObjectPascal> ::= <Program> | <Unit> | <Package> | <Library> |
|||
<Program> ::= <ProgHeader> <OptUsesSection> <Block> '.' |
|||
<ProgHeader> ::= PROGRAM <RefId> <OptProgParamList> ';' |
|||
<OptProgParamList> ::= '(' <IdList> ')' |
|||
| |
|||
<Unit> ::= <UnitHeader> <InterfaceSection> <ImplementationSection> <InitSection> '.' |
|||
<UnitHeader> ::= UNIT <RefId> <OptPortDirectives> ';' |
|||
<Package> ::= <PackageHeader> <OptRequiresClause> <OptContainsClause> END '.' |
|||
<PackageHeader> ::= PACKAGE <RefId> ';' |
|||
<OptRequiresClause> ::= REQUIRES <IdList> ';' |
|||
| |
|||
<OptContainsClause> ::= CONTAINS <IdList> ';' |
|||
| |
|||
<LibraryHeader> ::= LIBRARY <RefId> ';' |
|||
<Library> ::= <LibraryHeader> <OptUsesSection> <Block> '.' |
|||
<InterfaceSection> ::= INTERFACE <OptUsesSection> <OptExportDeclList> |
|||
<OptUsesSection> ::= <UsesSection> |
|||
| |
|||
<UsesClause> ::= USES <IdList> ';' |
|||
| SynError |
|||
<UsesSection> ::= <UsesClause> |
|||
| <UsesSection> <UsesClause> |
|||
<OptExportDeclList> ::= <ExportDeclList> |
|||
| |
|||
<ExportDeclList> ::= <ExportDeclItem> |
|||
| <ExportDeclList> <ExportDeclItem> |
|||
<ExportDeclItem> ::= <ConstSection> |
|||
| <TypeSection> |
|||
| <VarSection> |
|||
| <CallSection> |
|||
| <CallSection> FORWARD ';' |
|||
! The forward directive has no effect in the interface section of a unit, |
|||
! but is not forbidden here. |
|||
<CallSection> ::= <ProcHeading> |
|||
| <FuncHeading> |
|||
<ImplementationSection> ::= IMPLEMENTATION <OptUsesSection> <OptDeclSection> <OptExportBlock> |
|||
<InitSection> ::= INITIALIZATION <StmtList> END |
|||
| INITIALIZATION <StmtList> FINALIZATION <StmtList> END |
|||
| <CompoundStmt> |
|||
| END |
|||
<Block> ::= <OptDeclSection> <OptExportBlock> <CompoundStmt> <OptExportBlock> |
|||
<OptExportBlock> ::= <ExportStmt> |
|||
| <OptExportBlock> <ExportStmt> |
|||
| |
|||
<ExportStmt> ::= EXPORTS <ExportList> ';' |
|||
<ExportList> ::= <ExportItem> |
|||
| <ExportList> ',' <ExportItem> |
|||
<ExportItem> ::= id |
|||
| id NAME '' <ConstExpr> '' |
|||
| Id INDEX '' <ConstExpr> '' |
|||
| NAME '' <ConstExpr> '' |
|||
| INDEX '' <ConstExpr> '' |
|||
!------------------------------------------------------------------------------ |
|||
! D E C L A R A T I O N S |
|||
!------------------------------------------------------------------------------ |
|||
<OptDeclSection> ::= <DeclSection> |
|||
| |
|||
<DeclSection> ::= <DeclItem> |
|||
| <DeclSection> <DeclItem> |
|||
<DeclItem> ::= <LabelSection> |
|||
| <ConstSection> |
|||
| <TypeSection> |
|||
| <VarSection> |
|||
| <ProcedureDeclSection> |
|||
| SynError |
|||
<LabelSection> ::= LABEL <LabelList> ';' |
|||
<LabelList> ::= <LabelId> |
|||
| <LabelList> ',' <LabelId> |
|||
!-----CONSTS------------------------------------------------------------------- |
|||
<ConstSection> ::= CONST <ConstantDeclList> |
|||
| RESOURCESTRING <ConstantDeclList> !all these constants should be string |
|||
<ConstantDeclList> ::= <ConstantDecl> |
|||
| <ConstantDeclList> <ConstantDecl> |
|||
<ConstantDecl> ::= <RefId> '=' <ConstExpr> <OptPortDirectives> ';' |
|||
| <RefId> ':' <Type> '=' <TypedConstant> <OptPortDirectives> ';' |
|||
| SynError ';' |
|||
<TypedConstant> ::= <ConstExpr> |
|||
| <ArrayConstant> |
|||
| <RecordConstant> |
|||
<ArrayConstant> ::= '(' <TypedConstList> ')' |
|||
<RecordConstant> ::= '(' <RecordFieldConstList> ')' |
|||
| '(' <RecordFieldConstList> ';' ')' |
|||
| '(' ')' !only to initialize globar vars" |
|||
<RecordFieldConstList> ::= <RecordFieldConstant> |
|||
| <RecordFieldConstList> ';' <RecordFieldConstant> |
|||
<RecordFieldConstant> ::= <RefId> ':' <TypedConstant> |
|||
<TypedConstList> ::= <TypedConstant> |
|||
| <TypedConstList> ',' <TypedConstant> |
|||
!-----TYPES-------------------------------------------------------------------- |
|||
<TypeSection> ::= TYPE <TypeDeclList> |
|||
<TypeDeclList> ::= <TypeDecl> |
|||
| <TypeDeclList> <TypeDecl> |
|||
<TypeDecl> ::= <TypeId> '=' <TypeSpec> |
|||
| SynError ';' |
|||
<TypeSpec> ::= <GenericType> ';' |
|||
| <RestrictedType> <OptPortDirectives> ';' |
|||
| <CallType> ';' |
|||
| <CallType> ';' <CallConventions> ';' |
|||
| SynError ';' |
|||
<Type> ::= <GenericType> |
|||
| <CallType> |
|||
<TypeRef> ::= <TypeName> |
|||
| <StringType> |
|||
| <VariantType> |
|||
<GenericType> ::= <TypeName> |
|||
| <StringType> |
|||
| <VariantType> |
|||
| <SubrangeType> |
|||
| <EnumType> |
|||
| <StructType> |
|||
| <PointerType> |
|||
| <ClassRefType> |
|||
| <ClonedType> |
|||
<ClonedType> ::= TYPE <TypeRef> |
|||
<StringType> ::= STRING |
|||
| ANSISTRING |
|||
| WIDESTRING |
|||
| STRING '[' <ConstExpr> ']' |
|||
<VariantType> ::= VARIANT |
|||
| OLEVARIANT |
|||
<OrdinalType> ::= <SubrangeType> | <EnumType> | <TypeName> |
|||
<SubrangeType> ::= <ConstOrdExpr> '..' <ConstOrdExpr> |
|||
| <ConstOrdExpr> SynError |
|||
| '(' <RefId> ')' '..' <ConstOrdExpr> |
|||
<EnumType> ::= '(' <EnumList> ')' |
|||
| '(' <RefId> ')' |
|||
<EnumList> ::= <EnumId> |
|||
| <EnumList> ',' <EnumId> |
|||
<EnumId> ::= <RefId> |
|||
| <RefId> '=' <ConstExpr> |
|||
<OptPacked> ::= PACKED |
|||
| |
|||
<StructType> ::= <ArrayType> |
|||
| <SetType> |
|||
| <FileType> |
|||
| <RecType> |
|||
<ArrayType> ::= <OptPacked> ARRAY '[' <OrdinalTypeList> ']' OF <Type> |
|||
| <OptPacked> ARRAY OF CONST |
|||
| <OptPacked> ARRAY OF <Type> !dynamic array, starting from 0 |
|||
! FCells: array of array of TIWGridCell; |
|||
<OrdinalTypeList> ::= <OrdinalType> |
|||
| <OrdinalTypeList> ',' <OrdinalType> |
|||
<RecType> ::= <OptPacked> RECORD <RecFieldList> END <OptPortDirectives> |
|||
<RecFieldList> ::= |
|||
| <RecField1> |
|||
| <RecField2> |
|||
| <RecField1> ';' <RecFieldList> |
|||
| <RecField2> ';' <RecFieldList> |
|||
| <RecField2> ';' <CallConvention> |
|||
| <RecField2> ';' <CallConvention> ';' <RecFieldList> |
|||
| CASE <Selector> OF <RecVariantList> |
|||
<RecVariantList> ::= |
|||
| <RecVariant> |
|||
| <RecVariant> ';' <RecVariantList> |
|||
<RecField1> ::= <IdList> ':' <GenericType> <OptPortDirectives> |
|||
<RecField2> ::= <IdList> ':' <CallType> |
|||
<RecVariant> ::= <ConstExprList> ':' '(' <RecFieldList> ')' |
|||
<Selector> ::= <RefId> ':' <TypeName> |
|||
| <TypeName> |
|||
<SetType> ::= <OptPacked> SET OF <OrdinalType> |
|||
<FileType> ::= <OptPacked> FILE OF <TypeRef> |
|||
| FILE |
|||
<PointerType> ::= '^' <TypeRef> |
|||
<CallType> ::= PROCEDURE <OptFormalParms> <OptCallConventions> |
|||
| PROCEDURE <OptFormalParms> OF OBJECT <OptCallConventions> |
|||
| FUNCTION <OptFormalParms> ':' <ResultType> <OptCallConventions> |
|||
| FUNCTION <OptFormalParms> ':' <ResultType> OF OBJECT <OptCallConventions> |
|||
!-----CLASSES AND OBJECTS------------------------------------------------------ |
|||
<RestrictedType> ::= <ObjectType> |
|||
| <ClassType> |
|||
| <InterfaceType> |
|||
<ObjectType> ::= <OptPacked> OBJECT <OptObjectHeritage> <ObjectMemberList> END |
|||
<ClassType> ::= CLASS <OptClassHeritage> <ClassMemberList> END |
|||
| CLASS <OptClassHeritage> |
|||
<ClassRefType> ::= CLASS OF <TypeName> |
|||
<InterfaceType> ::= INTERFACE <OptClassHeritage> <OptClassGUID> <OptClassMethodList> END |
|||
| DISPINTERFACE <OptClassHeritage> <OptClassGUID> <OptClassMethodList> END |
|||
| INTERFACE |
|||
| DISPINTERFACE |
|||
<OptObjectHeritage> ::= '(' <TypeName> ')' |
|||
| |
|||
<OptClassHeritage> ::='(' <TypeList> ')' |
|||
| |
|||
<OptClassGUID> ::= '[' <ConstStrExpr> ']' ! <SCONST> globally unique identifier |
|||
| |
|||
<ObjectMemberList> ::= <OptFieldList> <OptObjectMethodList> |
|||
| <ObjectMemberList> PUBLIC <OptFieldList> <OptObjectMethodList> |
|||
| <ObjectMemberList> PRIVATE <OptFieldList> <OptObjectMethodList> |
|||
| <ObjectMemberList> PROTECTED <OptFieldList> <OptObjectMethodList> |
|||
<ClassMemberList> ::= <OptFieldList> <OptClassMethodList> |
|||
| <ClassMemberList> PUBLIC <OptFieldList> <OptClassMethodList> |
|||
| <ClassMemberList> PRIVATE <OptFieldList> <OptClassMethodList> |
|||
| <ClassMemberList> PROTECTED <OptFieldList> <OptClassMethodList> |
|||
| <ClassMemberList> PUBLISHED <OptFieldList> <OptClassMethodList> |
|||
<OptFieldList> ::= <FieldList> |
|||
| |
|||
<OptObjectMethodList> ::= <ObjectMethodList> |
|||
| |
|||
<OptClassMethodList> ::= <ClassMethodList> |
|||
| |
|||
<FieldList> ::= <FieldSpec> |
|||
| <FieldList> <FieldSpec> |
|||
<ObjectMethodList> ::= <ObjectMethodSpec> |
|||
| <ObjectMethodList> <ObjectMethodSpec> |
|||
<ClassMethodList> ::= <ClassMethodSpec> |
|||
| <ClassMethodList> <ClassMethodSpec> |
|||
<FieldSpec> ::= <IdList> ':' <Type> <OptPortDirectives> ';' |
|||
| SynError ';' |
|||
<ObjectMethodSpec> ::= <MethodSpec> <OptMethodDirectives> |
|||
| <PropertySpec> <OptPropertyDirectives> |
|||
| SynError |
|||
<ClassMethodSpec> ::= <MethodSpec> <OptMethodDirectives> |
|||
| <ResolutionSpec> <OptMethodDirectives> |
|||
| CLASS <ProcSpec> <OptMethodDirectives> |
|||
| CLASS <FuncSpec> <OptMethodDirectives> |
|||
| <PropertySpec> <OptPropertyDirectives> |
|||
| SynError |
|||
<MethodSpec> ::= <ConstructorSpec> |
|||
| <DestructorSpec> |
|||
| <ProcSpec> |
|||
| <FuncSpec> |
|||
<ConstructorSpec> ::= CONSTRUCTOR <RefId> <OptFormalParms> ';' |
|||
<DestructorSpec> ::= DESTRUCTOR <RefId> <OptFormalParms> ';' |
|||
<ProcSpec> ::= PROCEDURE <RefId> <OptFormalParms> <OptCallConventions> ';' |
|||
<FuncSpec> ::= FUNCTION <RefId> <OptFormalParms> ':' <ResultType> <OptCallConventions> ';' |
|||
<ResolutionSpec> ::= PROCEDURE <RefId> '.' <RefId> '=' <RefId> ';' |
|||
| FUNCTION <RefId> '.' <RefId> '=' <RefId> ';' |
|||
<PropertySpec> ::= PROPERTY <PropertyDecl> <OptPropSpecifiers> ';' |
|||
<PropertyDecl> ::= <RefId> ':' <TypeRef> |
|||
| <RefId> '[' <IndexList> ']' ':' <TypeRef> |
|||
| <RefId> |
|||
<IndexList> ::= <IndexDecl> |
|||
| <IndexList> ';' <IndexDecl> |
|||
<IndexDecl> ::= <IdDecl> |
|||
| CONST <IdDecl> |
|||
<IdDecl> ::= <IdList> ':' <Type> |
|||
<OptPropSpecifiers> ::= <PropertySpecifiers> |
|||
| |
|||
<PropertySpecifiers> ::= <PropertySpecifier> |
|||
| <PropertySpecifiers> <PropertySpecifier> |
|||
<PropertySpecifier> ::= INDEX <ConstExpr> !StorageSpecifier |
|||
| READ <FieldDesignator> |
|||
| WRITE <FieldDesignator> |
|||
| STORED <FieldDesignator> |
|||
! | STORED <ConstExpr> |
|||
| DEFAULT <ConstExpr> |
|||
| NODEFAULT |
|||
| WRITEONLY |
|||
| READONLY |
|||
| DISPID <ConstExpr> !Only within InterfaceTypes |
|||
| <ImplementsSpecifier> |
|||
<ImplementsSpecifier> ::= IMPLEMENTS <TypeRef> |
|||
| <ImplementsSpecifier> ',' <TypeRef> |
|||
! The implements directive must be the last specifier in the property |
|||
! declaration and can list more than one interface, separated by commas |
|||
!-----VARS--------------------------------------------------------------------- |
|||
<VarSection> ::= VAR <VarDeclList> |
|||
| THREADVAR <ThreadVarDeclList> |
|||
<VarDeclList> ::= <VarDecl> |
|||
| <VarDeclList> <VarDecl> |
|||
<VarDecl> ::= <IdList> ':' <Type> <OptAbsoluteClause> <OptPortDirectives> ';' |
|||
| <IdList> ':' <Type> '=' <TypedConstant> <OptPortDirectives> ';' |
|||
| <IdList> ':' <TypeSpec> |
|||
| SynError ';' |
|||
<ThreadVarDeclList> ::= <ThreadVarDecl> |
|||
| <ThreadVarDeclList> <ThreadVarDecl> |
|||
<ThreadVarDecl> ::= <IdList> ':' <TypeSpec> |
|||
| SynError ';' |
|||
<OptAbsoluteClause> ::= ABSOLUTE <RefId> |
|||
! | ABSOLUTE <ConstExpr> !on windows only, not on linux |
|||
| |
|||
!------------------------------------------------------------------------------ |
|||
! E X P R E S S I O N S |
|||
!------------------------------------------------------------------------------ |
|||
<ConstExpr> ::= <Expr> |
|||
<ConstOrdExpr> ::= <AddExpr> |
|||
<ConstStrExpr> ::= <AddExpr> |
|||
<Expr> ::= <AddExpr> |
|||
| <AddExpr> <RelOp> <AddExpr> |
|||
| SynError |
|||
<AddExpr> ::= <MulExpr> |
|||
| <AddExpr> <AddOp> <MulExpr> |
|||
<MulExpr> ::= <Factor> |
|||
| <MulExpr> <MulOp> <Factor> |
|||
<Factor> ::= NIL |
|||
| <ICONST> |
|||
| <RCONST> |
|||
| <SCONST> |
|||
| <Designator> |
|||
| <SetConstructor> |
|||
| '@' <Designator> |
|||
| '@' '@' <Designator> !returns memory address of a procedural variable |
|||
| '(' <Expr> ')' |
|||
| '(' <Expr> ')' '^' |
|||
| '+' <Factor> |
|||
| '-' <Factor> |
|||
| NOT <Factor> |
|||
!---PortArray |
|||
<Designator> ::= <FieldDesignator> |
|||
| <Designator> '.' <FieldDesignator> |
|||
| <Designator> '^' |
|||
| <Designator> '[' <ExprList> ']' |
|||
| <Designator> '(' <ExprList> ')' !FunctionCall or TypeCast |
|||
| <Designator> '(' ')' !FunctionCall |
|||
| <Designator> AS <TypeRef> !eg "with Source as TListItem do ..." |
|||
| '(' <Designator> ')' |
|||
| INHERITED <Designator> |
|||
<AsnOp> ::= ':=' |
|||
| '+=' | '-=' | '*=' | '/=' |
|||
<RelOp> ::= '=' | '>' | '<' | '<=' | '>=' | '<>' |
|||
| IN | IS | AS |
|||
<AddOp> ::= '+' |'-' |
|||
| OR | XOR |
|||
<MulOp> ::='*' | '/' |
|||
| DIV | MOD | AND | SHL | SHR |
|||
<SetConstructor> ::= '[' <SetElementList> ']' |
|||
| '[' ']' |
|||
<SetElementList> ::= <SetElement> |
|||
| <SetElementList> ',' <SetElement> |
|||
<SetElement> ::= <Expr> |
|||
| <Expr> '..' <Expr> |
|||
<ExprList> ::= <Expr> |
|||
| <ExprList> ',' <Expr> |
|||
<FmtExpr> ::= <Expr> |
|||
| <Expr> ':' <Expr> |
|||
| <Expr> ':' <Expr> ':' <Expr> |
|||
<FmtExprList> ::= <FmtExpr> |
|||
| <FmtExprList> ',' <FmtExpr> |
|||
<ConstExprList> ::= <ConstExpr> |
|||
| <ConstExprList> ',' <ConstExpr> |
|||
!------------------------------------------------------------------------------ |
|||
! S T A T E M E N T S |
|||
!------------------------------------------------------------------------------ |
|||
<StmtList> ::= <Statement> |
|||
| <StmtList> ';' <Statement> |
|||
<Statement> ::= <Label> <Statement> |
|||
| <AssignmentStmt> |
|||
| <CallStmt> |
|||
| <GotoStatement> |
|||
| <CompoundStmt> |
|||
| <IfStatement> |
|||
| <CaseStatement> |
|||
| <ForStatement> |
|||
| <WhileStatement> |
|||
| <RepeatStatement> |
|||
| <WithStatement> |
|||
| <TryFinallyStmt> |
|||
| <TryExceptStmt> |
|||
| <RaiseStmt> |
|||
| <AssemblerStmt> |
|||
| SynError |
|||
| |
|||
<Label> ::= <LCONST> ':' |
|||
| <LabelId> ':' |
|||
<AssignmentStmt> ::= <Designator> <AsnOp> <Expr> |
|||
| '@' <RefId> ':=' <Factor> |
|||
!EXAMPLE of this '@' <RefId>, that calls the GetProcAddress |
|||
!function and points a var StrComp to the result. |
|||
! var StrComp: function(Str1, Str2: PChar): Integer; |
|||
! ... |
|||
! @StrComp := GetProcAddress(KernelHandle, 'lstrcmpi'); |
|||
<CallStmt> ::= <Designator> !procedure, function, method, typecast |
|||
| WRITE '(' <FmtExprList> ')' |
|||
| WRITELN '(' <FmtExprList> ')' |
|||
! | INHERITED <CallStmt> |
|||
| INHERITED |
|||
<GotoStatement> ::= GOTO <LCONST> |
|||
| GOTO <RefId> |
|||
<CompoundStmt> ::= BEGIN <StmtList> END |
|||
<IfStatement> ::= IF <Expr> THEN <Statement> ELSE <Statement> |
|||
| IF <Expr> THEN <Statement> |
|||
| IF SynError THEN <Statement> |
|||
<CaseStatement> ::= CASE <Expr> OF <CaseList> <OtherWise> END |
|||
<ForStatement> ::= FOR <RefId> ':=' <Expr> <Dir> <Expr> DO <Statement> |
|||
<Dir> ::= TO | DOWNTO |
|||
<WhileStatement> ::= WHILE <Expr> DO <Statement> |
|||
<WithStatement> ::= WITH <DesignatorList> DO <Statement> |
|||
<DesignatorList> ::= <Designator> |
|||
| <DesignatorList> ',' <Designator> |
|||
<RepeatStatement> ::= REPEAT <StmtList> UNTIL <Expr> |
|||
<AssemblerStmt> ::= ASM <AsmLanguage> END |
|||
<OtherWise> ::= OTHERWISE <StmtList> |
|||
| ELSE <StmtList> |
|||
| |
|||
<CaseList> ::= <CaseSelector> |
|||
| <CaseList> ';' <CaseSelector> |
|||
| <CaseList> ';' |
|||
<CaseSelector> ::= <CaseLabels> ':' <Statement> |
|||
<CaseLabels> ::= <CaseLabel> |
|||
| <CaseLabels> ',' <CaseLabel> |
|||
<CaseLabel> ::= <ConstExpr> |
|||
| <ConstExpr> '..' <ConstExpr> |
|||
<RaiseStmt> ::= RAISE SynError ![object] [AT address] |
|||
| RAISE <OptExceptInstance> |
|||
| RAISE <OptExceptInstance> AT <Address> |
|||
<TryFinallyStmt> ::= TRY <StmtList> FINALLY <StmtList> END |
|||
<TryExceptStmt> ::= TRY <StmtList> EXCEPT <ExceptionBlock> <OptExceptionElse> END |
|||
<ExceptionBlock> ::= <ExceptionStmt> |
|||
| <ExceptionBlock> ';' <ExceptionStmt> |
|||
<ExceptionStmt> ::= ON <Selector> DO <Statement> |
|||
! | ELSE <Statement> |
|||
| <Statement> |
|||
<OptExceptionElse> ::= ELSE <StmtList> |
|||
| |
|||
<OptExceptInstance> ::= <Designator> !usually a method call (??) |
|||
| |
|||
<Address> ::= <Designator> !usually a functiion call, returning an adress |
|||
<OptSemi> ::= ';' |
|||
| |
|||
!------------------------------------------------------------------------------ |
|||
! R O U T I N E S |
|||
!------------------------------------------------------------------------------ |
|||
<ProcedureDeclSection> ::= <ProcedureDecl> |
|||
| <FunctionDecl> |
|||
| <MethodDecl> |
|||
<ProcedureDecl> ::= <ProcHeading> <CallBody> <OptSemi> |
|||
<FunctionDecl> ::= <FuncHeading> <CallBody> <OptSemi> |
|||
<MethodDecl> ::= <MethHeading> <CallBody> <OptSemi> |
|||
<ProcHeading> ::= PROCEDURE <RefId> <OptFormalParms> <OptCallSpecifiers> ';' |
|||
| <ProcHeading> <CallDirectives> <OptSemi> |
|||
<FuncHeading> ::= FUNCTION <RefId> <OptFormalParms> ':' <ResultType> <OptCallSpecifiers> ';' |
|||
| FUNCTION <RefId> ';' |
|||
| <FuncHeading> <CallDirectives> <OptSemi> |
|||
! |
|||
! if the heading is 'incomplete' it was declared before |
|||
! and must be followed by a <CallBody> TO BE IMPROVED |
|||
<MethHeading> ::= PROCEDURE <RefId> '.' <RefId> <OptFormalParms> <OptCallSpecifiers> ';' |
|||
| FUNCTION <RefId> '.' <RefId> <OptFormalParms> ':' <ResultType> <OptCallSpecifiers> ';' |
|||
| FUNCTION <RefId> '.' <RefId> ';' |
|||
| CONSTRUCTOR <RefId> '.' <RefId> <OptFormalParms> <OptCallSpecifiers> ';' |
|||
| DESTRUCTOR <RefId> '.' <RefId> <OptFormalParms> <OptCallSpecifiers> ';' |
|||
| CLASS PROCEDURE <RefId> '.' <RefId> <OptFormalParms> <OptCallSpecifiers> ';' |
|||
| CLASS FUNCTION <RefId> '.' <RefId> <OptFormalParms> ':' <ResultType> <OptCallSpecifiers> ';' |
|||
| <MethHeading> <CallDirectives> ';' |
|||
! |
|||
! the class methods operates on classes instead of objects |
|||
<ResultType> ::= <TypeRef> |
|||
<OptFormalParms> ::= '(' <FormalParmList> ')' |
|||
| '(' ')' |
|||
| |
|||
<FormalParmList> ::= <FormalParm> |
|||
| <FormalParmList> ';' <FormalParm> |
|||
<FormalParm> ::= <Parameter> |
|||
| CONST <Parameter> |
|||
| VAR <Parameter> |
|||
| OUT <Parameter> |
|||
<Parameter> ::= <IdList> |
|||
| <IdList> ':' <ParmType> |
|||
| <IdList> ':' <TypeRef> '=' <ConstExpr> |
|||
<ParmType> ::= <TypeRef> |
|||
| ARRAY OF <TypeRef> |
|||
| ARRAY OF CONST |
|||
| FILE |
|||
<CallBody> ::= <OptDeclSection> <CompoundStmt> |
|||
| <OptDeclSection> <AssemblerStmt> |
|||
| <ExternalDeclaration> |
|||
| FORWARD |
|||
!-----DIRECTIVES--------------------------------------------------------------- |
|||
! <PortDirectives> are to produce warnings at compile time when source code is compiled |
|||
! in the {$HINTS ON} {$WARNINGS ON} state. It can be applied to declarations |
|||
! |
|||
! <PortDirectives are accepted: |
|||
! WITHIN const and var declarations (not after), |
|||
! WITHIN unit headers (not after) |
|||
! AFTER function/procedure headings (not within) (ONE terminating ';' is optional) |
|||
! <PortDirectives are NOT accepted: |
|||
! in/after type declarations |
|||
!------------------------------------------------------------------------------ |
|||
<OptPortDirectives> ::= <PortDirectives> |
|||
| |
|||
<PortDirectives> ::= <PortDirective> |
|||
| <PortDirectives> <PortDirective> |
|||
<PortDirective> ::= PLATFORM ! to warn that it is specific to a particular operating environment (such as Windows or Linux) |
|||
| PLATFORM '=' <ConstExpr> |
|||
| DEPRECATED ! to warn it is obsolete or supported only for backward compatibility |
|||
| LIBRARY ! to warn dependencies on a particular library or component framework (such as CLX). |
|||
!------------------------ |
|||
<OptMethodDirectives> ::= <MethodDirectives> |
|||
| <OptMethodDirectives> <PortDirective> ';' |
|||
| |
|||
<MethodDirectives> ::= <MethodDirective> ';' |
|||
| <MethodDirectives> <MethodDirective> ';' |
|||
<MethodDirective> ::= VIRTUAL |
|||
| VIRTUAL <ConstExpr> |
|||
| DYNAMIC !for classes only |
|||
| OVERRIDE |
|||
| ABSTRACT |
|||
| MESSAGE <ConstExpr> |
|||
| OVERLOAD |
|||
| REINTRODUCE |
|||
| DISPID <ConstExpr> !only within an <InterfaceType> |
|||
| <CallConvention> |
|||
!TODO NOT ALL THESE METHOD DIRECTIVES CAN BE COMBINED WITH EACH OTHER |
|||
!------------------------ |
|||
<OptPropertyDirectives> ::= <PropertyDirective> ';' |
|||
| <OptPropertyDirectives> <PortDirective> ';' |
|||
| |
|||
<PropertyDirective> ::= DEFAULT |
|||
!------------------------ |
|||
<ExternalDeclaration> ::= EXTERNAL |
|||
| EXTERNAL <ConstStrExpr> |
|||
| EXTERNAL <ConstStrExpr> NAME <ConstStrExpr> |
|||
! | EXTERNAL <SCONST> |
|||
! | EXTERNAL <SCONST> NAME <SCONST> |
|||
!------------------------ |
|||
<CallDirectives> ::= <CallDirective> |
|||
| <CallDirectives> <CallDirective> |
|||
<CallDirective> ::= <CallConvention> |
|||
| <CallObsolete> |
|||
| <PortDirective> |
|||
| VARARGS !works only with external routines and cdecl calling convention. |
|||
| LOCAL !prevents exporting in a library |
|||
| <SCONST> !for PasPro only |
|||
| OVERLOAD |
|||
<OptCallSpecifiers> ::= <CallSpecifier> |
|||
| <OptCallSpecifiers> <CallSpecifier> |
|||
| |
|||
<CallSpecifier> ::= <CallConvention> |
|||
| <CallObsolete> |
|||
<CallConventions> ::= <CallConvention> |
|||
| <CallConventions> <CallConvention> |
|||
<OptCallConventions> ::= <CallConvention> |
|||
| <OptCallConventions> <CallConvention> |
|||
| |
|||
![ParmOrder] [CleanUp] [RegParms] |
|||
<CallConvention> ::= REGISTER !Left-to-right Routine Yes |
|||
| PASCAL !Left-to-right Routine No |
|||
| CDECL !Right-to-left Caller No |
|||
| STDCALL !Right-to-left Routine No |
|||
| SAFECALL !Right-to-left Routine No |
|||
<CallObsolete> ::= INLINE !for backward compatibility only; has no effect on the compiler. |
|||
| ASSEMBLER !for backward compatibility only; has no effect on the compiler. |
|||
| NEAR !for 16-bits programming only, has no effect in 32 bit applications |
|||
| FAR !for 16-bits programming only, has no effect in 32 bit applications |
|||
| EXPORT !for 16-bits programming only, has no effect in 32 bit applications |
|||
!------------------------------------------------------------------------------ |
|||
! A S S E M B L E R I N S T R U C T I O N S |
|||
!------------------------------------------------------------------------------ |
|||
! The asm 'grammar' below is rather tolerant in accepting assembler code and needs |
|||
! further elaboration. The main problem is that end of lines are not detected, so |
|||
! the separators between the instructions cannot be found, so an <AsmItem> cannot |
|||
! be grouped in a meaningfull way with another <AsmItem> into a true <AsmInstruction> |
|||
! A fundamental solution could be to start a new lexical "context" in this grammar, with |
|||
! that forces the lexical scanner to recognize an assembler specific list of keywords |
|||
! Unfortunately, this is not supported by the Gold parser |
|||
<AsmLanguage> ::= <AsmInstruction> |
|||
| <AsmLanguage> <AsmInstruction> |
|||
<AsmInstruction> ::= <AsmItem> |
|||
| <AsmInstruction> <AsmItem> |
|||
| <AsmInstruction> ',' <AsmItem> |
|||
| <AsmInstruction> ';' |
|||
<AsmItem> ::= <AsmLabel> |
|||
| <AsmExpr> |
|||
<AsmLabel> ::= <AsmLocal> ':' |
|||
| <AsmId> ':' |
|||
<AsmExpr> ::= <AsmFactor> |
|||
| '-' <AsmFactor> |
|||
| <AsmExpr> '+' <AsmFactor> |
|||
| <AsmExpr> '*' <AsmFactor> |
|||
| <AsmExpr> '-' <AsmFactor> |
|||
| <AsmExpr> '.' <AsmFactor> |
|||
| '[' <AsmExpr> ']' |
|||
| '(' <AsmExpr> ')' |
|||
! <AsmId> '(' <AsmExpr> ')' |
|||
| SynError |
|||
<AsmFactor> ::= <AsmId> |
|||
| <AsmLocal> |
|||
| <ICONST> |
|||
| <RCONST> |
|||
| <SCONST> |
|||
<AsmId> ::= <RefId> |
|||
| '&' <RefId> |
|||
| REPEAT | WHILE | IF |
|||
| AND | OR | XOR | SHR | SHL | DIV | NOT |
|||
! plus many other keywords as well that may serve as an identifier |
|||
<AsmLocal> ::= '@' <LCONST> |
|||
| '@' <AsmId> |
|||
| '@' <AsmLocal> |
|||
| '@' END |
|||
</pre> |
|||
=={{header|E}}== |
=={{header|E}}== |
||
=={{header|EC}}== |
=={{header|EC}}== |
Revision as of 05:03, 21 June 2009
You are encouraged to solve this task according to the task description, using any language you may know.
In computer science, Backus–Naur Form (BNF) is a metasyntax used to express context-free grammars: that is, a formal way to describe formal languages. John Backus and Peter Naur developed a context free grammar to define the syntax of a programming language by using two sets of rules: i.e., lexical rules and syntactic rules.
BNF is widely used as a notation for the grammars of computer programming languages, instruction sets and communication protocols, as well as a notation for representing parts of natural language grammars. Many textbooks for programming language theory and/or semantics document the programming language in BNF.
There are many extensions and variants of BNF, including Extended and Augmented Backus–Naur Forms (EBNF and ABNF).
The task here is establish a BNF grammar for as many languages as possible to facilitate language categorization and translation.
4D
ALGOL 60
! ---------------------------------------------------------------------------- ! ALGOL 60 ! ! (ALGO)rithmic (L)anguage ! ! ALGOL is, by far, the most influential programming language developed to ! date. Although is did not achieve mass use, a large number of syntactic ! and semantic principles and concepts were developed and incorporated into ! the language. As a result, ALGOL is considered the main reference language ! in computer science. ! ! In the late 1950's, many in the study of computer science believed that a ! new universal programming language was needed. This new language would be ! used through the study of computer science and would eventually replace ! other popular languages such as FORTRAN. ! ! The ACM (Association for Computing Machinery) and GAMM (a European ! organization of mathematics and mechanics) created an international ! committee to define and document the new language. This committee ! included computer scientists from both North America and Europe. ! ! The process of developing ALGOL included a number of challenges: ! ! First, the computers of the era varied greatly in the number of characters ! that could be represented. This made it difficult to define the exact ! lexics of the language. For instance, one mainframe could contain an ! ampersand character (&) while another may not. ! ! Another challenge involved an issue that nowadays seems trival - the ! representation of decimal points. In the 50 United States and Canada, real ! numbers are represented using a period. For instance, the value 4 1/2 can ! be written as "4.5". Europe, on the other hand, uses a comma. The same ! value is represented with "4,5". Both sides were steadfast that their ! format was superior. Although the "period" format would eventually ! dominate, this was a major issue at the time. ! ! To describe the syntax of the first version of ALGOL, Peter Naur modified ! Backus Normal Form to create Backus-Naur Form. This format is now used ! universially to describe the syntax of programming languages. ! ! To spite these challenges, ALGOL created a number of language features ! that would be incorporated into its numerious successors. These include: ! ! * Block structure ! * Free-form structure (elements are not required to be in a specific column) ! * Pass by Name (while powerful, it is not used in modern languages) ! * The For-Loop ! * The 'Else' clause on if-statements (LISP's 'cond' predates this though) ! * Reserved words ! ! The grammar below was, for the most part, cut and pasted from "Revised ! Report on the Algorithmic Language: Algol 60" by Peter Naur. The numbered ! sections refer directly to the chapters in the Report. ! ! The grammar was modified to remove ambigities and define terminals using ! regular expressions. ! ! ---------------------------------------------------------------------------- "Name" = 'ALGOL 60' "Version" = '1960' "Author" = 'J.W. Backus, F.L. Bauer, J.Green, C. Katz, J. McCarthy, P. Naur,' | 'A.J. Perlis, H. Rutishauser, K. Samuelson, B. Vauquois,' | 'J.H. Wegstein, A. van Wijngaarden, M. Woodger' "About" = 'ALGOL (ALGOrithmic Language) is the most influential' | 'programming language to date. Although it did not achieve' | 'mass use, it established multiple syntactic and semantic' | 'features used in languages today.' "Start Symbol" = <program> ! ========================================================== Terminals {String Ch} = {Printable} - [`] - [''] Identifier = {Letter}{Alphanumeric}* String = '`' ( '`' {String Ch}* '' | {String Ch} )* '' IntegerLiteral = {Digit}+ RealLiteral = {Digit}+ '.' {Digit}+ (e {Digit}+)? ! =========================================================== Rules <unsigned integer> ::= IntegerLiteral <unsigned number> ::= IntegerLiteral | RealLiteral ! ==================================================================== ! 2.2.2 Logical values. ! ==================================================================== <logical value> ::= true | false ! ==================================================================== ! 3. Expressions ! ==================================================================== <expression> ::= <Boolean expression> ! ==================================================================== ! 3.1. Variables ! ==================================================================== <subscript expression> ::= <arithmetic expression> <subscript list> ::= <subscript expression> | <subscript list> ',' <subscript expression> <variable> ::= Identifier | Identifier '[' <subscript list> ']' ! subscripted value ! ==================================================================== ! 3.2. Function designators ! ==================================================================== <actual parameter> ::= String | <expression> <parameter delimiter> ::= ',' | ')' Identifier ':' '(' <actual parameter list> ::= <actual parameter> | <actual parameter list> <parameter delimiter> <actual parameter> ! ==================================================================== ! 3.3. Arithmetic expressions ! ==================================================================== <adding operator> ::= '+' | '-' <multiplying operator> ::= '*' | '/' | 'div' <primary> ::= <unsigned number> | <variable> | Identifier '(' <actual parameter list> ')' | '(' <arithmetic expression> ')' <factor> ::= <primary> | <factor> '^' <primary> !Originally an up-arrow <term> ::= <factor> | <term> <multiplying operator> <factor> <simple arithmetic expression> ::= <term> | <adding operator> <term> | <simple arithmetic expression> <adding operator> <term> <if clause> ::= if <Boolean expression> then <arithmetic expression> ::= <simple arithmetic expression> | <if clause> <simple arithmetic expression> else <arithmetic expression> ! ==================================================================== ! 3.4. Boolean expressions ! ==================================================================== <relational operator> ::= '<' | '<=' | '=' | '>=' | '>' | '~=' <relation> ::= <relation> <relational operator> <simple arithmetic expression> | <simple arithmetic expression> <Boolean primary> ::= <logical value> | <relation> <Boolean secondary> ::= <Boolean primary> | not <Boolean primary> <Boolean factor> ::= <Boolean secondary> | <Boolean factor> and <Boolean secondary> <Boolean term> ::= <Boolean factor> | <Boolean term> or <Boolean factor> <implication> ::= <Boolean term> | <implication> implies <Boolean term> <simple Boolean> ::= <implication> | <simple Boolean> eqv <implication> <Boolean expression> ::= <simple Boolean> | <if clause> <simple Boolean> else <Boolean expression> ! ==================================================================== ! 3.5. Designational expressions ! ==================================================================== <label> ::= Identifier | <Unsigned Integer> <switch designator> ::= Identifier '[' <subscript expression> ']' <simple designational expression> ::= <label> | <switch designator> | '(' <designational expression> ')' <designational expression> ::= <simple designational expression> | <if clause> <simple designational expression> else <designational expression> ! ==================================================================== ! 4.1. Compound statements and blocks ! ==================================================================== <unlabelled basic statement> ::= <assignment statement> | <go to statement> | !EMPTY !dummy statement | <procedure statement> <basic statement> ::= <unlabelled basic statement> | <label> ':' <basic statement> <unconditional statement> ::= <basic statement> | <compound statement> | <block> <statement> ::= <unconditional statement> | <conditional statement> | <for statement> <compound tail> ::= <statement> end | <statement> ';' <compound tail> <block head> ::= begin <declaration> | <block head> ';' <declaration> <unlabelled block> ::= <block head> ';' <compound tail> <unlabelled compound> ::= begin <compound tail> <compound statement> ::= <unlabelled compound> | <label> ':' <compound statement> <block> ::= <unlabelled block> | <label> ':' <block> <program> ::= <block> | <compound statement> ! ==================================================================== ! 4.2. Assignment statements ! ==================================================================== <left part> ::= <variable> ':=' <left part list> ::= <left part> | <left part list> <left part> <assignment statement> ::= <left part list> <Boolean expression> ! ==================================================================== ! 4.3. Go to statements ! ==================================================================== <go to statement> ::= goto <designational expression> ! ==================================================================== ! 4.4. Dummy statements ! ==================================================================== !<dummy statement> ::= <empty> ! ==================================================================== ! 4.5. Conditional statements ! ==================================================================== <if statement> ::= <if clause> <unconditional statement> <conditional statement> ::= <if statement> | <if statement> else <statement> | <if clause> <for statement> | <label> ':' <conditional statement> ! ==================================================================== ! 4.6. For statements ! ==================================================================== <for list element> ::= <arithmetic expression> | <arithmetic expression> step <arithmetic expression> until <arithmetic expression> | <arithmetic expression> while <Boolean expression> <for list> ::= <for list element> | <for list> ',' <for list element> <for clause> ::= for <variable> ':=' <for list> do <for statement> ::= <for clause> <statement> | <label> ':' <for statement> ! ==================================================================== ! 4.7. Procedure statements ! ==================================================================== <procedure statement> ::= Identifier '(' <actual parameter list> ')' | Identifier ! ==================================================================== ! 5. Declarations ! ==================================================================== <declaration> ::= <type declaration> | <array declaration> | <switch declaration> | <procedure declaration> ! ==================================================================== ! 5.1. Type declarations ! ==================================================================== <type list> ::= Identifier | Identifier ',' <type list> <type> ::= real | integer | Boolean <local or own type> ::= <type> | own <type> <type declaration> ::= <local or own type> <type list> ! ==================================================================== ! 5.2. Array declarations ! ==================================================================== <lower bound> ::= <arithmetic expression> <upper bound> ::= <arithmetic expression> <bound pair> ::= <lower bound> ':' <upper bound> <bound pair list> ::= <bound pair> | <bound pair list> ',' <bound pair> <array segment> ::= Identifier '[' <bound pair list> ']' | Identifier ',' <array segment> <array list> ::= <array segment> | <array list> ',' <array segment> <array declaration> ::= array <array list> | <local or own type> array <array list> ! ==================================================================== ! 5.3. Switch declarations ! ==================================================================== <switch list> ::= <designational expression> | <switch list> ',' <designational expression> <switch declaration> ::= switch Identifier ':=' <switch list> ! ==================================================================== ! 5.4. Procedure declarations ! ==================================================================== <formal parameter> ::= Identifier <formal parameter list> ::= <formal parameter> | <formal parameter list> <parameter delimiter> <formal parameter> <formal parameter part> ::= !EMPTY | '(' <formal parameter list> ')' <identifier list> ::= Identifier | <identifier list> ',' Identifier <value part> ::= value <identifier list> ';' | !EMPTY <specifier> ::= string | <type> | array | <type> array | label | switch | procedure | <type> procedure <specification part> ::= !EMPTY | <specification> !=== The following rule was added <specification> ::= <specifier> <identifier list> ';' | <specification> <specifier> <identifier list> ';' <procedure heading> ::= Identifier <formal parameter part> ';' <value part> <specification part> <procedure body> ::= <statement> !!! | <code> !<code> refers to any embedded non-Algol code <procedure declaration> ::= procedure <procedure heading> <procedure body> | <type> procedure <procedure heading> <procedure body>
ALGOL 68
APL
AWK
ActionScript
Ada
Agda2
AmigaE
AppleScript
Assembly
AutoHotkey
BASIC
! ----------------------------------------------------------------------- ! BASIC '64 ! ! Beginner's All-purpose Symbolic Instruction Code ! ! "It is practically impossible to teach good programming style to students ! that have had prior exposure to BASIC; as potential programmers they are ! mentally mutilated beyond hope of regeneration." ! ! - Edsger W. Dijkstra ! ! BASIC is one of the oldest programming language and one of the most popular. ! It was developed in 1964 by John G. Kemeny and Thomas E. Kurtz to teach ! students the basics of programming concepts. At the advent of the microcomputer, ! BASIC was implemented on numerous platforms such as the Commodore, Atari, ! Apple II, Altair, IBM PC computers. Over time, BASIC evolved into GW-BASIC, ! QBasic, Visual Basic, and recently Visual Basic .NET. ! ! In practically all programming languages, the reserved word/symbol that denotes ! a comment is treated as a form of whitespace - having no effect in the manner in ! which the program runs. Once such type of comment is used to indicate the remainder ! of the line is to be ignored. These can be added to the end of any line without ! changing the meaning of the program. In C++, it is the '//' symbol; ! in BASIC '64 it is 'REM'. ! ! However, in the BASIC programming language, the line comment is treated like a ! statement. For instance, if 'REM' was a normal line comment: ! ! 10 PRINT "Hello World" REM Common first program ! ! would be a valid statement. However, in BASIC, this is illegal. In the example ! above, the comment must be added as an additional statement. ! ! 10 PRINT "Hello World" : REM Common first program ! ! As a result, the Line Comment terminal that is used in the GOLD Parser cannot be ! used here. In the grammar below, a 'Remark' terminal was created that accepts all ! series of printable characters starting with the characters "REM ". In some ! implementations of BASIC, any string starting with "REM" is a comment statement. ! Examples include "REMARK", "REMARKABLE" and "REMODEL". This grammar requires the space. ! ! This grammar does not include the editor statements such as NEW, SAVE, LOAD, etc... ! ! Note: This is an ad hoc version of the language. If there are any flaws, please ! e-mail GOLDParser@DevinCook.com and I will update the grammar. Most likely I have ! included features not available in BASIC '64. ! ----------------------------------------------------------------------- "Name" = 'BASIC (Beginners All-purpose Symbolic Instruction Code)' "Author" = 'John G. Kemeny and Thomas E. Kurtz' "Version" = '1964 - Original - before Microsoft enhanced the language for the IBM PC.' "About" = 'BASIC is one of most common and popular teaching languages ever created. ' "Case Sensitive" = False "Start Symbol" = <Lines> {String Chars} = {Printable} - ["] {WS} = {Whitespace} - {CR} - {LF} NewLine = {CR}{LF}|{CR} Whitespace = {WS}+ Remark = REM{Space}{Printable}* ID = {Letter}[$%]? String = '"'{String Chars}*'"' Integer = {digit}+ Real = {digit}+.{digit}+ <Lines> ::= Integer <Statements> NewLine <Lines> | Integer <Statements> NewLine <Statements> ::= <Statement> ':' <Statements> | <Statement> <Statement> ::= CLOSE '#' Integer | DATA <Constant List> | DIM ID '(' <Integer List> ')' | END | FOR ID '=' <Expression> TO <Expression> | FOR ID '=' <Expression> TO <Expression> STEP Integer | GOTO <Expression> | GOSUB <Expression> | IF <Expression> THEN <Statement> | INPUT <ID List> | INPUT '#' Integer ',' <ID List> | LET Id '=' <Expression> | NEXT <ID List> | OPEN <Value> FOR <Access> AS '#' Integer | POKE <Value List> | PRINT <Print list> | PRINT '#' Integer ',' <Print List> | READ <ID List> | RETURN | RESTORE | RUN | STOP | SYS <Value> | WAIT <Value List> | Remark <Access> ::= INPUT | OUPUT <ID List> ::= ID ',' <ID List> | ID <Value List> ::= <Value> ',' <Value List> | <Value> <Constant List> ::= <Constant> ',' <Constant List> | <Constant> <Integer List> ::= Integer ',' <Integer List> | Integer <Expression List> ::= <Expression> ',' <Expression List> | <Expression> <Print List> ::= <Expression> ';' <Print List> | <Expression> | <Expression> ::= <And Exp> OR <Expression> | <And Exp> <And Exp> ::= <Not Exp> AND <And Exp> | <Not Exp> <Not Exp> ::= NOT <Compare Exp> | <Compare Exp> <Compare Exp> ::= <Add Exp> '=' <Compare Exp> | <Add Exp> '<>' <Compare Exp> | <Add Exp> '><' <Compare Exp> | <Add Exp> '>' <Compare Exp> | <Add Exp> '>=' <Compare Exp> | <Add Exp> '<' <Compare Exp> | <Add Exp> '<=' <Compare Exp> | <Add Exp> <Add Exp> ::= <Mult Exp> '+' <Add Exp> | <Mult Exp> '-' <Add Exp> | <Mult Exp> <Mult Exp> ::= <Negate Exp> '*' <Mult Exp> | <Negate Exp> '/' <Mult Exp> | <Negate Exp> <Negate Exp> ::= '-' <Power Exp> | <Power Exp> <Power Exp> ::= <Power Exp> '^' <Value> | <Value> <Value> ::= '(' <Expression> ')' | ID | ID '(' <Expression List> ')' | <Constant> <Constant> ::= Integer | String | Real
! ----------------------------------------------------------------------- ! Commodore PET BASIC ! ! Beginner's All-purpose Symbolic Instruction Code ! ! "It is practically impossible to teach good programming style to students ! that have had prior exposure to BASIC; as potential programmers they are ! mentally mutilated beyond hope of regeneration." ! ! - Edsger W. Dijkstra ! ! ! BASIC is one of the oldest programming language and one of the most popular. ! It was developed in 1964 by John G. Kemeny and Thomas E. Kurtz to teach ! students the basics of programming concepts. At the advent of the microcomputer, ! BASIC was implemented on numerous platforms such as the Commodore, Atari, ! Apple II, Altair, IBM PC computers. Over time, BASIC evolved into GW-BASIC, ! QBasic, Visual Basic, and recently Visual Basic .NET. ! ! In practically all programming languages, the reserved word/symbol that denotes ! a comment is treated as a form of whitespace - having no effect in the manner in ! which the program runs. Once such type of comment is used to indicate the remainder ! of the line is to be ignored. These can be added to the end of any line without ! changing the meaning of the program. In C++, it is the '//' symbol. ! ! However, in the BASIC programming language, the line comment is treated like a ! statement. For instance, if 'REM' was a normal line comment: ! ! 10 PRINT "Hello World" REM Common first program ! ! would be a valid statement. However, in BASIC, this is illegal. In the example ! above, the comment must be added as an additional statement. ! ! 10 PRINT "Hello World" : REM Common first program ! ! As a result, the Line Comment terminal that is used in the GOLD Parser cannot be ! used here. In the grammar below, a 'Remark' terminal was created that accepts all ! series of printable characters starting with the characters "REM ". In some ! implementations of BASIC, any string starting with "REM" is a comment statement. ! Examples include "REMARK", "REMARKABLE" and "REMODEL". This grammar requires the space. ! ! ----------------------------------------------------------------------- "Name" = 'Commodore PET BASIC' "Author" = 'Commodore Business Machines' "Version" = '2.0' "About" = 'This is the version of BASIC that was used on the Commodore 64.' "Case Sensitive" = False "Start Symbol" = <Lines> {String Chars} = {Printable} - ["] {WS} = {Whitespace} - {CR} - {LF} NewLine = {CR}{LF}|{CR} Whitespace = {WS}+ Remark = REM{Space}{Printable}* ID = {Letter}{Alphanumeric}?[$%]? !IDs are can only have a maximum of 2 characters FunctionID = FN {Letter}{Letter}? String = '"'{String Chars}*'"' Integer = {Digit}+ Real = {Digit}+'.'{Digit}+ <Lines> ::= <Lines> <Line> | <Line> <Line> ::= Integer <Statements> NewLine <Statements> ::= <Statements> ':' <Statement> | <Statement> <Statement> ::= CLOSE Integer | CLR | CMD <Expression> | CONT !Continue | DATA <Constant List> | DEF FunctionID '(' <ID List> ')' '=' <Expression> !The ID must start with FN | DIM ID '(' <Expression List> ')' | END | FOR ID '=' <Expression> TO <Expression> <Step Opt> | GET ID | GET '#' Integer ',' ID | GOSUB <Expression> | GOTO <Expression> | IF <Expression> THEN <Then Clause> | INPUT <ID List> | INPUT '#' Integer ',' <ID List> | LET ID '=' <Expression> | LIST <Line Range> | LOAD <Value List> | ID '=' <Expression> | NEW | NEXT <ID List> | ON ID GOTO <Expression List> | OPEN <Expression List> | POKE <Expression> ',' <Expression> | PRINT <Print list> | PRINT '#' Integer ',' <Print List> | READ <ID List> | RETURN | RESTORE | RUN | RUN <Expression> | STOP | SYS <Expression> | WAIT <Expression List> | VERIFY <Expression List> | Remark <Step Opt> ::= STEP <Expression> | <ID List> ::= ID ',' <ID List> | ID <Value List> ::= <Value> ',' <Value List> | <Value> <Constant List> ::= <Constant> ',' <Constant List> | <Constant> <Expression List> ::= <Expression> ',' <Expression List> | <Expression> <Print List> ::= <Expression> ';' <Print List> | <Expression> | <Line Range> ::= Integer | Integer '-' | Integer '-' Integer <Then Clause> ::= Integer | <Statement> ! ----------------------------------------------- Expressions <Expression> ::= <And Exp> OR <Expression> | <And Exp> <And Exp> ::= <Not Exp> AND <And Exp> | <Not Exp> <Not Exp> ::= NOT <Compare Exp> | <Compare Exp> <Compare Exp> ::= <Add Exp> '=' <Compare Exp> | <Add Exp> '<>' <Compare Exp> | <Add Exp> '>' <Compare Exp> | <Add Exp> '>=' <Compare Exp> | <Add Exp> '<' <Compare Exp> | <Add Exp> '<=' <Compare Exp> | <Add Exp> <Add Exp> ::= <Mult Exp> '+' <Add Exp> | <Mult Exp> '-' <Add Exp> | <Mult Exp> <Mult Exp> ::= <Negate Exp> '*' <Mult Exp> | <Negate Exp> '/' <Mult Exp> | <Negate Exp> <Negate Exp> ::= '-' <Power Exp> | <Power Exp> <Power Exp> ::= <Power Exp> '^' <Sub Exp> !On the Commodore, the symbol was an up-arrow | <Sub Exp> <Sub Exp> ::= '(' <Expression> ')' | <Value> <Value> ::= ID | ABS '(' <Expression> ')' | ASC '(' <Expression> ')' | ATN '(' <Expression> ')' | 'CHR$' '(' <Expression> ')' | COS '(' <Expression> ')' | EXP '(' <Expression> ')' | FunctionID '(' <Expression List> ')' | FRE '(' <Value> ')' !The <Value> is irrelevant | INT '(' <Expression> ')' | 'LEFT$' '(' <Expression> ',' <Expression> ')' | LEN '(' <Expression> ')' | PEEK '(' <Expression> ')' | POS '(' <Value> ')' !The <Value> is irrelevant | 'RIGHT$' '(' <Expression> ',' <Expression> ')' | RND '(' <Expression> ')' | SGN '(' <Expression> ')' | SPC '(' <Expression> ')' | SQR '(' <Expression> ')' | TAB '(' <Expression> ')' | TAN '(' <Expression> ')' | VAL '(' <Expression> ')' | <Constant> <Constant> ::= Integer | String | Real
Bc
Befunge
Brainf***
C
! ----------------------------------------------------------------------- ! ANSI C ! ! The C programming language evolved at Bell Labs from a series of ! programming languages: 'CPL', 'BCPL', and then 'B'. As a result, C's ! development was a combined effort between Dennis Ritchie, Ken Thompson, ! and Martin Richards. ! ! C was designed for the creation and implementation of low-level systems ! such as operating systems, device drivers, firmware, etc... To realize ! this goal, the language contains the ability to perform operations ! directly on memory and has direct access to system pointers. While this ! gives an enormous amount of control and flexibility, it also makes C a ! professional programming language - not to be used by an inexperienced ! programmer. ! ! C (and later C++) quickly became the de facto standard for developing ! operating systems, applications and most other large projects. UNIX as ! well as Windows, Linux, and Mac-OS X were developed using this ! language (and its successors). ! ! More information is available at Dennis Ritchie's website: ! http://cm.bell-labs.com/cm/cs/who/dmr/ ! ! The C grammar is inherently ambigious and requires a large number of ! LALR(1) states to parse. As a result, the time required by the GOLD ! Parser Builder to compile this grammar is extensive. ! ! C is not a line-based grammar with the notable exception of compiler ! directives (which are preceeded by a '#' character). These are usually not ! handled directly by the actual parser, but, rather, the pre-processor. ! Before the program is analyzed by the parser, C compilers scan the code and ! act on these commands. The final C program is then passed to the parser. ! ----------------------------------------------------------------------- ! ----------------------------------------------------------------------- ! This grammar does not contain the compiler directives. ! ! Note: This is an ad hoc version of the language. If there are any flaws, ! please visit the contact page and tell me. ! ! SPECIAL THANKS TO: ! BOB MEAGHER ! MIKE WISDOM ! VLADIMIR MOROZOV ! TOM VAN DIJCK ! ! Modified 06/14/2002 ! * The correct definition for "return" was added. Thanks to Bob Meagher. ! * Added the missing rules for labels, storage specifications, etc... ! which were left out. Thanks to Mike Wisdom for calling this to ! my attention. ! ! Modified 06/21/2002 ! * I fixed an error in the grammar for declaring functions. ! ! Modified 06/15/2003 ! * Vladimir Morozov fixed an error for calling functions with no parameters ! ! Modified 01/31/2004 ! * Tom van Dijck found a bug in the grammar concerning variable ! initialization. ! ! Modified 04/26/2004 ! * Some errors in the grammar were fixed. ! ! Modified 01/19/2005 ! * The definition for comments was modified. In ANSI C, block comments ! cannot be nested. As a result, they are defined using the whitespace ! terminal. ! ! Modified 03/28/2007 ! * The commented-out definition for non-nested comments was updated. The ! previous version did not work in all cases. ! ----------------------------------------------------------------------- "Name" = 'ANSI C' "Version" = '1973' "Author" = 'Dennis Ritchie, Ken Thompson, Martin Richards' "About" = 'C is one of the most common, and complex, programming languages in use today.' "Case Sensitive" = True "Start Symbol" = <Decls> {Hex Digit} = {Digit} + [abcdefABCDEF] {Oct Digit} = [01234567] {Id Head} = {Letter} + [_] {Id Tail} = {Id Head} + {Digit} {String Ch} = {Printable} - ["] {Char Ch} = {Printable} - [''] DecLiteral = [123456789]{digit}* OctLiteral = 0{Oct Digit}* HexLiteral = 0x{Hex Digit}+ FloatLiteral = {Digit}*'.'{Digit}+ StringLiteral = '"'( {String Ch} | '\'{Printable} )* '"' CharLiteral = '' ( {Char Ch} | '\'{Printable} )'' Id = {Id Head}{Id Tail}* ! =================================================================== ! Comments ! =================================================================== Comment Start = '/*' Comment End = '*/' Comment Line = '//' ! Typically, C comments cannot be nested. As a result, the ! Comment Start and Comment End terminals cannot be used. ! ! To implement non-nested comments, the whitespace terminal is ! modified to accept them. In the definition below, Whitespace ! is defined as one or more {Whitespace} characters OR a series ! of characters delimited by /* and */. Note that the characters ! between the two delimiters cannot contain the */ sequence. ! ! Uncomment the following to prevent block commments. Make sure ! to comment the Comment Start and Comment End definitions. ! ! {Non Slash} = {Printable} - [/] ! {Non Asterisk} = {Printable} - [*] ! ! Whitespace = {Whitespace}+ ! | '/*' ( {Non Asterisk} | '*' {Non Slash}? )* '*/' !======================================================= <Decls> ::= <Decl> <Decls> | <Decl> ::= <Func Decl> | <Func Proto> | <Struct Decl> | <Union Decl> | <Enum Decl> | <Var Decl> | <Typedef Decl> ! =================================================================== ! Function Declaration ! =================================================================== <Func Proto> ::= <Func ID> '(' <Types> ')' ';' | <Func ID> '(' <Params> ')' ';' | <Func ID> '(' ')' ';' <Func Decl> ::= <Func ID> '(' <Params> ')' <Block> | <Func ID> '(' <Id List> ')' <Struct Def> <Block> | <Func ID> '(' ')' <Block> <Params> ::= <Param> ',' <Params> | <Param> <Param> ::= const <Type> ID | <Type> ID <Types> ::= <Type> ',' <Types> | <Type> <Id List> ::= Id ',' <Id List> | Id <Func ID> ::= <Type> ID | ID ! =================================================================== ! Type Declaration ! =================================================================== <Typedef Decl> ::= typedef <Type> ID ';' <Struct Decl> ::= struct Id '{' <Struct Def> '}' ';' <Union Decl> ::= union Id '{' <Struct Def> '}' ';' <Struct Def> ::= <Var Decl> <Struct Def> | <Var Decl> ! =================================================================== ! Variable Declaration ! =================================================================== <Var Decl> ::= <Mod> <Type> <Var> <Var List> ';' | <Type> <Var> <Var List> ';' | <Mod> <Var> <Var List> ';' <Var> ::= ID <Array> | ID <Array> '=' <Op If> <Array> ::= '[' <Expr> ']' | '[' ']' | <Var List> ::= ',' <Var Item> <Var List> | <Var Item> ::= <Pointers> <Var> <Mod> ::= extern | static | register | auto | volatile | const ! =================================================================== ! Enumerations ! =================================================================== <Enum Decl> ::= enum Id '{' <Enum Def> '}' ';' <Enum Def> ::= <Enum Val> ',' <Enum Def> | <Enum Val> <Enum Val> ::= Id | Id '=' OctLiteral | Id '=' HexLiteral | Id '=' DecLiteral ! =================================================================== ! Types ! =================================================================== <Type> ::= <Base> <Pointers> <Base> ::= <Sign> <Scalar> | struct Id | struct '{' <Struct Def> '}' | union Id | union '{' <Struct Def> '}' | enum Id <Sign> ::= signed | unsigned | <Scalar> ::= char | int | short | long | short int | long int | float | double | void <Pointers> ::= '*' <Pointers> | ! =================================================================== ! Statements ! =================================================================== <Stm> ::= <Var Decl> | Id ':' !Label | if '(' <Expr> ')' <Stm> | if '(' <Expr> ')' <Then Stm> else <Stm> | while '(' <Expr> ')' <Stm> | for '(' <Arg> ';' <Arg> ';' <Arg> ')' <Stm> | <Normal Stm> <Then Stm> ::= if '(' <Expr> ')' <Then Stm> else <Then Stm> | while '(' <Expr> ')' <Then Stm> | for '(' <Arg> ';' <Arg> ';' <Arg> ')' <Then Stm> | <Normal Stm> <Normal Stm> ::= do <Stm> while '(' <Expr> ')' | switch '(' <Expr> ')' '{' <Case Stms> '}' | <Block> | <Expr> ';' | goto Id ';' | break ';' | continue ';' | return <Expr> ';' | ';' !Null statement <Arg> ::= <Expr> | <Case Stms> ::= case <Value> ':' <Stm List> <Case Stms> | default ':' <Stm List> | <Block> ::= '{' <Stm List> '}' <Stm List> ::= <Stm> <Stm List> | ! =================================================================== ! Here begins the C's 15 levels of operator precedence. ! =================================================================== <Expr> ::= <Expr> ',' <Op Assign> | <Op Assign> <Op Assign> ::= <Op If> '=' <Op Assign> | <Op If> '+=' <Op Assign> | <Op If> '-=' <Op Assign> | <Op If> '*=' <Op Assign> | <Op If> '/=' <Op Assign> | <Op If> '^=' <Op Assign> | <Op If> '&=' <Op Assign> | <Op If> '|=' <Op Assign> | <Op If> '>>=' <Op Assign> | <Op If> '<<=' <Op Assign> | <Op If> <Op If> ::= <Op Or> '?' <Op If> ':' <Op If> | <Op Or> <Op Or> ::= <Op Or> '||' <Op And> | <Op And> <Op And> ::= <Op And> '&&' <Op BinOR> | <Op BinOR> <Op BinOR> ::= <Op BinOr> '|' <Op BinXOR> | <Op BinXOR> <Op BinXOR> ::= <Op BinXOR> '^' <Op BinAND> | <Op BinAND> <Op BinAND> ::= <Op BinAND> '&' <Op Equate> | <Op Equate> <Op Equate> ::= <Op Equate> '==' <Op Compare> | <Op Equate> '!=' <Op Compare> | <Op Compare> <Op Compare> ::= <Op Compare> '<' <Op Shift> | <Op Compare> '>' <Op Shift> | <Op Compare> '<=' <Op Shift> | <Op Compare> '>=' <Op Shift> | <Op Shift> <Op Shift> ::= <Op Shift> '<<' <Op Add> | <Op Shift> '>>' <Op Add> | <Op Add> <Op Add> ::= <Op Add> '+' <Op Mult> | <Op Add> '-' <Op Mult> | <Op Mult> <Op Mult> ::= <Op Mult> '*' <Op Unary> | <Op Mult> '/' <Op Unary> | <Op Mult> '%' <Op Unary> | <Op Unary> <Op Unary> ::= '!' <Op Unary> | '~' <Op Unary> | '-' <Op Unary> | '*' <Op Unary> | '&' <Op Unary> | '++' <Op Unary> | '--' <Op Unary> | <Op Pointer> '++' | <Op Pointer> '--' | '(' <Type> ')' <Op Unary> !CAST | sizeof '(' <Type> ')' | sizeof '(' ID <Pointers> ')' | <Op Pointer> <Op Pointer> ::= <Op Pointer> '.' <Value> | <Op Pointer> '->' <Value> | <Op Pointer> '[' <Expr> ']' | <Value> <Value> ::= OctLiteral | HexLiteral | DecLiteral | StringLiteral | CharLiteral | FloatLiteral | Id '(' <Expr> ')' | Id '(' ')' | Id | '(' <Expr> ')'
C#
! ---------------------------------------------------------------------------- ! C# ! ! The C# Programming Language was created by the Microsoft Corporation to be ! used with the .NET platform. The goal of C# was to counter the flaws and ! difficulties found in Java and C++. In addition, the language was designed ! to work well with the Common Language Runtime which runs the .NET platform. ! ! C# was primarily the work of computer scientist Anders Hejlsberg who has ! worked on a wide range of programming languages. These include, but are ! not limited to, Visual J++, Borland Delphi and Turbo Pascal. His previous ! works and influences from Java and C++ can be seen in C#. ! ! ! GRAMMAR NOTES: ! ! The grammar was designed, in part, using the official language ! specification that can be found on the Microsoft website. ! ! Unfortunately, C# has a very complex grammar. As a result, considerable ! time was required to write a LALR(1) compliant version. In most cases, ! I preserved the section names used in the original specification, but many ! productions, especially those regarding local variable declarations and ! expressions, required modifications. ! ! Feel free to modify and port this grammar to other parsing systems, but ! please leave this information. Have a great day and happy programming! ! ! Note: If there are any flaws, please visit www.DevinCook.com/GOLDParser ! ! - Devin Cook ! ! ! Updates: ! 05/09/2006 ! Devin Cook ! The first version of the grammar was released. ! ! 04/04/2007 ! Devin Cook ! Fixed a flaw in the Primary Exp. Thanks to Patrick Kristiansen for ! the reporting the error. ! ! 09/21/2007 ! Devin Cook ! Modified the grammar to include the new features in C# 2.0. These include ! delegate expressions and partial classes. ! ! 11/07/2007 ! Devin Cook ! Made some additional changes to make the grammar compliant to the C# spec. ! ! ---------------------------------------------------------------------------- "Name" = 'C#' "Version" = '2.0' "Author" = 'Anders Hejlsberg' "About" = 'C# was created by Anders Hejlsberg for the Microsoft Corporation.' | 'The language was designed primarily to both fix flaws found in' | 'other languages and to integrate with the the .NET platform.' | 'This grammar was written by Devin Cook.' "Start Symbol" = <Compilation Unit> ! ----------------------------------------------------------------- Sets {ID Head} = {Letter} + [_] {ID Tail} = {AlphaNumeric} + [_] {String Ch} = {Printable} - ["] {Char Ch} = {Printable} - [''] {Hex Digit} = {Digit} + [abcdef] + [ABCDEF] ! ----------------------------------------------------------------- Terminals Identifier = [@]? {ID Head} {ID Tail}* !The @ is an override char MemberName = '.' {ID Head} {ID Tail}* DecLiteral = {Digit}+ ( [UuLl] | [Uu][Ll] | [Ll][Uu] )? HexLiteral = '0'[xX]{Hex Digit}+ ( [UuLl] | [Uu][Ll] | [Ll][Uu] )? RealLiteral = {Digit}*'.'{Digit}+ StringLiteral = '"'( {String Ch} | '\'{Printable} )* '"' CharLiteral = '' ( {Char Ch} | '\'{Printable} )'' ! ----------------------------------------------------------------- Comments Comment Line = '//' Comment Start = '/*' Comment End = '*/' ! =========================================================================== ! Shared by multiple sections ! =========================================================================== <Block or Semi> ::= <Block> | ';' <Valid ID> ::= Identifier | this | base | <Base Type> <Qualified ID> ::= <Valid ID> <Member List> <Member List> ::= <Member List> MemberName | !Zero or more <Semicolon Opt> ::= ';' | !Nothing ! =========================================================================== ! C.1.8 Literals ! =========================================================================== <Literal> ::= true | false | DecLiteral | HexLiteral | RealLiteral | CharLiteral | StringLiteral | null ! =========================================================================== ! C.2.2 Types ! =========================================================================== ! All date types in C# are objects. A distinction is made between different ! subtypes of objects, though. Some language constructs are restricted to ! one type or another. <Type> ::= <Non Array Type> | <Non Array Type> '*' | <Non Array Type> <Rank Specifiers> | <Non Array Type> <Rank Specifiers> '*' <Pointer Opt> ::= '*' | !Nothing <Non Array Type> ! ::= <Other Type> ! | <Integral Type> ! | <Qualified ID> ::= <Qualified ID> ! The following defines built-in datatypes only. This is necessary for local ! variable declarations. <Base Type> ::= <Other Type> | <Integral Type> <Other Type> ::= float | double | decimal | bool | void | object | string ! Integral types are valid in enumeration declarations. <Integral Type> ::= sbyte | byte | short | ushort | int | uint | long | ulong | char ! Rank specifiers are used to define the dimensions of arrays. The notation is odd. <Rank Specifiers Opt> ::= <Rank Specifiers Opt> <Rank Specifier> | <Rank Specifiers> ::= <Rank Specifiers> <Rank Specifier> | <Rank Specifier> <Rank Specifier> ::= '[' <Dim Separators> ']' <Dim Separators> ::= <Dim Separators> ',' | !Nothing ! =========================================================================== ! C.2.4 Expressions ! =========================================================================== <Expression Opt> ::= <Expression> | !Nothing <Expression List> ::= <Expression> | <Expression> ',' <Expression List> <Expression> ::= <Conditional Exp> '=' <Expression> | <Conditional Exp> '+=' <Expression> | <Conditional Exp> '-=' <Expression> | <Conditional Exp> '*=' <Expression> | <Conditional Exp> '/=' <Expression> | <Conditional Exp> '^=' <Expression> | <Conditional Exp> '&=' <Expression> | <Conditional Exp> '|=' <Expression> | <Conditional Exp> '%=' <Expression> | <Conditional Exp> '<<=' <Expression> | <Conditional Exp> '>>=' <Expression> | <Conditional Exp> <Conditional Exp> ::= <Or Exp> '?' <Or Exp> ':' <Conditional Exp> | <Or Exp> <Or Exp> ::= <Or Exp> '||' <And Exp> | <And Exp> <And Exp> ::= <And Exp> '&&' <Logical Or Exp> | <Logical Or Exp> <Logical Or Exp> ::= <Logical Or Exp> '|' <Logical Xor Exp> | <Logical Xor Exp> <Logical Xor Exp> ::= <Logical Xor Exp> '^' <Logical And Exp> | <Logical And Exp> <Logical And Exp> ::= <Logical And Exp> '&' <Equality Exp> | <Equality Exp> <Equality Exp> ::= <Equality Exp> '==' <Compare Exp> | <Equality Exp> '!=' <Compare Exp> | <Compare Exp> <Compare Exp> ::= <Compare Exp> '<' <Shift Exp> | <Compare Exp> '>' <Shift Exp> | <Compare Exp> '<=' <Shift Exp> | <Compare Exp> '>=' <Shift Exp> | <Compare Exp> is <Type> | <Compare Exp> as <Type> | <Shift Exp> <Shift Exp> ::= <Shift Exp> '<<' <Add Exp> | <Shift Exp> '>>' <Add Exp> | <Add Exp> <Add Exp> ::= <Add Exp> '+' <Mult Exp> | <Add Exp> '-' <Mult Exp> | <Mult Exp> <Mult Exp> ::= <Mult Exp> '*' <Unary Exp> | <Mult Exp> '/' <Unary Exp> | <Mult Exp> '%' <Unary Exp> | <Unary Exp> <Unary Exp> ::= '!' <Unary Exp> | '~' <Unary Exp> | '-' <Unary Exp> | '++' <Unary Exp> | '--' <Unary Exp> | '(' <Expression> ')' <Object Exp> !Cast "expression" is required to avoid a conflict | <Object Exp> ! Primary: x.y f(x) a[x] x++ x-- new typeof checked unchecked -> <Object Exp> ::= delegate '(' <Formal Param List Opt> ')' <Block> !New in 2.0 | <Primary Array Creation Exp> | <Method Exp> <Primary Array Creation Exp> ::= new <Non Array Type> '[' <Expression List> ']' <Rank Specifiers Opt> <Array Initializer Opt> | new <Non Array Type> <Rank Specifiers> <Array Initializer> <Method Exp> ::= <Method Exp> <Method> | <Primary Exp> <Primary Exp> ::= typeof '(' <Type> ')' | sizeof '(' <Type> ')' | checked '(' <Expression> ')' | unchecked '(' <Expression> ')' | new <Non Array Type> '(' <Arg List Opt> ')' !Non array creation | <Primary> | '(' <Expression> ')' <Primary> ::= <Valid ID> | <Valid ID> '(' <Arg List Opt> ')' !Current object method | <Literal> ! =========================================================================== ! Arguments ! =========================================================================== <Arg List Opt> ::= <Arg List> | !Nothing <Arg List> ::= <Arg List> ',' <Argument> | <Argument> <Argument> ::= <Expression> | ref <Expression> | out <Expression> ! =========================================================================== ! C.2.5 Statements ! =========================================================================== <Stm List> ::= <Stm List> <Statement> | <Statement> ! This repetative productions below resolve the hanging-else problem by ! restricting the "if-then" statement to remove ambiguity. Two levels of ! statements are declared with the second, "restricted", group only used in ! the "then" clause of a "if-then-else" statement. ! ! The "restricted" group is completely identical the the first with one ! exception: only the "if-then-else" variant of the if statement is allowed. ! In other words, no "if" statements without "else" clauses can appear inside ! the "then" part of an "if-then-else" statement. Using this solution, the ! "else" will bind to the last "If" statement, and still allows chaining. <Statement> ::= Identifier ':' ! label | <Local Var Decl> ';' | if '(' <Expression> ')' <Statement> | if '(' <Expression> ')' <Then Stm> else <Statement> | for '(' <For Init Opt> ';' <For Condition Opt> ';' <For Iterator Opt> ')' <Statement> | foreach '(' <Type> Identifier in <Expression> ')' <Statement> | while '(' <Expression> ')' <Statement> | lock '(' <Expression> ')' <Statement> | using '(' <Resource> ')' <Statement> | fixed '(' <Type> <Fixed Ptr Decs> ')' <Statement> | delegate '(' <Formal Param List Opt> ')' <Statement> | <Normal Stm> <Then Stm> ::= if '(' <Expression> ')' <Then Stm> else <Then Stm> | for '(' <For Init Opt> ';' <For Condition Opt> ';' <For Iterator Opt> ')' <Then Stm> | foreach '(' <Type> Identifier in <Expression> ')' <Then Stm> | while '(' <Expression> ')' <Then Stm> | lock '(' <Expression> ')' <Then Stm> | using '(' <Resource> ')' <Then Stm> | fixed '(' <Type> <Fixed Ptr Decs> ')' <Then Stm> | delegate '(' <Formal Param List Opt> ')' <Then Stm> | <Normal Stm> <Normal Stm> ::= switch '(' <Expression> ')' '{' <Switch Sections Opt> '}' | do <Normal Stm> while '(' <Expression> ')' ';' | try <Block> <Catch Clauses> <Finally Clause Opt> | checked <Block> | unchecked <Block> | unsafe <Block> | break ';' | continue ';' | goto Identifier ';' | goto case <Expression> ';' | goto default ';' | return <Expression Opt> ';' | throw <Expression Opt> ';' | <Statement Exp> ';' | ';' | <Block> <Block> ::= '{' <Stm List> '}' | '{' '}' <Variable Decs> ::= <Variable Declarator> | <Variable Decs> ',' <Variable Declarator> <Variable Declarator> ::= Identifier | Identifier '=' <Variable Initializer> <Variable Initializer> ::= <Expression> | <Array Initializer> | stackalloc <Non Array Type> '[' <Non Array Type> ']' <Constant Declarators> ::= <Constant Declarator> | <Constant Declarators> ',' <Constant Declarator> <Constant Declarator> ::= Identifier '=' <Expression> ! =========================================================================== ! Switch Clauses ! =========================================================================== <Switch Sections Opt> ::= <Switch Sections Opt> <Switch Section> | !Nothing <Switch Section> ::= <Switch Labels> <Stm List> <Switch Labels> ::= <Switch Label> | <Switch Labels> <Switch Label> <Switch Label> ::= case <Expression> ':' | default ':' ! =========================================================================== ! For Clauses ! =========================================================================== <For Init Opt> ::= <Local Var Decl> | <Statement Exp List> | !Nothing <For Iterator Opt> ::= <Statement Exp List> | !Nothing <For Condition Opt> ::= <Expression> | !Nothing <Statement Exp List> ::= <Statement Exp List> ',' <Statement Exp> | <Statement Exp> ! =========================================================================== ! Catch Clauses ! =========================================================================== <Catch Clauses> ::= <Catch Clause> <Catch Clauses> | !Nothing <Catch Clause> ::= catch '(' <Qualified ID> Identifier ')' <Block> | catch '(' <Qualified ID> ')' <Block> | catch <Block> <Finally Clause Opt> ::= finally <Block> | !Nothing ! =========================================================================== ! Using Clauses ! =========================================================================== <Resource> ::= <Local Var Decl> | <Statement Exp> ! =========================================================================== ! Fixed Clauses ! =========================================================================== <Fixed Ptr Decs> ::= <Fixed Ptr Dec> | <Fixed Ptr Decs> ',' <Fixed Ptr Dec> <Fixed Ptr Dec> ::= Identifier '=' <Expression> ! =========================================================================== ! Statement Expressions & Local Variable Declaration ! =========================================================================== ! The complex productions below are able to avoid the shift-reduce error caused ! by declaring an array. The notation used by C# (and the rest of the C++ ! family) prevents an array declaration to be distinguished from an array ! assignment statement until a number of characters are read. ! ! a.b.c[2] = "Test" ! a.b.c[] = new String[3] ! ! The system CANNOT make a decision between the two until it is reading the ! contents the [ ... ]. ! ! As a result, the local variable declaration below contains the full notation ! for each of the C# methods at the same level as local variable declarations. ! Since the system does not have to reduce UNTIL it is within the [ ... ], no ! shift-reduce error will occur. Nasty, huh? <Local Var Decl> ::= <Qualified ID> <Rank Specifiers> <Pointer Opt> <Variable Decs> | <Qualified ID> <Pointer Opt> <Variable Decs> ! | <Base Type> <Rank Specifiers> <Pointer Opt> <Variable Decs> ! | <Base Type> <Pointer Opt> <Variable Decs> <Statement Exp> ::= <Qualified ID> '(' <Arg List Opt> ')' | <Qualified ID> '(' <Arg List Opt> ')' <Methods Opt> <Assign Tail> | <Qualified ID> '[' <Expression List> ']' <Methods Opt> <Assign Tail> | <Qualified ID> '->' Identifier <Methods Opt> <Assign Tail> | <Qualified ID> '++' <Methods Opt> <Assign Tail> | <Qualified ID> '--' <Methods Opt> <Assign Tail> | <Qualified ID> <Assign Tail> <Assign Tail> ::= '++' | '--' | '=' <Expression> | '+=' <Expression> | '-=' <Expression> | '*=' <Expression> | '/=' <Expression> | '^=' <Expression> | '&=' <Expression> | '|=' <Expression> | '%=' <Expression> | '<<=' <Expression> | '>>=' <Expression> <Methods Opt> ::= <Methods Opt> <Method> | !Null <Method> ::= MemberName | MemberName '(' <Arg List Opt> ')' !Invocation | '[' <Expression List> ']' | '->' Identifier | '++' | '--' ! =========================================================================== ! C.2.6 Namespaces ! =========================================================================== <Compilation Unit> ::= <Using List> <Compilation Items> <Using List> ::= <Using List> <Using Directive> | !Nothing <Using Directive> ::= using Identifier '=' <Qualified ID> ';' | using <Qualified ID> ';' <Compilation Items> ::= <Compilation Items> <Compilation Item> | ! Zero or more <Compilation Item> ::= <Namespace Dec> | <Namespace Item> !Default namespace ! =========================================================================== ! Namespace ! =========================================================================== <Namespace Dec> ::= <Attrib Opt> namespace <Qualified ID> '{' <Using List> <Namespace Items> '}' <Semicolon Opt> <Namespace Items> ::= <Namespace Items> <Namespace Item> | ! Zero or more <Namespace Item> ::= <Constant Dec> | <Field Dec> | <Method Dec> | <Property Dec> | <Type Decl> <Type Decl> ::= <Class Decl> | <Struct Decl> | <Interface Decl> | <Enum Decl> | <Delegate Decl> ! ================================= Modifiers <Header> ::= <Attrib Opt> <Access Opt> <Modifier List Opt> <Access Opt> ::= private | protected | public | internal !Friend | !Nothing <Modifier List Opt> ::= <Modifier List Opt> <Modifier> | !Nothing <Modifier> ::= abstract | extern | new | override | partial | readonly | sealed | static | unsafe | virtual | volatile ! =========================================================================== ! C.2.7 Classes ! =========================================================================== <Class Decl> ::= <Header> class Identifier <Class Base Opt> '{' <Class Item Decs Opt> '}' <Semicolon Opt> <Class Base Opt> ::= ':' <Class Base List> | !Nothing <Class Base List> ::= <Class Base List> ',' <Non Array Type> | <Non Array Type> <Class Item Decs Opt> ::= <Class Item Decs Opt> <Class Item> | !Nothing <Class Item> ::= <Constant Dec> | <Field Dec> | <Method Dec> | <Property Dec> | <Event Dec> | <Indexer Dec> | <Operator Dec> | <Constructor Dec> | <Destructor Dec> | <Type Decl> <Constant Dec> ::= <Header> const <Type> <Constant Declarators> ';' <Field Dec> ::= <Header> <Type> <Variable Decs> ';' <Method Dec> ::= <Header> <Type> <Qualified ID> '(' <Formal Param List Opt> ')' <Block or Semi> <Formal Param List Opt> ::= <Formal Param List> | !Nothing <Formal Param List> ::= <Formal Param> | <Formal Param List> ',' <Formal Param> <Formal Param> ::= <Attrib Opt> <Type> Identifier | <Attrib Opt> ref <Type> Identifier | <Attrib Opt> out <Type> Identifier | <Attrib Opt> params <Type> Identifier !Parameter array <Property Dec> ::= <Header> <Type> <Qualified ID> '{' <Accessor Dec> '}' <Accessor Dec> ::= <Access Opt> get <Block or Semi> | <Access Opt> get <Block or Semi> <Access Opt> set <Block or Semi> | <Access Opt> set <Block or Semi> | <Access Opt> set <Block or Semi> <Access Opt> get <Block or Semi> <Event Dec> ::= <Header> event <Type> <Variable Decs> ';' | <Header> event <Type> <Qualified ID> '{' <Event Accessor Decs> '}' <Event Accessor Decs> ::= add <Block or Semi> | add <Block or Semi> remove <Block or Semi> | remove <Block or Semi> | remove <Block or Semi> add <Block or Semi> !<Indexer Dec> ! ::= <Header> <Type> <Indexer This> '[' <Formal Param List> ']' '{' <Accessor Dec>'}' ! !<Indexer This> ! ::= this ! | <Qualified ID> !Ending in 'this' - This is a post-parse semantic check <Indexer Dec> ::= <Header> <Type> <Qualified ID> '[' <Formal Param List> ']' '{' <Accessor Dec>'}' !Ending in 'this' - This is a post-parse semantic check ! =========================================================================== ! Operator Declarations ! =========================================================================== <Operator Dec> ::= <Header> <Overload Operator Decl> <Block or Semi> | <Header> <Conversion Operator Decl> <Block or Semi> <Overload Operator Decl> ::= <Type> operator <Overload Op> '(' <Type> Identifier ')' | <Type> operator <Overload Op> '(' <Type> Identifier ',' <Type> Identifier ')' <Conversion Operator Decl> ::= implicit operator <Type> '(' <Type> Identifier ')' | explicit operator <Type> '(' <Type> Identifier ')' <Overload Op> ::= '+' | '-' | '!' | '~' | '++' | '--' | true | false | '*' | '/' | '%' | '&' | '|' | '^' | '<<' | '>>' | '==' | '!=' | '>' | '<' | '>=' | '<=' ! =========================================================================== ! Constructor / Destructor Declarations ! =========================================================================== <Constructor Dec> ::= <Header> <Constructor Declarator> <Block or Semi> <Constructor Declarator> ::= Identifier '(' <Formal Param List Opt> ')' <Constructor Init Opt> <Constructor Init Opt> ::= <Constructor Init> | !Nothing <Constructor Init> ::= ':' base '(' <Arg List Opt> ')' | ':' this '(' <Arg List Opt> ')' <Destructor Dec> ::= <Header> '~' Identifier '(' ')' <Block> ! =========================================================================== ! C.2.8 Structs ! =========================================================================== ! Note: Structures have the SAME members as normal classes. As a result, the ! <Class Item Decs Opt> rule is used <Struct Decl> ::= <Header> struct Identifier <Class Base Opt> '{' <Class Item Decs Opt>'}' <Semicolon Opt> ! =========================================================================== ! C.2.9 Arrays ! =========================================================================== <Array Initializer Opt> ::= <Array Initializer> | ! NOTHING <Array Initializer> ::= '{' <Variable Initializer List Opt> '}' | '{' <Variable Initializer List> ',' '}' <Variable Initializer List Opt> ::= <Variable Initializer List> | ! Nothing <Variable Initializer List> ::= <Variable Initializer> | <Variable Initializer List> ',' <Variable Initializer> ! =========================================================================== ! C.2.10 Interfaces ! =========================================================================== <Interface Decl> ::= <Header> interface Identifier <Interface Base Opt> '{' <Interface Item Decs Opt> '}' <Semicolon Opt> <Interface Base Opt> ::= ':' <Class Base List> | !Nothing <Interface Item Decs Opt> ::= <Interface Item Decs Opt> <Interface Item Dec> | !Nothing <Interface Item Dec> ::= <Interface Method Dec> | <Interface Property Dec> | <Interface Event Dec> | <Interface Indexer Dec> <Interface Method Dec> ::= <Attrib Opt> <New Opt> <Type> Identifier '(' <Formal Param List Opt> ')' <Interface Empty Body> <New Opt> ::= NEW | !Nothing <Interface Property Dec> ::= <Attrib Opt> <New Opt> <Type> Identifier '{' <Interface Accessors> '}' <Interface Indexer Dec> ::= <Attrib Opt> <New Opt> <Type> this '[' <Formal Param List> ']' '{' <Interface Accessors> '}' <Interface Accessors> ::= <Attrib Opt> <Access Opt> get <Interface Empty Body> | <Attrib Opt> <Access Opt> set <Interface Empty Body> | <Attrib Opt> <Access Opt> get <Interface Empty Body> <Attrib Opt> <Access Opt> set <Interface Empty Body> | <Attrib Opt> <Access Opt> set <Interface Empty Body> <Attrib Opt> <Access Opt> get <Interface Empty Body> <Interface Event Dec> ::= <Attrib Opt> <New Opt> event <Type> Identifier <Interface Empty Body> <Interface Empty Body> ::= ';' | '{' '}' ! =========================================================================== ! C.2.11 Enums ! =========================================================================== <Enum Decl> ::= <Header> enum Identifier <Enum Base Opt> <Enum Body> <Semicolon Opt> <Enum Base Opt> ::= ':' <Integral Type> | !Nothing <Enum Body> ::= '{' <Enum Item Decs Opt> '}' | '{' <Enum Item Decs> ',' '}' <Enum Item Decs Opt> ::= <Enum Item Decs> | !Nothing <Enum Item Decs> ::= <Enum Item Dec> | <Enum Item Decs> ',' <Enum Item Dec> <Enum Item Dec> ::= <Attrib Opt> Identifier | <Attrib Opt> Identifier '=' <Expression> ! =========================================================================== ! C.2.12 Delegates ! =========================================================================== <Delegate Decl> ::= <Header> delegate <Type> Identifier '(' <Formal Param List Opt> ')' ';' ! =========================================================================== ! C.2.13 Attributes ! =========================================================================== <Attrib Opt> ::= <Attrib Opt> <Attrib Section> | !Nothing <Attrib Section> ::= '[' <Attrib Target Spec Opt> <Attrib List> ']' | '[' <Attrib Target Spec Opt> <Attrib List> ',' ']' <Attrib Target Spec Opt> ::= assembly ':' | field ':' | event ':' | method ':' | module ':' | param ':' | property ':' | return ':' | type ':' | ! Nothing <Attrib List> ::= <Attribute> | <Attrib List> ',' <Attribute> <Attribute> ::= <Qualified ID> '(' <Expression List> ')' | <Qualified ID> '(' ')' | <Qualified ID>
C++
Caml
Clean
Clojure
Cobol
! ----------------------------------------------------------------------------- ! COBOL 85 ! ! COmmon Business Oriented Language ! ! ! The COBOL programmming language is one of the oldest still in use today. It ! was originally designed by the United States Department of defense under the ! supervision of the COnference on DAta SYstems Languages (CODASYL) Committee. ! Most of the groundwork and design of COBOL was done by General Grace Hopper ! of the United States Navy. ! ! The COBOL language was designed to be a self-documenting language where ! programs would read as close to English as possible. All interaction ! between the user, the terminal and files are performed through language ! statements rather than third-party libraries. The metaphor used for data ! types is abstract and completely platform independant. As a result of these ! factors, COBOL is a very portable. ! ! The COBOL 85 grammar is complex - containing, over 350 reserved words, ! 950 rules which results in iver 1,600 LALR states. ! ! ! Side Note: General Grace Hopper was the engineer who coined the term "bug" ! when she found an "ill-positioned" insect in an early mainframe. ! ! Revisions: ! 09-13-06: Devin Cook ! * Fixed a flaw in the Communications Section where a period was added ! to the end of a terminal rather than as a separate terminal. Thanks ! to Jose Ventura for finding this flaw. ! ! * Fixed a flaw in the PicString terminal. The definition required two or ! more spaces between PIC and the picture characters. Thanks to Jose ! Ventura for finding this flaw. ! ! 07-21-06: Devin Cook ! * The grammar was modified to better handle embeded statements and ! message handling clauses. ! ! 06-12-06: Devin Cook ! * Grammar was completed ! ----------------------------------------------------------------------------- "Name" = 'COBOL 85' "Version" = '1.1' "Author" = 'General Grace Hopper (United States Navy) and the CODASYL Committee' "About" = 'Originally created in 1960, COBOL (COmmon Business Oriented Language)' | 'is one of the top 5 most popular languages in use today. COBOL was designed' | 'to be self-documenting by using a structure simular to basic English.' | 'This is the full 85 grammar. However, However, differ vendors have' | 'created specialized dialects. As result, this grammar may not parse' | 'them. This grammar was written by Devin Cook.' "Case Sensitive" = False "Start Symbol" = <Program> {String Chars 1} = {Printable} - [''] {String Chars 2} = {Printable} - ["] {Id Tail Chars} = {Alphanumeric} + [-] StringLiteral = ''{String Chars 1}*'' | '"'{String Chars 2}*'"' IntLiteral = {Digit}+ FloatLiteral = {Digit}+'.'{Digit}+ Identifier = {Letter}{Id Tail Chars}* ! ----------------------------------------------------------------------------- ! Picture Clause ! ----------------------------------------------------------------------------- ! TYPE SYMBOLS ! X ! 9 ! ! EDITED SYMBOLS ! , B 0 / Simple Insertion ! . Special Insertion ! - CR DB $ Fixed Insertion ! + - $ Floating Insertion ! Z * Suppression and Replacement {Pic Ch} = [xa9] + [bpz0*+-,] {WS} = {Space} + {HT} + {NBSP} PicString = PIC(TURE)? {WS}+ (IS {WS}+)? (CR|DB|[$s])? {Pic Ch}+ ( '('{Number}+')' )? ( [v.] {Pic Ch}+ ( '('{Number}+')' )? )? (CR|DB|[$s])? | PIC(TURE)? {WS}+ (IS {WS}+)? '' {String Chars 1}* '' | PIC(TURE)? {WS}+ (IS {WS}+)? '"' {String Chars 2}* '"' ! ----------------------------------------------------------------------------- ! Main program structure ! ----------------------------------------------------------------------------- <Program> ::= <Identification Division> <Environment Division> <Data Division> <Procedure Division> ! ----------------------------------------------------------------------------- ! Optional Keywords - Often used only for readbility ! ----------------------------------------------------------------------------- <ADVANCING Opt> ::= ADVANCING | !Optional <ALL Opt> ::= ALL | !Optional <ARE Opt> ::= ARE | !Optional <AREA Opt> ::= AREA | AREAS | !Optional <AT Opt> ::= AT | !Optional <BY Opt> ::= BY | !Optional <CHARACTERS Opt> ::= CHARACTERS | !Optional <COLLATING Opt> ::= COLLATING | !Optional <CONTAINS Opt> ::= CONTAINS | !Optional <DATA Opt> ::= DATA | !Optional <EVERY Opt> ::= EVERY | !Optional <FILE Opt> ::= FILE | !Optional <FINAL Opt> ::= FINAL | !Optional <FOR Opt> ::= FOR | !Optional <GLOBAL Opt> ::= GLOBAL | !Optional <IN Opt> ::= IN | !Optional <INDICATE Opt> ::= INDICATE | !Optional <INITIAL Opt> ::= INITIAL | !Optional <IS Opt> ::= IS | !Optional <KEY Opt> ::= KEY | !Optional <LINE Opt> ::= LINE | !Optional <LINES Opt> ::= LINE | LINES | !Optional <MESSAGE opt> ::= MESSAGE | !Optional <MODE Opt> ::= MODE | !Optional <NEXT Opt> ::= NEXT | !Optional <NUMBER Opt> ::= NUMBER | !Optional <OF Opt> ::= OF | !Optional <ON Opt> ::= ON | !Optional <ORDER opt> ::= ORDER | !Optional <PRINTING Opt> ::= PRINTING | !Optional <RECORD Opt> ::= RECORD | !Optional <REFERENCES Opt> ::= REFERENCES | !Optional <RIGHT Opt> ::= RIGHT | !Optional <ROUNDED Opt> ::= ROUNDED | !Optional <STANDARD Opt> ::= STANDARD | !Optional <SIGN Opt> ::= SIGN | !Optional <SIZE Opt> ::= SIZE | !Optional <STATUS Opt> ::= STATUS | !Optional <SYMBOLIC Opt> ::= SYMBOLIC | !Optional <TAPE Opt> ::= TAPE | !Optional <THEN Opt> ::= THEN | !Optional <THAN Opt> ::= THAN | !Optional <TO Opt> ::= TO | !Optional <WHEN Opt> ::= WHEN | !Optional <WITH Opt> ::= WITH | !Optional ! ----------------------------------------------------------------------------- ! Equivelent Keywords ! ----------------------------------------------------------------------------- <THRU> ::= THRU | THROUGH <IS ARE Opt> ::= IS | ARE | !Optional <CORRESPONDING> ::= CORRESPONDING | CORR ! ----------------------------------------------------------------------------- ! Clauses Shared By Multiple Rules ! ----------------------------------------------------------------------------- <Giving Clause Opt> ::= GIVING Identifier | !Optional <Pointer Clause> ::= <WITH Opt> POINTER <Variable> | !Optional <File Name> ::= Identifier | StringLiteral <File Name List> ::= <File Name List> <File Name> | <File Name> <Int Constant> ::= Identifier | <Integer> <Index Clause> ::= INDEXED <BY Opt> Identifier | !Optional <BEFORE AFTER> ::= BEFORE | AFTER ! ----------------------------------------------------------------------------- ! Values, Literals, etc... ! ----------------------------------------------------------------------------- <Symbolic Value> ::= <Literal> | <Variable> | <Figurative> <Values> ::= <Values> <Value> | <Value> <Value> ::= <Literal> | <Variable> <Numeric> ::= <Integer> | Identifier <Literal> ::= <Integer> | FloatLiteral | StringLiteral | QUOTE | QUOTES <Integer> ::= IntLiteral | '66' | '77' | '88' <Figurative> ::= ZERO | ZEROS | ZEROES | SPACE | SPACES | HIGH-VALUE | HIGH-VALUES | LOW-VALUE | LOW-VALUES | ALL StringLiteral | NULL | NULLS <Identifiers> ::= <Identifiers> Identifier | Identifier <Variables> ::= <Variables> Identifier | Identifier <Variable> ::= Identifier | Identifier '(' <Subsets> ')' <Subsets> ::= <Subsets> ':' <Numeric> | <Numeric> ! ----------------------------------------------------------------------------- ! ------------------------- IDENTIFICATION DIVISION --------------------------- ! ----------------------------------------------------------------------------- <Identification Division> ::= IDENTIFICATION DIVISION '.' <Prog ID> <Program Info Items> <Prog ID> ::= PROGRAM-ID '.' <Word List> <Prog Name Opt> '.' <Program Info Items> ::= <Program Info Items> <Program Info Item> | !Zero or more <Program Info Item> ::= AUTHOR '.' <Word List> '.' | INSTALLATION '.' <Word List> '.' | DATE-WRITTEN '.' <Word List> '.' | DATE-COMPILED '.' <Word List> '.' | SECURITY '.' <Word List> '.' <Word List> ::= <Word List> <Word Item> | <Word Item> <Word Item> ::= Identifier | <Integer> | FloatLiteral | StringLiteral | '/' | ',' <Prog Name Opt> ::= <IS Opt> <Common Initial> <Program Opt> | !Optional <Common Initial> ::= COMMON | INITIAL <Program Opt> ::= PROGRAM | !Optional ! ----------------------------------------------------------------------------- ! -------------------------- ENVIRONMENT DIVISION ----------------------------- ! ----------------------------------------------------------------------------- <Environment Division> ::= ENVIRONMENT DIVISION '.' <Config Section> <Input-Output Section> | !Optional ! ----------------------------------------------------------------------------- ! CONFIGURATION SECTION ! ----------------------------------------------------------------------------- <Config Section> ::= CONFIGURATION SECTION '.' <Config Section Items> | !Optional <Config Section Items> ::= <Config Section Items> <Config Section Item> | !Zero or more <Config Section Item> ::= <Source Computer> | <Object Computer> | <Special Names> ! ----------------------------------------------------------------------------- ! SOURCE-COMPUTER ! ----------------------------------------------------------------------------- <Source Computer> ::= SOURCE-COMPUTER '.' <Source Computer Clause Opt> <Source Computer Clause Opt> ::= Identifier <Source Debug Opt> '.' | !Optional <Source Debug Opt> ::= <WITH Opt> DEBUGGING MODE ! ----------------------------------------------------------------------------- ! OBJECT-COMPUTER ! ----------------------------------------------------------------------------- <Object Computer> ::= OBJECT-COMPUTER '.' <Object Computer Clause Opt> <Object Computer Clause Opt> ::= Identifier <Object Clauses> '.' | !Optional <Object Clauses> ::= <Object Clause> <Object Clauses> | !Optional <Object Clause> ::= <Program Opt> <COLLATING Opt> SEQUENCE <IS Opt> Identifier | SEGMENT-LIMIT <IS Opt> <Integer> ! ----------------------------------------------------------------------------- ! SPECIAL-NAMES ! ----------------------------------------------------------------------------- <Special Names> ::= SPECIAL-NAMES '.' <Special Name List> <Special Name List> ::= <Special Name List> <Special Names Item> | !Zero or more <Special Names Item> ::= Identifier <IS Opt> Identifier <Name Status Items> '.' | Identifier <Name Status Items> '.' | SYMBOLIC <CHARACTERS Opt> <Symbolic Char List> '.' | ALPHABET Identifier <IS Opt> <Alphabet Item> '.' | CLASS Identifier <IS Opt> <Special Ranges> '.' | CURRENCY <SIGN Opt> <IS Opt> <Literal> '.' | DECIMAL-POINT <IS Opt> COMMA '.' <Name Status Items> ::= <Name Status Items> <Name Status Item> | !Zero or more <Name Status Item> ::= ON <STATUS Opt> <IS Opt> Identifier | OFF <STATUS Opt> <IS Opt> Identifier ! ----------------------------------------------- <Alphabet Item> ::= STANDARD-1 | STANDARD-2 | NATIVE | Identifier | <Special Ranges> <Special Ranges> ::= <Special Ranges> ALSO <Special Range> | <Special Range> <Special Range> ::= <Literal> <THRU> <Literal> ! ----------------------------------------------- <Symbolic Char List> ::= <Symbolic Characters> | <Symbolic Characters> IN Identifier <Symbolic Characters> ::= <Symbolic Character> <Symbolic Value> | <Symbolic Character> <Symbolic Character> ::= Identifier <IS ARE Opt> <Literal> ! ----------------------------------------------------------------------------- ! INPUT-OUTPUT SECTION ! ----------------------------------------------------------------------------- <Input-Output Section> ::= INPUT-OUTPUT SECTION '.' <File-Control> <I-O-Control> | !Optional ! ----------------------------------------------------------------------------- ! FILE-CONTROL ! ----------------------------------------------------------------------------- <File-Control> ::= FILE-CONTROL '.' <Select Block> | !Optional <Select Block> ::= <Select Block> <Select Paragraph> | !Optional <Select Paragraph> ::= SELECT <Optional Opt> Identifier ASSIGN <TO Opt> Identifier <Select Opt List> '.' <Optional Opt> ::= OPTIONAL | !Null <Select Opt List> ::= <Select Option> <Select Opt List> | !Zero or more <Select Option> ::= RESERVE <Integer> <AREA Opt> | ORGANIZATION <IS Opt> <Organization Kind> | <Organization Kind> | PADDING <Character Opt> <IS Opt> <Padding Kind> | RECORD DELIMITER <IS Opt> <Record Delimiter Kind> | RECORD <KEY Opt> <IS Opt> Identifier | ALTERNATIVE RECORD <KEY Opt> <IS Opt> Identifier <Duplicates Clause Opt> | ACCESS <MODE Opt> <IS Opt> <Access Mode> | <FILE Opt> STATUS <IS Opt> Identifier <Access Mode> ::= SEQUENTIAL | RANDOM | DYNAMIC <Organization Kind> ::= SEQUENTIAL | LINE SEQUENTIAL | RELATIVE <Relative Key Opt> | INDEXED <Relative Key Opt> ::= <KEY Opt> <IS Opt> Identifier | !Optional <Record Delimiter Kind> ::= STANDARD-1 | Identifier <Padding Kind> ::= Identifier | <Literal> <Duplicates Clause Opt> ::= <WITH Opt> DUPLICATES | !Optional ! ----------------------------------------------------------------------------- ! I-O CONTROL ! ----------------------------------------------------------------------------- <I-O-Control> ::= I-O-CONTROL '.' <Rerun List> <Same List> <Multiple List> '.' <Rerun List> ::= <Rerun List> <Rerun Item> | !Zero or more <Rerun Item> ::= RERUN <Rerun Clause Opt> <EVERY Opt> <Every Clause> <Rerun Clause Opt> ::= ON <File Name> | !Optional <Every Clause> ::= <End Of Opt> <Every End Target> <OF Opt> <File Name> | <Integer> RECORDS | <Integer> CLOCK-UNITS | Identifier <End Of Opt> ::= END <OF Opt> | !Optional <Every End Target> ::= REEL | UNIT ! ----------------------------------------------- <Same List> ::= <Same List> <Same Item> | !Zero or more <Same Item> ::= SAME <Same Source> <AREA Opt> <File Name> <File Name List> <Same Source> ::= RECORD | SORT | SORT-MERGE <Multiple List> ::= <Multiple List> <Multiple Item> | !Zero or more <Multiple Item> ::= MULTIPLE FILE <TAPE Opt> <CONTAINS Opt> <Contain List> <Contain List> ::= <Contain List> <Contain Item> | <Contain Item> <Contain Item> ::= <File Name> POSITION <IS Opt> <Integer> | <File Name> ! ----------------------------------------------------------------------------- ! ------------------------------ DATA DIVISION -------------------------------- ! ----------------------------------------------------------------------------- <Data Division> ::= DATA DIVISION '.' <Data Section List> <Data Section List> ::= <Data Section Entry> <Data Section List> | !Zero or more <Data Section Entry> ::= <File Section> | <Working-Storage Section> | <Linkage Section> | <Screen Section> | <Communication Section> | <Report Section> ! ----------------------------------------------------------------------------- ! Record Definition ! ----------------------------------------------------------------------------- <Record Entry Block> ::= <Record Entry Block> <Record Entry> | !Zero or more <Record Entry> ::= IntLiteral <Level Name> <Record Option List> '.' !Normal Record | '66' <Level Name> RENAMES <Identifier Range> '.' | '77' <Level Name> <Record Option List> '.' !Constant | '88' <Level Name> VALUES <IS ARE Opt> <Values> '.' <Level Name> ::= Identifier | FILLER <Times Opt> ::= TIMES | !Optional <Record Option List> ::= <Record Option List> <Record Option> | !Zero or more <Record Option> ::= REDEFINES Identifier | <IS Opt> EXTERNAL | <IS Opt> INTERNAL | <Picture> | USAGE <IS Opt> <Usage Args> | <Usage Args> | SIGN <IS Opt> <Sign Args> <Sep Char Option> | OCCURS <Numeric> <Times Opt> <Key Clause> <Index Clause> | OCCURS <Numeric> TO <Numeric> <Times Opt> DEPENDING <ON Opt> Identifier <Key Clause> <Index Clause> | SYNCHRONIZED <Left Right Opt> | SYNC <Left Right Opt> | JUSTIFIED <RIGHT Opt> | JUST <RIGHT Opt> | BLANK <WHEN Opt> ZERO | VALUE <IS Opt> <Symbolic Value> <Picture> ::= PicString <Key Clause> ::= ASCENDING <KEY Opt> <IS Opt> <Identifiers> | DESCENDING <KEY Opt> <IS Opt> <Identifiers> | !Optional <Usage Args> ::= BINARY | COMPUTATIONAL | COMP | DISPLAY | INDEX | PACKED-DECIMAL <Sign Args> ::= LEADING | TRAILING <Sep Char Option> ::= SEPARATE <Character Opt> | !Optional <Character Opt> ::= CHARACTER | !Optional <Left Right Opt> ::= LEFT | RIGHT | !Optional ! ----------------------------------------------------------------------------- ! FILE SECTION ! ----------------------------------------------------------------------------- <File Section> ::= FILE SECTION '.' <File Desc Block> <File Desc Block> ::= <File Desc Entry> <File Desc Block> | !Zero ore more <File Desc Entry> ::= FD Identifier <File Option List> '.' <Record Entry Block> | SD Identifier <File Option List> '.' <Record Entry Block> <File Option List> ::= <File Option List> <File Option> | !Zero or more <File Option> ::= <File Is Option> | <File Block Option> | <File Record Option> | <File Label Option> | <File Value Option> | <File Data Option> | <File Linage Option> | <File Code-Set Option> ! ----------------------------------------------------------------------------- ! Description Clauses ! ----------------------------------------------------------------------------- <File Is Option> ::= <IS Opt> EXTERNAL | <IS Opt> INTERNAL ! ----------------------------------------------- <File Block Option> ::= BLOCK <CONTAINS Opt> <Numeric> <File Block Units> | BLOCK <CONTAINS Opt> <Numeric> TO <Numeric> <File Block Units> <File Block Units> ::= RECORDS | CHARACTERS | !Optional - defaults to characters. ! ----------------------------------------------- <File Record Option> ::= RECORD <CONTAINS Opt> <Numeric> <CHARACTERS Opt> | RECORD <CONTAINS Opt> <Numeric> TO <Numeric> <CHARACTERS Opt> | RECORD <IS Opt> VARYING <IN Opt> <SIZE Opt> <File Record Size Clause> <File Record Depending Clause> <File Record Size Clause> ::= FROM <Numeric> <CHARACTERS Opt> | TO <Numeric> <CHARACTERS Opt> | FROM <Numeric> TO <Numeric> <CHARACTERS Opt> | !Optional <File Record Depending Clause> ::= DEPENDING <ON Opt> Identifier | !Optional ! ----------------------------------------------- <File Label Option> ::= LABEL RECORD <IS Opt> <File Label Type> | LABEL RECORDS <IS Opt> <File Label Type> <File Label Type> ::= STANDARD | OMITTED ! ----------------------------------------------- <File Value Option> ::= VALUE OF <File Value List> <File Value List> ::= <File Value List> <File Value Item> | <File Value Item> <File Value Item> ::= Identifier <IS Opt> Identifier | Identifier <IS Opt> <Literal> ! ----------------------------------------------- <File Data Option> ::= DATA RECORD <IS Opt> <Identifiers> | DATA RECORDS <ARE Opt> <Identifiers> ! ----------------------------------------------- <File Linage Option> ::= LINAGE <IS Opt> <Int Constant> <LINES Opt> <File Linage Footing> <File Linage Top> <File Linage Bottom> <File Linage Footing> ::= <WITH Opt> FOOTING <AT Opt> <Int Constant> ! Optional <File Linage Top> ::= <LINES Opt> <AT Opt> TOP <Int Constant> ! Optional <File Linage Bottom> ::= <LINES Opt> <AT Opt> BOTTOM <Int Constant> ! Optional ! ----------------------------------------------- <File Code-Set Option> ::= CODE-SET <IS Opt> Identifier ! ----------------------------------------------------------------------------- ! WORKING-STORAGE SECTION ! ----------------------------------------------------------------------------- <Working-Storage Section> ::= WORKING-STORAGE SECTION '.' <Record Entry Block> ! ----------------------------------------------------------------------------- ! LINKAGE SECTION ! ----------------------------------------------------------------------------- <Linkage Section> ::= LINKAGE SECTION '.' <Record Entry Block> ! ----------------------------------------------------------------------------- ! SCREEN SECTION ! ----------------------------------------------------------------------------- <Screen Section> ::= SCREEN SECTION '.' <Screen Field List> <Screen Field List> ::= <Screen Field> <Screen Field List> | <Screen Field> <Screen Field> ::= <Integer> <Field Name opt> <Field Def List> '.' <Field Name opt> ::= Identifier | !Optional <Field Def List> ::= <Field Def List> <Field Def Item> | !Optional <Field Def Item> ::= LINE <Numeric> | COLUMN <Numeric> | FOREGROUND-COLOR <Numeric> | BACKGROUND-COLOR <Numeric> | VALUE <IS Opt> <Symbolic Value> | <Picture> | FROM Identifier | USING Identifier | HIGHLIGHT | REVERSE-VIDEO | BLINK | UNDERLINE | BLANK SCREEN ! ----------------------------------------------------------------------------- ! COMMUNICATION SECTION ! ----------------------------------------------------------------------------- <Communication Section> ::= COMMUNICATION SECTION '.' <Comm Desc List> <Comm Desc List> ::= <Comm Desc List> <Comm Desc> | !Zero or more <Comm Desc> ::= CD Identifier <FOR Opt> <INITIAL Opt> INPUT <Comm Input Body> '.' <Record Entry Block> | CD Identifier <FOR Opt> OUTPUT <Comm Output Options> '.' <Record Entry Block> | CD Identifier <FOR Opt> <INITIAL Opt> I-O <Comm I-O Body> '.' <Record Entry Block> <Comm Input Body> ::= <Identifiers> | <Comm Input Options> <Comm Input Options> ::= <Comm Input Options> <Comm Input Option> | !Zero ore more <Comm Input Option> ::= <SYMBOLIC Opt> QUEUE <IS Opt> Identifier | <SYMBOLIC Opt> SUB-QUEUE-1 <IS Opt> Identifier | <SYMBOLIC Opt> SUB-QUEUE-2 <IS Opt> Identifier | <SYMBOLIC Opt> SUB-QUEUE-3 <IS Opt> Identifier | MESSAGE DATE <IS Opt> Identifier | MESSAGE TIME <IS Opt> Identifier | <SYMBOLIC Opt> SOURCE <IS Opt> Identifier | TEXT LENGTH <IS Opt> <Numeric> | END KEY <IS Opt> Identifier | STATUS KEY <IS Opt> Identifier | MESSAGE COUNT <IS Opt> Identifier <Comm Output Options> ::= <Comm Output Options> <Comm Output Option> | !Zero or more <Comm Output Option> ::= DESTINATION TABLES OCCURS <Numeric> <TIMES Opt> <Index Clause> | DESTINATION COUNT <IS Opt> Identifier | TEXT LENGTH <IS Opt> Identifier | STATUS KEY <IS Opt> Identifier | ERROR KEY <IS Opt> Identifier | SYMBOLIC DESTINATION <IS Opt> Identifier | DESTINATION <IS Opt> Identifier <Comm I-O Body> ::= <Identifiers> | <Comm I-O Options> <Comm I-O Options> ::= <Comm I-O Options> <Comm I-O Option> | !Zero or more <Comm I-O Option> ::= MESSAGE DATE <IS Opt> Identifier | MESSAGE TIME <IS Opt> Identifier | <SYMBOLIC Opt> TERMINAL <IS Opt> Identifier | TEXT LENGTH <IS Opt> <Numeric> | END KEY <IS Opt> Identifier | STATUS KEY <IS Opt> Identifier ! ----------------------------------------------------------------------------- ! REPORT SECTION ! ----------------------------------------------------------------------------- <Report Section> ::= REPORT SECTION '.' <Report Desc List> <Report Desc List> ::= <Report Desc List> <Report Desc> | !Zero or more <Report Desc> ::= RD Identifier <Report Options> <Report Entry Block> <Report Options> ::= <Report Options> <Report Option> | !Zero or more <Report Option> ::= <IS Opt> GLOBAL | CODE <Literal> | <CONTROL IS> <FINAL Opt> <Identifiers> | PAGE <LIMITS IS Opt> <Numeric> <LINES Opt> <Report Heading Opt> <CONTROL IS> ::= CONTROL IS | CONTROLS ARE <LIMITS IS Opt> ::= LIMIT IS | LIMITS ARE | !Optional <Report Heading Opt> ::= HEADING <Integer> | !Optional <Report Entry Block> ::= <Report Entry Block> <Report Entry> | !Zero or more <Report Entry> ::= <Integer> Identifier <Report Entry Options> '.' <Report Entry Options> ::= <Report Entry Option> <Report Entry Options> | !Zero or more <Report Entry Option> ::= LINE <NUMBER Opt> <IS Opt> <Numeric> | LINE <NUMBER Opt> <IS Opt> <Numeric> ON NEXT PAGE !Same as above | LINE <NUMBER Opt> <IS Opt> PLUS <Numeric> | NEXT GROUP <IS Opt> <Report Entry Next Group> | TYPE <IS Opt> <Report Entry Type> | USAGE <IS Opt> DISPLAY | DISPLAY | <Picture> | SIGN <IS Opt> <Sign Args> <Sep Char Option> | JUSTIFIED <RIGHT Opt> | JUST <RIGHT Opt> | BLANK <WHEN Opt> ZERO | COLUMN <Number Opt> <IS Opt> <Numeric> | SOURCE <IS Opt> <Numeric> | VALUE <IS Opt> <Symbolic Value> | SUM <Identifiers> | SUM <Identifiers> UPON <Identifiers> <Report Entry Result Clause> | GROUP <INDICATE Opt> <Report Entry Next Group> ::= <Numeric> | PLUS <Numeric> | NEXT PAGE <Report Entry Type> ::= REPORT HEADING | RH !Report Heading | PAGE HEADING | PH !Page Heading | CONTROL HEADING | CH !Control Heading | DETAIL | DE !Detail | CONTROL FOOTING | CF !Control Footing | PAGE FOOTING | PF !Page Footing | REPORT FOOTING | RF !Report Footing <Report Entry Result Clause> ::= RESET <ON Opt> Identifier | RESET <ON Opt> FINAL | !Optional ! ------------------------------------------------------------------------------ ! --------------------------- PROCEDURE DIVISION ------------------------------- ! ------------------------------------------------------------------------------ <Procedure Division> ::= PROCEDURE DIVISION <Using Clause Opt> <Declarative Block> '.' <Paragraphs> <Using Clause Opt> ::= USING <Identifiers> | !Optional <Paragraphs> ::= <Paragraphs> <Paragraph> | !Zero or more <Paragraph> ::= Identifier SECTION '.' Identifier '.' <Sentences> | Identifier '.' <Sentences> ! ----------------------------------------------------------------------------- ! Declaratives ! ----------------------------------------------------------------------------- <Declarative Block> ::= DECLARATIVES '.' <Declarative Sections> END DECLARATIVES '.' !No dash - inconsistent | !Optional <Declarative Sections> ::= <Declarative Sections> <Declarative Section> | !Zero or more <Declarative Section> ::= Identifier SECTION '.' USE <BEFORE AFTER> <STANDARD Opt> ERROR PROCEDURE ON <Error Cause> '.' <Sentences> | Identifier '.' <Sentences> <Error Cause> ::= Identifier | INPUT | OUTPUT | I-O | EXTEND ! ----------------------------------------------------------------------------- ! Shared by sentences ! ----------------------------------------------------------------------------- <Sort Keys> ::= <Sort Keys> <Sort Key> | <Sort Key> <Sort Key> ::= <ON Opt> ASCENDING <KEY Opt> Identifier | <ON Opt> DESCENDING <KEY Opt> Identifier <Collating Clause> ::= <COLLATING Opt> SEQUENCE <IS Opt> Identifier | !Optional <Sort Source> ::= INPUT PROCEDURE <IS Opt> <Identifier Range> | USING <Values> <Sort Target> ::= OUTPUT PROCEDURE <IS Opt> <Identifier Range> | GIVING <Values> <Identifier Range> ::= Identifier | Identifier THRU Identifier | Identifier THROUGH Identifier <Enabled Disable Mode> ::= INPUT | INPUT TERMINAL | I-O TERMINAL | OUTPUT <Enable Disable Key> ::= <WITH Opt> KEY <Value> | !Optional ! ----------------------------------------------------------------------------- ! Boolean Expressions ! ----------------------------------------------------------------------------- ! Note: <Not Opt> is very significant in the operators below <Boolean Exp> ::= <Boolean Exp> OR <And Exp> | <And Exp> <And Exp> ::= <Negation Exp> And <And Exp> | <Negation Exp> <Negation Exp> ::= <Compare Exp> | NOT <Compare Exp> !<And Exp> ! ::= <And Exp> AND <Compare Exp> ! | <Compare Exp> <Compare Exp> ::= <Symbolic Value> <Compare Op> <Symbolic Value> | <Symbolic Value> IS ALPHABETIC | <Symbolic Value> IS ALPHABETIC-UPPER | <Symbolic Value> IS ALPHABETIC-LOWER | '(' <Boolean Exp> ')' | <Symbolic Value> <Compare Op> ::= <IS ARE Opt> <Greater Op> | <IS ARE Opt> NOT <Greater Op> | <IS ARE Opt> <Greater Eq Op> | <IS ARE Opt> NOT <Greater Eq Op> | <IS ARE Opt> <Less Op> | <IS ARE Opt> NOT <Less Op> | <IS ARE Opt> <Less Eq Op> | <IS ARE Opt> NOT <Less Eq Op> | <IS ARE Opt> <Equal Op> | <IS ARE Opt> NOT <Equal Op> <Greater Op> ::= GREATER <THAN Opt> | '>' <Greater Eq Op> ::= GREATER <THAN Opt> OR EQUAL <TO Opt> | '>=' <Less Op> ::= LESS <THAN Opt> | '<' <Less Eq Op> ::= LESS <THAN Opt> OR EQUAL <TO Opt> | '<=' <Equal Op> ::= EQUAL <TO Opt> | '=' ! ----------------------------------------------------------------------------- ! Sentences ! ----------------------------------------------------------------------------- ! If you add statements to the grammar, make sure to update the corresponding ! <Statement> rules below <Sentences> ::= <Sentence> <Sentences> | !Zero or more <Sentence> ::= <Sent Stm> '.' <Sent Stm> ::= <Accept Sent> | <Add Sent> | <Alter Sent> | <Call Sent> | <Cancel Sent> | <Close Sent> | <Compute Sent> | <Continue Sent> | <Delete Sent> | <Disable Sent> | <Display Sent> | <Divide Sent> | <Enable Sent> | <Evaluate Sent> | <Exit Sent> | <Generate Sent> | <Go To Sent> | <If Sent> | <Initialize Sent> | <Initiate Sent> | <Inspect Sent> | <Merge Sent> | <Move Sent> | <Multiply Sent> | <Open Sent> | <Perform Sent> | <Read Sent> | <Release Sent> | <Return Sent> | <Rewrite Sent> | <Search Sent> | <Send Sent> | <Set Sent> | <Sort Sent> | <Start Sent> | <Stop Sent> | <String Sent> | <Subtract Sent> | <Suppress Sent> | <Terminate Sent> | <Unstring Sent> | <Use Sent> | <Write Sent> <Embed Stms> ::= <Embed Stms> <Embed Stm> | <Embed Stm> <Embed Stm> ::= <Accept Embed> | <Add Embed> | <Alter Embed> | <Call Embed> | <Cancel Embed> | <Close Embed> | <Compute Embed> | <Continue Embed> | <Delete Embed> | <Disable Embed> | <Display Embed> | <Divide Embed> | <Enable Embed> | <Evaluate Embed> | <Exit Embed> | <Generate Embed> | <Go To Embed> | <If Embed> | <Initialize Embed> | <Initiate Embed> | <Inspect Embed> | <Merge Embed> | <Move Embed> | <Multiply Embed> | <Open Embed> | <Perform Embed> | <Read Embed> | <Release Embed> | <Return Embed> | <Rewrite Embed> | <Search Embed> | <Send Embed> | <Set Embed> | <Sort Embed> | <Start Embed> | <Stop Embed> | <String Embed> | <Subtract Embed> | <Suppress Embed> | <Terminate Embed> | <Unstring Embed> | <Use Embed> | <Write Embed> <Imperative Stms> ::= <Imperative Stms> <Imperative Stm> | <Imperative Stm> <Imperative Stm> ::= <Accept Imp> | <Add Imp> | <Alter Imp> | <Call Imp> | <Cancel Imp> | <Close Imp> | <Compute Imp> | <Continue Imp> | <Delete Imp> | <Disable Imp> | <Display Imp> | <Divide Imp> | <Enable Imp> | <Evaluate Imp> | <Exit Imp> | <Generate Imp> | <Go To Imp> | <If Imp> | <Initialize Imp> | <Initiate Imp> | <Inspect Imp> | <Merge Imp> | <Move Imp> | <Multiply Imp> | <Open Imp> | <Perform Imp> | <Read Imp> | <Release Imp> | <Return Imp> | <Rewrite Imp> | <Search Imp> | <Send Imp> | <Set Imp> | <Sort Imp> | <Start Imp> | <Stop Imp> | <String Imp> | <Subtract Imp> | <Suppress Imp> | <Terminate Imp> | <Unstring Imp> | <Use Imp> | <Write Imp> ! ----------------------------------------------------------------------------- ! Exception Handling ! ----------------------------------------------------------------------------- <Size Clauses> ::= <Size Clauses> <Size Clause> | <Size Clause> <Size Clause> ::= <ON Opt> SIZE ERROR <Imperative Stms> | NOT <ON Opt> SIZE ERROR <Imperative Stms> !----------------------------------------- <Invalid Key Clauses> ::= <Invalid Key Clauses> <Invalid Key Clause> | <Invalid Key Clause> <Invalid Key Clause> ::= INVALID <KEY Opt> <Imperative Stms> | NOT INVALID <KEY Opt> <Imperative Stms> !----------------------------------------- <Exception Clauses> ::= <Exception Clauses> <Exception Clause> | <Exception Clause> <Exception Clause> ::= <ON Opt> EXCEPTION <Imperative Stms> | NOT <ON Opt> EXCEPTION <Imperative Stms> !----------------------------------------- <Overflow Clauses> ::= <Overflow Clauses> <Overflow Clause> | <Overflow Clause> <Overflow Clause> ::= <ON Opt> OVERFLOW <Imperative Stms> | NOT <ON Opt> OVERFLOW <Imperative Stms> !----------------------------------------- <At End Clauses> ::= <At End Clauses> <At End Clause> | <At End Clause> <At End Clause> ::= AT END <Imperative Stms> | NOT AT END <Imperative Stms> !----------------------------------------- <AT EOP Clauses> ::= <AT EOP Clauses> <AT EOP Clause> | <AT EOP Clause> <AT EOP Clause> ::= AT <End of Page> <Imperative Stms> | NOT AT <End of Page> <Imperative Stms> <End of Page> ::= END-OF-PAGE | EOP ! ----------------------------------------------------------------------------- ! ACCEPT Statement ! ----------------------------------------------------------------------------- <Accept Sent> ::= <Accept Stm> <Accept Embed> ::= <Accept Stm> <Accept Imp> ::= <Accept Stm> <Accept Stm> ::= ACCEPT Identifier | ACCEPT Identifier FROM <Accept From Arg> | ACCEPT Identifier <MESSAGE opt> COUNT !CD <Accept From Arg> ::= FROM DATE | FROM DAY | FROM DAY-OF-WEEK | FROM TIME | FROM CONSOLE | FROM Identifier | !Optional ! ----------------------------------------------------------------------------- ! ADD Statement ! ----------------------------------------------------------------------------- <Add Sent> ::= <Add Stm> <Size Clauses> <END-ADD Opt> | <Add Stm> <Add Embed> ::= <Add Stm> <Size Clauses> 'END-ADD' | <Add Stm> <Add Imp> ::= <Add Stm> <Add Stm> ::= ADD <Values> TO <Add Items> <Giving Clause> | ADD <CORRESPONDING> Identifier TO Identifier <ROUNDED Opt> <Giving Clause> ::= GIVING <Add Item> | !Optional <Add Items> ::= <Add Items> <Add Item> | <Add Item> <Add Item> ::= <Variable> <ROUNDED Opt> <END-ADD Opt> ::= END-ADD | !Optional ! ----------------------------------------------------------------------------- ! ALTER Statement ! ----------------------------------------------------------------------------- <Alter Sent> ::= <Alter Stm> <Alter Embed> ::= <Alter Stm> <Alter Imp> ::= <Alter Stm> <Alter Stm> ::= ALTER Identifier TO Identifier | ALTER Identifier TO PROCEED TO Identifier ! ----------------------------------------------------------------------------- ! CALL Statement ! ----------------------------------------------------------------------------- !Call can call just about anything, it depends on the system. <Call Sent> ::= <Call Stm> <Exception Clauses> <END-CALL Opt> | <Call Stm> <Overflow Clauses> <END-CALL Opt> | <Call Stm> <Call Embed> ::= <Call Stm> <Exception Clauses> END-CALL | <Call Stm> <Overflow Clauses> END-CALL | <Call Stm> <Call Imp> ::= <Call Stm> <Call Stm> ::= CALL <Value> | CALL <Value> USING <Call Items> <Call Items> ::= <Call Items> <Call Item> | <Call Item> <Call Item> ::= <Variable> | <BY Opt> REFERENCE <Variable> !default | <BY Opt> CONTENT <Variable> <END-CALL Opt> ::= END-CALL | !Optional ! ----------------------------------------------------------------------------- ! CANCEL Statement ! ----------------------------------------------------------------------------- <Cancel Sent> ::= <Cancel Stm> <Cancel Embed> ::= <Cancel Stm> <Cancel Imp> ::= <Cancel Stm> <Cancel Stm> ::= CANCEL <Values> ! ----------------------------------------------------------------------------- ! CLOSE Statement ! ----------------------------------------------------------------------------- <Close Sent> ::= <Close Stm> <Close Embed> ::= <Close Stm> <Close Imp> ::= <Close Stm> <Close Stm> ::= CLOSE <Close Items> <Close Items> ::= <Close Items> <Close Item> | <Close Item> <Close Item> ::= Identifier <Close Options> <Close Options> ::= UNIT <Close Method> | REEL <Close Method> | <WITH Opt> LOCK | <WITH Opt> NO REWIND | !Empty <Close Method> ::= <FOR Opt> REMOVAL | !Optional ! ----------------------------------------------------------------------------- ! COMPUTE Statement ! ----------------------------------------------------------------------------- <Compute Sent> ::= <Compute Stm> <Size Clauses> <END-COMPUTE Opt> | <Compute Stm> <Compute Embed> ::= <Compute Stm> <Size Clauses> END-COMPUTE | <Compute Stm> <Compute Imp> ::= <Compute Stm> <Compute Stm> ::= COMPUTE Identifier <ROUNDED Opt> <Equal Op> <Math Exp> <Math Exp> ::= <Math Exp> '+' <Mult Exp> | <Math Exp> '-' <Mult Exp> | <Mult Exp> <Mult Exp> ::= <Mult Exp> '*' <Negate Exp> | <Mult Exp> '/' <Negate Exp> | <Negate Exp> <Negate Exp> ::= '-' <Value> | <Value> | '(' <Math Exp> ')' <END-COMPUTE Opt> ::= END-COMPUTE | !Optional ! ----------------------------------------------------------------------------- ! CONTINUE ! ----------------------------------------------------------------------------- <Continue Sent> ::= <Continue Stm> <Continue Embed> ::= <Continue Stm> <Continue Imp> ::= <Continue Stm> <Continue Stm> ::= CONTINUE ! ----------------------------------------------------------------------------- ! DELETE Statement ! ----------------------------------------------------------------------------- <Delete Sent> ::= <Delete Stm> <Invalid Key Clauses> <END-DELETE Opt> | <Delete Stm> <Delete Embed> ::= <Delete Stm> <Invalid Key Clauses> END-DELETE | <Delete Stm> <Delete Imp> ::= <Delete Stm> <Delete Stm> ::= DELETE Identifier <RECORD Opt> <END-DELETE Opt> ::= END-DELETE | !Optional ! ----------------------------------------------------------------------------- ! DISABLE Statement ! ----------------------------------------------------------------------------- <Disable Sent> ::= <Disable Stm> <Disable Embed> ::= <Disable Stm> <Disable Imp> ::= <Disable Stm> <Disable Stm> ::= DISABLE <Enabled Disable Mode> Identifier <Enable Disable Key> ! ----------------------------------------------------------------------------- ! DISPLAY Statement ! ----------------------------------------------------------------------------- <Display Sent> ::= <Display Stm> <Display Embed> ::= <Display Stm> <Display Imp> ::= <Display Stm> <Display Stm> ::= DISPLAY <Values> <Display Target> <Advancing Clause> <Display Target> ::= UPON Identifier | !Optional <Advancing Clause> ::= <WITH Opt> NO ADVANCING | !Optional ! ----------------------------------------------------------------------------- ! DIVIDE Statement ! ----------------------------------------------------------------------------- <Divide Sent> ::= <Divide Stm> <Size Clauses> <END-DIVIDE Opt> | <Divide Stm> <Divide Embed> ::= <Divide Stm> <Size Clauses> 'END-DIVIDE' | <Divide Stm> <Divide Imp> ::= <Divide Stm> <Divide Stm> ::= DIVIDE <Values> BY <Values> | DIVIDE <Values> BY <Values> GIVING <Variable> <ROUNDED Opt> | DIVIDE <Values> INTO <Values> | DIVIDE <Values> INTO <Values> GIVING <Variable> <ROUNDED Opt> <Remainder Opt> <Remainder Opt> ::= REMAINDER <Variable> | !Optional <END-DIVIDE Opt> ::= END-DIVIDE | !Optional ! ----------------------------------------------------------------------------- ! ENABLE Statement ! ----------------------------------------------------------------------------- <Enable Sent> ::= <Enable Stm> <Enable Embed> ::= <Enable Stm> <Enable Imp> ::= <Enable Stm> <Enable Stm> ::= ENABLE <Enabled Disable Mode> Identifier <Enable Disable Key> ! ----------------------------------------------------------------------------- ! EVALUATE Statement ! ----------------------------------------------------------------------------- <Evaluate Sent> ::= <Evaluate Stm> <END-EVALUATE Opt> <Evaluate Embed> ::= <Evaluate Stm> END-EVALUATE <Evaluate Imp> ::= <Evaluate Stm> END-EVALUATE <Evaluate Stm> ::= EVALUATE <Subjects> <When Clauses> <Subjects> ::= <Subjects> ALSO <Subject> | <Subject> <Subject> ::= TRUE | <Boolean Exp> <When Clauses> ::= <When Clauses> <When Clause> | <When Clause> <When Clause> ::= WHEN <Phrases> <THEN Opt> <Embed Stms> | WHEN OTHER <THEN Opt> <Embed Stms> <Phrases> ::= <Phrases> ALSO <Phrase> | <Phrase> <Phrase> ::= ANY | <Symbolic Value> THROUGH <Symbolic Value> | <Symbolic Value> THRU <Symbolic Value> | <Symbolic Value> <END-EVALUATE Opt> ::= END-EVALUATE | !Optional ! ----------------------------------------------------------------------------- ! EXIT Statement ! ----------------------------------------------------------------------------- <Exit Sent> ::= <Exit Stm> <Exit Embed> ::= <Exit Stm> <Exit Imp> ::= <Exit Stm> <Exit Stm> ::= EXIT | EXIT PROGRAM ! ----------------------------------------------------------------------------- ! GENERATE Statement ! ----------------------------------------------------------------------------- <Generate Sent> ::= <Generate Stm> <Generate Embed> ::= <Generate Stm> <Generate Imp> ::= <Generate Stm> <Generate Stm> ::= GENERATE Identifier ! ----------------------------------------------------------------------------- ! GO TO Statement ! ----------------------------------------------------------------------------- <Go To Sent> ::= <Go To Stm> <Go To Embed> ::= <Go To Stm> <Go To Imp> ::= <Go To Stm> <Go To Stm> ::= GO TO Identifier | GO TO <Identifiers> DEPENDING ON <Variable> ! ----------------------------------------------------------------------------- ! IF Statement ! ----------------------------------------------------------------------------- <If Sent> ::= <If Stm> <END-IF Opt> <If Embed> ::= <If Stm> END-IF <If Imp> ::= <If Stm> END-IF <If Stm> ::= IF <Boolean Exp> <THEN Opt> <Embed Stms> | IF <Boolean Exp> <THEN Opt> <Embed Stms> ELSE <THEN Opt> <Embed Stms> | IF <Boolean Exp> <THEN Opt> <Embed Stms> ELSE NEXT SENTENCE <END-IF Opt> ::= END-IF | !Optional ! ----------------------------------------------------------------------------- ! INITIALIZE Statement ! ----------------------------------------------------------------------------- <Initialize Sent> ::= <Initialize Stm> <Initialize Embed> ::= <Initialize Stm> <Initialize Imp> ::= <Initialize Stm> <Initialize Stm> ::= INITIALIZE <Variables> <Replacing Opt> <Replacing Opt> ::= REPLACING <Replacing Items> <Replacing Items> ::= <Replacing Items> <Replacing Item> | <Replacing Item> <Replacing Item> ::= <Replacing Type> <DATA Opt> <Value> <Replacing Type> ::= ALPHABETIC | ALPHANUMERIC | NUMERIC | ALPHANUMERIC-EDITED | NUMERIC-EDITED ! ----------------------------------------------------------------------------- ! INITIATE Statement ! ----------------------------------------------------------------------------- <Initiate Sent> ::= <Initiate Stm> <Initiate Embed> ::= <Initiate Stm> <Initiate Imp> ::= <Initiate Stm> <Initiate Stm> ::= INITIATE <Identifiers> ! ----------------------------------------------------------------------------- ! INSPECT Statement ! ----------------------------------------------------------------------------- <Inspect Sent> ::= <Inspect Stm> <Inspect Embed> ::= <Inspect Stm> <Inspect Imp> ::= <Inspect Stm> <Inspect Stm> ::= INSPECT <Variable> TALLYING <Tally Variables> | INSPECT <Variable> TALLYING <Tally Variables> REPLACING <Replace Chars> | INSPECT <Variable> REPLACING <Replace Chars> | INSPECT <Variable> CONVERTING <Value> TO <Value> <Inspect Specs> ! ----------------------------------- Tally group <Tally Variables> ::= <Tally Variables> <Tally Variable> | <Tally Variable> <Tally Variable> ::= <Variable> FOR <Tally Items> <Tally Items> ::= <Tally Items> <Tally Item> | <Tally Item> <Tally Item> ::= CHARACTERS <Inspect Specs> | ALL <Value> <Inspect Specs> | LEADING <Value> <Inspect Specs> ! ----------------------------------- Replacing group <Replace Chars> ::= <Replace Chars> <Replace Char> | <Replace Char> <Replace Char> ::= CHARACTERS BY <Value> <Inspect Specs> | ALL <Replace Items> | LEADING <Replace Items> | FIRST <Replace Items> <Replace Items> ::= <Replace Items> <Replace Item> | <Replace Item> <Replace Item> ::= <Value> BY <Value> <Inspect Specs> ! ----------------------------------- Substring Specifiers <Inspect Specs> ::= <Inspect Specs> <Inspect Spec> | !Zero or more <Inspect Spec> ::= <BEFORE AFTER> INITIAL <Value> ! ----------------------------------------------------------------------------- ! MERGE Statement ! ----------------------------------------------------------------------------- <Merge Sent> ::= <Merge Stm> <Merge Embed> ::= <Merge Stm> <Merge Imp> ::= <Merge Stm> <Merge Stm> ::= MERGE Identifier <Sort Keys> <Collating Clause> USING <Identifiers> <Sort Target> ! ----------------------------------------------------------------------------- ! MOVE Statement ! ----------------------------------------------------------------------------- <Move Sent> ::= <Move Stm> <Size Clauses> <END-MOVE Opt> | <Move Stm> <Move Embed> ::= <Move Stm> <Size Clauses> END-MOVE | <Move Stm> <Move Imp> ::= <Move Stm> <Move Stm> ::= MOVE <Symbolic Value> TO <Variables> | MOVE <CORRESPONDING> Identifier TO Identifier <END-MOVE Opt> ::= END-MOVE | !Optional ! ----------------------------------------------------------------------------- ! MULTIPLY Statement ! ----------------------------------------------------------------------------- <Multiply Sent> ::= <Multiply Stm> <Size Clauses> <END-MULTIPLY Opt> | <Multiply Stm> <Multiply Embed> ::= <Multiply Stm> <Size Clauses> END-MULTIPLY | <Multiply Stm> <Multiply Imp> ::= <Multiply Stm> <Multiply Stm> ::= MULTIPLY <Variables> BY <Multiply Items> <Giving Clause Opt> <Multiply Items> ::= <Multiply Items> <Multiply Item> | <Multiply Item> <Multiply Item> ::= <Value> <ROUNDED Opt> <END-MULTIPLY Opt> ::= END-MULTIPLY | !Optional ! ----------------------------------------------------------------------------- ! OPEN Statement ! ----------------------------------------------------------------------------- <Open Sent> ::= <Open Stm> <Open Embed> ::= <Open Stm> <Open Imp> ::= <Open Stm> <Open Stm> ::= OPEN <Open List> <Open List> ::= <Open List> <Open Entry> | <Open Entry> <Open Entry> ::= INPUT <Variables> <Open No Rewind> | OUTPUT <Variables> <Open No Rewind> | EXTEND <Variables> <Open No Rewind> | I-O <Variables> <Open No Rewind> <Open No Rewind> ::= <WITH Opt> NO REWIND | !Optional ! ----------------------------------------------------------------------------- ! PERFORM Statement ! ----------------------------------------------------------------------------- <Perform Sent> ::= <Perform Block> <END-PERFORM Opt> | <Perform Stm> | <Perform Loop> <Perform Embed> ::= <Perform Block> END-PERFORM | <Perform Stm> | <Perform Loop> <Perform Imp> ::= <Perform Block> END-PERFORM | <Perform Stm> <Perform Stm> ::= PERFORM <Identifier Range> | PERFORM <Identifier Range> <Numeric> TIMES <Perform Loop> ::= PERFORM <Identifier Range> <With Test> UNTIL <Boolean Exp> | PERFORM <Identifier Range> <With Test> VARYING <Perform For List> <Perform Block> ::= PERFORM <With Test> UNTIL <Boolean Exp> <Embed Stms> | PERFORM <With Test> VARYING <Perform For List> <Embed Stms> | PERFORM <Numeric> TIMES <Embed Stms> <With Test> ::= <WITH Opt> TEST <BEFORE AFTER> | !Optional <Perform For List> ::= <Perform For List> AFTER <Perform For Range> | <Perform For Range> <Perform For Range> ::= <Variable> FROM <Numeric> BY <Numeric> UNTIL <Boolean Exp> <END-PERFORM Opt> ::= END-PERFORM | !Optional ! ----------------------------------------------------------------------------- ! READ Statement ! ----------------------------------------------------------------------------- <Read Sent> ::= <Read Stm> <Read Msg Clauses> <END-READ Opt> | <Read Stm> <Read Embed> ::= <Read Stm> <Read Msg Clauses> END-READ | <Read Stm> <Read Imp> ::= <Read Stm> <Read Stm> ::= READ Identifier <Next Opt> <RECORD Opt> | READ Identifier <Next Opt> <RECORD Opt> INTO <Variable> <Read Key Opt> <Read Msg Clauses> ::= <At End Clauses> | <Invalid Key Clauses> <Read Key Opt> ::= KEY <IS Opt> Identifier | !Optional <END-READ Opt> ::= END-READ | !Optional ! ----------------------------------------------------------------------------- ! RELEASE Statement ! ----------------------------------------------------------------------------- <Release Sent> ::= <Release Stm> <Release Embed> ::= <Release Stm> <Release Imp> ::= <Release Stm> <Release Stm> ::= RELEASE Identifier | RELEASE Identifier FROM Identifier ! ----------------------------------------------------------------------------- ! RETURN Statement ! ----------------------------------------------------------------------------- <Return Sent> ::= <Return Stm> <Return Embed> ::= <Return Stm> <Return Imp> ::= <Return Stm> <Return Stm> ::= RETURN Identifier <RECORD Opt> | RETURN Identifier <RECORD Opt> INTO Identifier ! ----------------------------------------------------------------------------- ! REWRITE Statement ! ----------------------------------------------------------------------------- <Rewrite Sent> ::= <Rewrite Stm> <Invalid Key Clauses> <END-REWRITE Opt> | <Rewrite Stm> <Rewrite Embed> ::= <Rewrite Stm> <Invalid Key Clauses> END-REWRITE | <Rewrite Stm> <Rewrite Imp> ::= <Rewrite Stm> <Rewrite Stm> ::= REWRITE Identifier | REWRITE Identifier FROM Identifier <END-REWRITE Opt> ::= END-REWRITE | !Optional ! ----------------------------------------------------------------------------- ! SEARCH Statement ! ----------------------------------------------------------------------------- <Search Sent> ::= <Search Stm> <END-SEARCH Opt> <Search Embed> ::= <Search Stm> END-SEARCH <Search Imp> ::= <Search Stm> END-SEARCH <Search Stm> ::= SEARCH Identifier <Varying Opt> <At End Clauses> <When Clauses> | SEARCH ALL Identifier <At End Clauses> <When Clauses> <Varying Opt> ::= VARYING <Value> | !Optional <END-SEARCH Opt> ::= END-SEARCH | !Optional ! ----------------------------------------------------------------------------- ! SEND Statement ! ----------------------------------------------------------------------------- <Send Sent> ::= <Send Stm> <Send Embed> ::= <Send Stm> <Send Imp> ::= <Send Stm> <Send Stm> ::= SEND Identifier FROM <Variable> | SEND Identifier FROM <Variable> <Send With> <Send Spec> <Send Replacing Opt> | SEND Identifier <Send With> <Send Spec> <Send Replacing Opt> <Send With> ::= <WITH Opt> Identifier | <WITH Opt> ESI | <WITH Opt> EMI | <WITH Opt> EGI <Send Spec> ::= <BEFORE AFTER> <ADVANCING Opt> <Send Advance> <Send Advance> ::= <Value> <LINES Opt> | PAGE <Send Replacing Opt> ::= REPLACING <LINE Opt> ! ----------------------------------------------------------------------------- ! SET Statement ! ----------------------------------------------------------------------------- <Set Sent> ::= <Set Stm> <Set Embed> ::= <Set Stm> <Set Imp> ::= <Set Stm> <Set Stm> ::= SET <Variables> UP BY <Value> | SET <Variables> DOWN BY <Value> | SET <Variables> TO <Set Value> <Set Value> ::= ON | OFF | TRUE ! ----------------------------------------------------------------------------- ! SORT Statement ! ----------------------------------------------------------------------------- <Sort Sent> ::= <Sort Stm> <Sort Embed> ::= <Sort Stm> <Sort Imp> ::= <Sort Stm> <Sort Stm> ::= SORT <Value> <Sort Keys> <Sort Duplicates Opt> <Collating Opt> <Sort Source> <Sort Target> <Sort Duplicates Opt> ::= <WITH Opt> DUPLICATES <IN Opt> <ORDER opt> | !Optional ! ----------------------------------------------------------------------------- ! START Statement ! ----------------------------------------------------------------------------- <Start Sent> ::= <Start Stm> <Invalid Key Clauses> <END-START Opt> | <Start Stm> <Start Embed> ::= <Start Stm> <Invalid Key Clauses> END-START | <Start Stm> <Start Imp> ::= <Start Stm> <Start Stm> ::= START Identifier <Start Key Opt> <Start Key Opt> ::= KEY <Compare Op> Identifier | !Optional <END-START Opt> ::= END-START | !Optional ! ----------------------------------------------------------------------------- ! STOP Statement ! ----------------------------------------------------------------------------- <Stop Sent> ::= <Stop Stm> <Stop Embed> ::= <Stop Stm> <Stop Imp> ::= <Stop Stm> <Stop Stm> ::= STOP RUN | STOP <Literal> ! ----------------------------------------------------------------------------- ! STRING Statement ! ----------------------------------------------------------------------------- <String Sent> ::= <String Stm> <Overflow Clauses> <END-STRING Opt> | <String Stm> <String Embed> ::= <String Stm> <Overflow Clauses> END-STRING | <String Stm> <String Imp> ::= <String Stm> <String Stm> ::= STRING <String Items> INTO <Variable> <Pointer Clause> <String Items> ::= <String Item> <String Items> | <String Item> <String Item> ::= <Values> DELIMITED <BY Opt> <Value> <END-STRING Opt> ::= END-STRING | !Optional ! ----------------------------------------------------------------------------- ! SUBTRACT Statement ! ----------------------------------------------------------------------------- <Subtract Sent> ::= <Subtract Stm> <Size Clauses> <END-SUBTRACT Opt> | <Subtract Stm> <Subtract Embed> ::= <Subtract Stm> <Size Clauses> END-SUBTRACT | <Subtract Stm> <Subtract Imp> ::= <Subtract Stm> <Subtract Stm> ::= SUBTRACT <Values> FROM <Variables> <Giving Clause Opt> | SUBTRACT <CORRESPONDING> <Value> FROM Identifier <END-SUBTRACT Opt> ::= END-SUBTRACT | !Optional ! ----------------------------------------------------------------------------- ! SUPPRESS Statement ! ----------------------------------------------------------------------------- <Suppress Sent> ::= <Suppress Stm> <Suppress Embed> ::= <Suppress Stm> <Suppress Imp> ::= <Suppress Stm> <Suppress Stm> ::= SUPPRESS <PRINTING Opt> ! ----------------------------------------------------------------------------- ! TERMMINATE Statement ! ----------------------------------------------------------------------------- <Terminate Sent> ::= <Terminate Stm> <Terminate Embed> ::= <Terminate Stm> <Terminate Imp> ::= <Terminate Stm> <Terminate Stm> ::= TERMINATE <Identifiers> ! ----------------------------------------------------------------------------- ! UNSTRING Statement ! ----------------------------------------------------------------------------- <Unstring Sent> ::= <Unstring Stm> <Overflow Clauses> <END-UNSTRING Opt> | <Unstring Stm> <Unstring Embed> ::= <Unstring Stm> <Overflow Clauses> END-UNSTRING | <Unstring Stm> <Unstring Imp> ::= <Unstring Stm> <Unstring Stm> ::= UNSTRING identifier <Delimiter Clause> INTO Identifier <Unstring Options> <Delimiter Clause> ::= DELIMITED <BY Opt> <Unstring Delimiter List> | !Optional <Unstring Delimiter List> ::= <Unstring Delimiter List> OR <Unstring Delimiter> | <Unstring Delimiter> <Unstring Delimiter> ::= <ALL Opt> <Value> <Unstring Options> ::= <Unstring Options> <Unstring Option> | !Empty <Unstring Option> ::= <WITH Opt> POINTER <Variable> | TALLYING <IN Opt> Identifier <END-UNSTRING Opt> ::= END-UNSTRING | !Optional ! ----------------------------------------------------------------------------- ! USE Statement ! ----------------------------------------------------------------------------- <Use Sent> ::= <Use Stm> <Use Embed> ::= <Use Stm> <Use Imp> ::= <Use Stm> <Use Stm> ::= USE <GLOBAL Opt> AFTER STANDARD <Use Proc Type> PROCEDURE ON <Use Access> | USE <GLOBAL Opt> BEFORE REPORTING Identifier | USE <FOR Opt> DEBUGGING <ON Opt> <Use Debug> <Use Proc Type> ::= EXCEPTION | ERROR <Use Access> ::= INPUT | OUTPUT | I-O | EXTEND | <Value> <Use Debug> ::= ALL <REFERENCES Opt> <OF Opt> Identifier | ALL PROCEDURES | <Value> ! ----------------------------------------------------------------------------- ! WRITE Statement ! ----------------------------------------------------------------------------- <Write Sent> ::= <Write Stm> <Invalid Key Clauses> <END-WRITE Opt> | <Write Stm> <AT EOP Clauses> <END-WRITE Opt> | <Write Stm> <Write Embed> ::= <Write Stm> <Invalid Key Clauses> END-WRITE | <Write Stm> <AT EOP Clauses> END-WRITE | <Write Stm> <Write Imp> ::= <Write Stm> <Write Stm> ::= WRITE Identifier <Write Options> | WRITE Identifier FROM Identifier <Write Options> <Write Options> ::= <BEFORE AFTER> <ADVANCING Opt> <Write Advance> <Write Advance> ::= <Value> <LINES Opt> | PAGE <END-WRITE Opt> ::= END-WRITE | !Optional
ColdFusion
Common Lisp
Component Pascal
Coq
D
DOS Batch File
Dc
Delphi
! ----------------------------------------------------------------------- ! Delphi 7.0 Object Pascal Grammar ! ----------------------------------------------------------------------- ! (c) Rob F.M. van den Brink - the Netherlands, 2006 - R.F.M.vandenBrink@hccnet.nl ! Version V1.1, Aug 2006 ! ! This grammar parses almost everything of the language, except for a few issues ! that are probably beyond the capabilities of Gold parser. ! Known limitations: ! (1) Cannot handle comment directives like {$ifdef Windows} ... {$endif} ! When parts of the source code is uncommented in this way, the grammer will ! still read it, and may fail. ! (2) The parser consumes all assembler statements, but is too tolerant in accepting ! input. Groups of several <AsmItem> does not belong to a single <AsmInstruction> ! because a 'newline' is regarded as whitespace while it should be a terminator here. ! (3) Lexemes like 'protected' , 'forward' can be both a keyword as well as an identifier ! in Delphi (even in the same object declaration), and when these lexemes should mean ! an identifier, the current grammar cannot handle it correctly. ! For several of them a workaround was created, but a better solution should be ! developped. ! (4) Strings with characters above #127 cannot be handled by the current Grammar. ! This should be very simple, but if the grammar defines string characters ! as the range {#32 .. #255}, Goldparser also adds {#376} and {#956}. ! This looks like a bug in Gold Parser. ! (5) The inclusion of an adequate number of error productions (SynError) is still ! to be done. ! (6) constructs that are considered (for the timebeing) as too weird, are not ! supported; see below. ! ----------------------------------------------------------------------- ! This grammar supports also most of 'weird' constructs that Borland has added ! to Delphi. This refers to the inconsistent syntax for several directives ! like in <CallConvention> and <MethodDirective>. Sometimes these directives have ! to be separated by an ';' sometimes not and somtimes both is alowed. ! An example of a syntax that was considered as too weird to be covered by this ! grammar was found in library routine "IdSSLOpenSSLHeaders.pas" (comes with Delphi) ! VAR ! IdSslCtxSetVerifyDepth : procedure(ctx: PSSL_CTX; depth: Integer); cdecl = nil; ! IdSslCtxGetVerifyDepth : function (ctx: PSSL_CTX):Integer; cdecl = nil; ! In a consistent syntax, cdecl should refer to some variable that is set to "nil', but ! the ';' does not close the <TypeSpec> and the rest is still part of the syntax ! ! ----------------------------------------------------------------------- ! Version history ! V1.0 - June 2006, derived from scratch, using Delphi 7.0 help and code files ! V1.1 - Aug 2006, lots of refinements to cover almost evberything of the language ! Consumes assembler code as well. ! ----------------------------------------------------------------------- "Name" = 'ObjectPascal' "Version" = '1.1, Aug 2006' "Author" = 'Rob F.M. van den Brink' "About" = 'Derived from scratch, from Delphi 7.0 help and experiments with code files' "Start Symbol" = <ObjectPascal> !------------------------------------------------------------------------------ "Case Sensitive" = False "Virtual Terminals" = SynError CommentStart2 CommentEnd2 Comment Line = '//' Comment Start = '{' Comment End = '}' CommentStart1 = '(*' CommentEnd1 = '*)' {Hex Digit} = {Digit} + [abcdefABCDEF] {Id Head} = {Letter} + [_] {Id Tail} = {Id Head} + {Digit} !{String Ch} = {#32 .. #255} - [''] + {HT} !WHY DOES GOLS ADD character #376 and #956 ?? {String Ch} = {printable} - [''] + {HT} DecLiteral = {digit}+ HexLiteral = '$'{Hex Digit}+ FloatLiteral = {Digit}+.{Digit}+ RealLiteral = {Digit}+ ('.' {Digit}* | {Digit}*) ('E' '+' | 'E' '-' | 'E') {digit}+ StringLiteral = ( '' {String Ch}* '' | '#' {digit}+ | '#' '$' {hex digit}+ | '''' )+ !StringLiteral = ( ( '' {String Ch}* '' ) ! | ( '#' {digit}+ ) ! | ( '#' '$' {hex digit}+ ) ! | ( '''' ) ! )+ id = {Id Head}{Id Tail}* <LCONST> ::= DecLiteral <ICONST> ::= DecLiteral | HexLiteral <RCONST> ::= FloatLiteral | RealLiteral <SCONST> ::= StringLiteral | '^' id ! handles characters like ^H and ^V !------------------------------------------------------------------------------ !<UnitId> ::= id <IdList> ::= <IdList> ',' <RefId> | <RefId> <LabelId> ::= id <TypeId> ::= id ! | id '.' <RefId> | NAME <TypeName> ::= <TypeId> | id '.' <RefId> !!accepts UnitId.Id as well <TypeList> ::= <TypeName> | <TypeList> ',' <TypeName> <RefId> ::= id | AT | ON | READ | WRITE | READLN | WRITELN | NAME | INDEX | VIRTUAL | ABSOLUTE | MESSAGE | DEFAULT | OVERRIDE | ABSTRACT | DISPID | REINTRODUCE | REGISTER | PASCAL | CDECL | STDCALL | SAFECALL | STRING | WIDESTRING | ANSISTRING | VARIANT | OLEVARIANT | READONLY | IMPLEMENTS | NODEFAULT | STORED | OVERLOAD | LOCAL | VARARGS | FORWARD | CONTAINS | PACKAGE | REQUIRES | LIBRARY | IMPORT | EXPORT | PLATFORM | DEPRECATED | EXTERNAL ! PROTECTED | PUBLISHED | PRIVATE | PUBLIC !THIS FAILS IN FIELDS <FieldDesignator> ::= <RefId> | <FieldDesignator> '.' <RefId> !* predefined identifiers are no part of a syntax <RealTypeId> ::= REAL48 | REAL | SINGLE | DOUBLE | EXTENDED | CURRENCY | COMP <OrdTypeId> ::= SHORTINT | SMALLINT | INTEGER | BYTE | LONGINT | INT64 | WORD | BOOLEAN | CHAR | WIDECHAR | LONGWORD | PCHAR *! !------------------------------------------------------------------------------ ! M O D U L E S !------------------------------------------------------------------------------ <ObjectPascal> ::= <Program> | <Unit> | <Package> | <Library> <Program> ::= <ProgHeader> <OptUsesSection> <Block> '.' <ProgHeader> ::= PROGRAM <RefId> <OptProgParamList> ';' <OptProgParamList> ::= '(' <IdList> ')' | <Unit> ::= <UnitHeader> <InterfaceSection> <ImplementationSection> <InitSection> '.' <UnitHeader> ::= UNIT <RefId> <OptPortDirectives> ';' <Package> ::= <PackageHeader> <OptRequiresClause> <OptContainsClause> END '.' <PackageHeader> ::= PACKAGE <RefId> ';' <OptRequiresClause> ::= REQUIRES <IdList> ';' | <OptContainsClause> ::= CONTAINS <IdList> ';' | <LibraryHeader> ::= LIBRARY <RefId> ';' <Library> ::= <LibraryHeader> <OptUsesSection> <Block> '.' <InterfaceSection> ::= INTERFACE <OptUsesSection> <OptExportDeclList> <OptUsesSection> ::= <UsesSection> | <UsesClause> ::= USES <IdList> ';' | SynError <UsesSection> ::= <UsesClause> | <UsesSection> <UsesClause> <OptExportDeclList> ::= <ExportDeclList> | <ExportDeclList> ::= <ExportDeclItem> | <ExportDeclList> <ExportDeclItem> <ExportDeclItem> ::= <ConstSection> | <TypeSection> | <VarSection> | <CallSection> | <CallSection> FORWARD ';' ! The forward directive has no effect in the interface section of a unit, ! but is not forbidden here. <CallSection> ::= <ProcHeading> | <FuncHeading> <ImplementationSection> ::= IMPLEMENTATION <OptUsesSection> <OptDeclSection> <OptExportBlock> <InitSection> ::= INITIALIZATION <StmtList> END | INITIALIZATION <StmtList> FINALIZATION <StmtList> END | <CompoundStmt> | END <Block> ::= <OptDeclSection> <OptExportBlock> <CompoundStmt> <OptExportBlock> <OptExportBlock> ::= <ExportStmt> | <OptExportBlock> <ExportStmt> | <ExportStmt> ::= EXPORTS <ExportList> ';' <ExportList> ::= <ExportItem> | <ExportList> ',' <ExportItem> <ExportItem> ::= id | id NAME '' <ConstExpr> '' | Id INDEX '' <ConstExpr> '' | NAME '' <ConstExpr> '' | INDEX '' <ConstExpr> '' !------------------------------------------------------------------------------ ! D E C L A R A T I O N S !------------------------------------------------------------------------------ <OptDeclSection> ::= <DeclSection> | <DeclSection> ::= <DeclItem> | <DeclSection> <DeclItem> <DeclItem> ::= <LabelSection> | <ConstSection> | <TypeSection> | <VarSection> | <ProcedureDeclSection> | SynError <LabelSection> ::= LABEL <LabelList> ';' <LabelList> ::= <LabelId> | <LabelList> ',' <LabelId> !-----CONSTS------------------------------------------------------------------- <ConstSection> ::= CONST <ConstantDeclList> | RESOURCESTRING <ConstantDeclList> !all these constants should be string <ConstantDeclList> ::= <ConstantDecl> | <ConstantDeclList> <ConstantDecl> <ConstantDecl> ::= <RefId> '=' <ConstExpr> <OptPortDirectives> ';' | <RefId> ':' <Type> '=' <TypedConstant> <OptPortDirectives> ';' | SynError ';' <TypedConstant> ::= <ConstExpr> | <ArrayConstant> | <RecordConstant> <ArrayConstant> ::= '(' <TypedConstList> ')' <RecordConstant> ::= '(' <RecordFieldConstList> ')' | '(' <RecordFieldConstList> ';' ')' | '(' ')' !only to initialize globar vars" <RecordFieldConstList> ::= <RecordFieldConstant> | <RecordFieldConstList> ';' <RecordFieldConstant> <RecordFieldConstant> ::= <RefId> ':' <TypedConstant> <TypedConstList> ::= <TypedConstant> | <TypedConstList> ',' <TypedConstant> !-----TYPES-------------------------------------------------------------------- <TypeSection> ::= TYPE <TypeDeclList> <TypeDeclList> ::= <TypeDecl> | <TypeDeclList> <TypeDecl> <TypeDecl> ::= <TypeId> '=' <TypeSpec> | SynError ';' <TypeSpec> ::= <GenericType> ';' | <RestrictedType> <OptPortDirectives> ';' | <CallType> ';' | <CallType> ';' <CallConventions> ';' | SynError ';' <Type> ::= <GenericType> | <CallType> <TypeRef> ::= <TypeName> | <StringType> | <VariantType> <GenericType> ::= <TypeName> | <StringType> | <VariantType> | <SubrangeType> | <EnumType> | <StructType> | <PointerType> | <ClassRefType> | <ClonedType> <ClonedType> ::= TYPE <TypeRef> <StringType> ::= STRING | ANSISTRING | WIDESTRING | STRING '[' <ConstExpr> ']' <VariantType> ::= VARIANT | OLEVARIANT <OrdinalType> ::= <SubrangeType> | <EnumType> | <TypeName> <SubrangeType> ::= <ConstOrdExpr> '..' <ConstOrdExpr> | <ConstOrdExpr> SynError | '(' <RefId> ')' '..' <ConstOrdExpr> <EnumType> ::= '(' <EnumList> ')' | '(' <RefId> ')' <EnumList> ::= <EnumId> | <EnumList> ',' <EnumId> <EnumId> ::= <RefId> | <RefId> '=' <ConstExpr> <OptPacked> ::= PACKED | <StructType> ::= <ArrayType> | <SetType> | <FileType> | <RecType> <ArrayType> ::= <OptPacked> ARRAY '[' <OrdinalTypeList> ']' OF <Type> | <OptPacked> ARRAY OF CONST | <OptPacked> ARRAY OF <Type> !dynamic array, starting from 0 ! FCells: array of array of TIWGridCell; <OrdinalTypeList> ::= <OrdinalType> | <OrdinalTypeList> ',' <OrdinalType> <RecType> ::= <OptPacked> RECORD <RecFieldList> END <OptPortDirectives> <RecFieldList> ::= | <RecField1> | <RecField2> | <RecField1> ';' <RecFieldList> | <RecField2> ';' <RecFieldList> | <RecField2> ';' <CallConvention> | <RecField2> ';' <CallConvention> ';' <RecFieldList> | CASE <Selector> OF <RecVariantList> <RecVariantList> ::= | <RecVariant> | <RecVariant> ';' <RecVariantList> <RecField1> ::= <IdList> ':' <GenericType> <OptPortDirectives> <RecField2> ::= <IdList> ':' <CallType> <RecVariant> ::= <ConstExprList> ':' '(' <RecFieldList> ')' <Selector> ::= <RefId> ':' <TypeName> | <TypeName> <SetType> ::= <OptPacked> SET OF <OrdinalType> <FileType> ::= <OptPacked> FILE OF <TypeRef> | FILE <PointerType> ::= '^' <TypeRef> <CallType> ::= PROCEDURE <OptFormalParms> <OptCallConventions> | PROCEDURE <OptFormalParms> OF OBJECT <OptCallConventions> | FUNCTION <OptFormalParms> ':' <ResultType> <OptCallConventions> | FUNCTION <OptFormalParms> ':' <ResultType> OF OBJECT <OptCallConventions> !-----CLASSES AND OBJECTS------------------------------------------------------ <RestrictedType> ::= <ObjectType> | <ClassType> | <InterfaceType> <ObjectType> ::= <OptPacked> OBJECT <OptObjectHeritage> <ObjectMemberList> END <ClassType> ::= CLASS <OptClassHeritage> <ClassMemberList> END | CLASS <OptClassHeritage> <ClassRefType> ::= CLASS OF <TypeName> <InterfaceType> ::= INTERFACE <OptClassHeritage> <OptClassGUID> <OptClassMethodList> END | DISPINTERFACE <OptClassHeritage> <OptClassGUID> <OptClassMethodList> END | INTERFACE | DISPINTERFACE <OptObjectHeritage> ::= '(' <TypeName> ')' | <OptClassHeritage> ::='(' <TypeList> ')' | <OptClassGUID> ::= '[' <ConstStrExpr> ']' ! <SCONST> globally unique identifier | <ObjectMemberList> ::= <OptFieldList> <OptObjectMethodList> | <ObjectMemberList> PUBLIC <OptFieldList> <OptObjectMethodList> | <ObjectMemberList> PRIVATE <OptFieldList> <OptObjectMethodList> | <ObjectMemberList> PROTECTED <OptFieldList> <OptObjectMethodList> <ClassMemberList> ::= <OptFieldList> <OptClassMethodList> | <ClassMemberList> PUBLIC <OptFieldList> <OptClassMethodList> | <ClassMemberList> PRIVATE <OptFieldList> <OptClassMethodList> | <ClassMemberList> PROTECTED <OptFieldList> <OptClassMethodList> | <ClassMemberList> PUBLISHED <OptFieldList> <OptClassMethodList> <OptFieldList> ::= <FieldList> | <OptObjectMethodList> ::= <ObjectMethodList> | <OptClassMethodList> ::= <ClassMethodList> | <FieldList> ::= <FieldSpec> | <FieldList> <FieldSpec> <ObjectMethodList> ::= <ObjectMethodSpec> | <ObjectMethodList> <ObjectMethodSpec> <ClassMethodList> ::= <ClassMethodSpec> | <ClassMethodList> <ClassMethodSpec> <FieldSpec> ::= <IdList> ':' <Type> <OptPortDirectives> ';' | SynError ';' <ObjectMethodSpec> ::= <MethodSpec> <OptMethodDirectives> | <PropertySpec> <OptPropertyDirectives> | SynError <ClassMethodSpec> ::= <MethodSpec> <OptMethodDirectives> | <ResolutionSpec> <OptMethodDirectives> | CLASS <ProcSpec> <OptMethodDirectives> | CLASS <FuncSpec> <OptMethodDirectives> | <PropertySpec> <OptPropertyDirectives> | SynError <MethodSpec> ::= <ConstructorSpec> | <DestructorSpec> | <ProcSpec> | <FuncSpec> <ConstructorSpec> ::= CONSTRUCTOR <RefId> <OptFormalParms> ';' <DestructorSpec> ::= DESTRUCTOR <RefId> <OptFormalParms> ';' <ProcSpec> ::= PROCEDURE <RefId> <OptFormalParms> <OptCallConventions> ';' <FuncSpec> ::= FUNCTION <RefId> <OptFormalParms> ':' <ResultType> <OptCallConventions> ';' <ResolutionSpec> ::= PROCEDURE <RefId> '.' <RefId> '=' <RefId> ';' | FUNCTION <RefId> '.' <RefId> '=' <RefId> ';' <PropertySpec> ::= PROPERTY <PropertyDecl> <OptPropSpecifiers> ';' <PropertyDecl> ::= <RefId> ':' <TypeRef> | <RefId> '[' <IndexList> ']' ':' <TypeRef> | <RefId> <IndexList> ::= <IndexDecl> | <IndexList> ';' <IndexDecl> <IndexDecl> ::= <IdDecl> | CONST <IdDecl> <IdDecl> ::= <IdList> ':' <Type> <OptPropSpecifiers> ::= <PropertySpecifiers> | <PropertySpecifiers> ::= <PropertySpecifier> | <PropertySpecifiers> <PropertySpecifier> <PropertySpecifier> ::= INDEX <ConstExpr> !StorageSpecifier | READ <FieldDesignator> | WRITE <FieldDesignator> | STORED <FieldDesignator> ! | STORED <ConstExpr> | DEFAULT <ConstExpr> | NODEFAULT | WRITEONLY | READONLY | DISPID <ConstExpr> !Only within InterfaceTypes | <ImplementsSpecifier> <ImplementsSpecifier> ::= IMPLEMENTS <TypeRef> | <ImplementsSpecifier> ',' <TypeRef> ! The implements directive must be the last specifier in the property ! declaration and can list more than one interface, separated by commas !-----VARS--------------------------------------------------------------------- <VarSection> ::= VAR <VarDeclList> | THREADVAR <ThreadVarDeclList> <VarDeclList> ::= <VarDecl> | <VarDeclList> <VarDecl> <VarDecl> ::= <IdList> ':' <Type> <OptAbsoluteClause> <OptPortDirectives> ';' | <IdList> ':' <Type> '=' <TypedConstant> <OptPortDirectives> ';' | <IdList> ':' <TypeSpec> | SynError ';' <ThreadVarDeclList> ::= <ThreadVarDecl> | <ThreadVarDeclList> <ThreadVarDecl> <ThreadVarDecl> ::= <IdList> ':' <TypeSpec> | SynError ';' <OptAbsoluteClause> ::= ABSOLUTE <RefId> ! | ABSOLUTE <ConstExpr> !on windows only, not on linux | !------------------------------------------------------------------------------ ! E X P R E S S I O N S !------------------------------------------------------------------------------ <ConstExpr> ::= <Expr> <ConstOrdExpr> ::= <AddExpr> <ConstStrExpr> ::= <AddExpr> <Expr> ::= <AddExpr> | <AddExpr> <RelOp> <AddExpr> | SynError <AddExpr> ::= <MulExpr> | <AddExpr> <AddOp> <MulExpr> <MulExpr> ::= <Factor> | <MulExpr> <MulOp> <Factor> <Factor> ::= NIL | <ICONST> | <RCONST> | <SCONST> | <Designator> | <SetConstructor> | '@' <Designator> | '@' '@' <Designator> !returns memory address of a procedural variable | '(' <Expr> ')' | '(' <Expr> ')' '^' | '+' <Factor> | '-' <Factor> | NOT <Factor> !---PortArray <Designator> ::= <FieldDesignator> | <Designator> '.' <FieldDesignator> | <Designator> '^' | <Designator> '[' <ExprList> ']' | <Designator> '(' <ExprList> ')' !FunctionCall or TypeCast | <Designator> '(' ')' !FunctionCall | <Designator> AS <TypeRef> !eg "with Source as TListItem do ..." | '(' <Designator> ')' | INHERITED <Designator> <AsnOp> ::= ':=' | '+=' | '-=' | '*=' | '/=' <RelOp> ::= '=' | '>' | '<' | '<=' | '>=' | '<>' | IN | IS | AS <AddOp> ::= '+' |'-' | OR | XOR <MulOp> ::='*' | '/' | DIV | MOD | AND | SHL | SHR <SetConstructor> ::= '[' <SetElementList> ']' | '[' ']' <SetElementList> ::= <SetElement> | <SetElementList> ',' <SetElement> <SetElement> ::= <Expr> | <Expr> '..' <Expr> <ExprList> ::= <Expr> | <ExprList> ',' <Expr> <FmtExpr> ::= <Expr> | <Expr> ':' <Expr> | <Expr> ':' <Expr> ':' <Expr> <FmtExprList> ::= <FmtExpr> | <FmtExprList> ',' <FmtExpr> <ConstExprList> ::= <ConstExpr> | <ConstExprList> ',' <ConstExpr> !------------------------------------------------------------------------------ ! S T A T E M E N T S !------------------------------------------------------------------------------ <StmtList> ::= <Statement> | <StmtList> ';' <Statement> <Statement> ::= <Label> <Statement> | <AssignmentStmt> | <CallStmt> | <GotoStatement> | <CompoundStmt> | <IfStatement> | <CaseStatement> | <ForStatement> | <WhileStatement> | <RepeatStatement> | <WithStatement> | <TryFinallyStmt> | <TryExceptStmt> | <RaiseStmt> | <AssemblerStmt> | SynError | <Label> ::= <LCONST> ':' | <LabelId> ':' <AssignmentStmt> ::= <Designator> <AsnOp> <Expr> | '@' <RefId> ':=' <Factor> !EXAMPLE of this '@' <RefId>, that calls the GetProcAddress !function and points a var StrComp to the result. ! var StrComp: function(Str1, Str2: PChar): Integer; ! ... ! @StrComp := GetProcAddress(KernelHandle, 'lstrcmpi'); <CallStmt> ::= <Designator> !procedure, function, method, typecast | WRITE '(' <FmtExprList> ')' | WRITELN '(' <FmtExprList> ')' ! | INHERITED <CallStmt> | INHERITED <GotoStatement> ::= GOTO <LCONST> | GOTO <RefId> <CompoundStmt> ::= BEGIN <StmtList> END <IfStatement> ::= IF <Expr> THEN <Statement> ELSE <Statement> | IF <Expr> THEN <Statement> | IF SynError THEN <Statement> <CaseStatement> ::= CASE <Expr> OF <CaseList> <OtherWise> END <ForStatement> ::= FOR <RefId> ':=' <Expr> <Dir> <Expr> DO <Statement> <Dir> ::= TO | DOWNTO <WhileStatement> ::= WHILE <Expr> DO <Statement> <WithStatement> ::= WITH <DesignatorList> DO <Statement> <DesignatorList> ::= <Designator> | <DesignatorList> ',' <Designator> <RepeatStatement> ::= REPEAT <StmtList> UNTIL <Expr> <AssemblerStmt> ::= ASM <AsmLanguage> END <OtherWise> ::= OTHERWISE <StmtList> | ELSE <StmtList> | <CaseList> ::= <CaseSelector> | <CaseList> ';' <CaseSelector> | <CaseList> ';' <CaseSelector> ::= <CaseLabels> ':' <Statement> <CaseLabels> ::= <CaseLabel> | <CaseLabels> ',' <CaseLabel> <CaseLabel> ::= <ConstExpr> | <ConstExpr> '..' <ConstExpr> <RaiseStmt> ::= RAISE SynError ![object] [AT address] | RAISE <OptExceptInstance> | RAISE <OptExceptInstance> AT <Address> <TryFinallyStmt> ::= TRY <StmtList> FINALLY <StmtList> END <TryExceptStmt> ::= TRY <StmtList> EXCEPT <ExceptionBlock> <OptExceptionElse> END <ExceptionBlock> ::= <ExceptionStmt> | <ExceptionBlock> ';' <ExceptionStmt> <ExceptionStmt> ::= ON <Selector> DO <Statement> ! | ELSE <Statement> | <Statement> <OptExceptionElse> ::= ELSE <StmtList> | <OptExceptInstance> ::= <Designator> !usually a method call (??) | <Address> ::= <Designator> !usually a functiion call, returning an adress <OptSemi> ::= ';' | !------------------------------------------------------------------------------ ! R O U T I N E S !------------------------------------------------------------------------------ <ProcedureDeclSection> ::= <ProcedureDecl> | <FunctionDecl> | <MethodDecl> <ProcedureDecl> ::= <ProcHeading> <CallBody> <OptSemi> <FunctionDecl> ::= <FuncHeading> <CallBody> <OptSemi> <MethodDecl> ::= <MethHeading> <CallBody> <OptSemi> <ProcHeading> ::= PROCEDURE <RefId> <OptFormalParms> <OptCallSpecifiers> ';' | <ProcHeading> <CallDirectives> <OptSemi> <FuncHeading> ::= FUNCTION <RefId> <OptFormalParms> ':' <ResultType> <OptCallSpecifiers> ';' | FUNCTION <RefId> ';' | <FuncHeading> <CallDirectives> <OptSemi> ! ! if the heading is 'incomplete' it was declared before ! and must be followed by a <CallBody> TO BE IMPROVED <MethHeading> ::= PROCEDURE <RefId> '.' <RefId> <OptFormalParms> <OptCallSpecifiers> ';' | FUNCTION <RefId> '.' <RefId> <OptFormalParms> ':' <ResultType> <OptCallSpecifiers> ';' | FUNCTION <RefId> '.' <RefId> ';' | CONSTRUCTOR <RefId> '.' <RefId> <OptFormalParms> <OptCallSpecifiers> ';' | DESTRUCTOR <RefId> '.' <RefId> <OptFormalParms> <OptCallSpecifiers> ';' | CLASS PROCEDURE <RefId> '.' <RefId> <OptFormalParms> <OptCallSpecifiers> ';' | CLASS FUNCTION <RefId> '.' <RefId> <OptFormalParms> ':' <ResultType> <OptCallSpecifiers> ';' | <MethHeading> <CallDirectives> ';' ! ! the class methods operates on classes instead of objects <ResultType> ::= <TypeRef> <OptFormalParms> ::= '(' <FormalParmList> ')' | '(' ')' | <FormalParmList> ::= <FormalParm> | <FormalParmList> ';' <FormalParm> <FormalParm> ::= <Parameter> | CONST <Parameter> | VAR <Parameter> | OUT <Parameter> <Parameter> ::= <IdList> | <IdList> ':' <ParmType> | <IdList> ':' <TypeRef> '=' <ConstExpr> <ParmType> ::= <TypeRef> | ARRAY OF <TypeRef> | ARRAY OF CONST | FILE <CallBody> ::= <OptDeclSection> <CompoundStmt> | <OptDeclSection> <AssemblerStmt> | <ExternalDeclaration> | FORWARD !-----DIRECTIVES--------------------------------------------------------------- ! <PortDirectives> are to produce warnings at compile time when source code is compiled ! in the {$HINTS ON} {$WARNINGS ON} state. It can be applied to declarations ! ! <PortDirectives are accepted: ! WITHIN const and var declarations (not after), ! WITHIN unit headers (not after) ! AFTER function/procedure headings (not within) (ONE terminating ';' is optional) ! <PortDirectives are NOT accepted: ! in/after type declarations !------------------------------------------------------------------------------ <OptPortDirectives> ::= <PortDirectives> | <PortDirectives> ::= <PortDirective> | <PortDirectives> <PortDirective> <PortDirective> ::= PLATFORM ! to warn that it is specific to a particular operating environment (such as Windows or Linux) | PLATFORM '=' <ConstExpr> | DEPRECATED ! to warn it is obsolete or supported only for backward compatibility | LIBRARY ! to warn dependencies on a particular library or component framework (such as CLX). !------------------------ <OptMethodDirectives> ::= <MethodDirectives> | <OptMethodDirectives> <PortDirective> ';' | <MethodDirectives> ::= <MethodDirective> ';' | <MethodDirectives> <MethodDirective> ';' <MethodDirective> ::= VIRTUAL | VIRTUAL <ConstExpr> | DYNAMIC !for classes only | OVERRIDE | ABSTRACT | MESSAGE <ConstExpr> | OVERLOAD | REINTRODUCE | DISPID <ConstExpr> !only within an <InterfaceType> | <CallConvention> !TODO NOT ALL THESE METHOD DIRECTIVES CAN BE COMBINED WITH EACH OTHER !------------------------ <OptPropertyDirectives> ::= <PropertyDirective> ';' | <OptPropertyDirectives> <PortDirective> ';' | <PropertyDirective> ::= DEFAULT !------------------------ <ExternalDeclaration> ::= EXTERNAL | EXTERNAL <ConstStrExpr> | EXTERNAL <ConstStrExpr> NAME <ConstStrExpr> ! | EXTERNAL <SCONST> ! | EXTERNAL <SCONST> NAME <SCONST> !------------------------ <CallDirectives> ::= <CallDirective> | <CallDirectives> <CallDirective> <CallDirective> ::= <CallConvention> | <CallObsolete> | <PortDirective> | VARARGS !works only with external routines and cdecl calling convention. | LOCAL !prevents exporting in a library | <SCONST> !for PasPro only | OVERLOAD <OptCallSpecifiers> ::= <CallSpecifier> | <OptCallSpecifiers> <CallSpecifier> | <CallSpecifier> ::= <CallConvention> | <CallObsolete> <CallConventions> ::= <CallConvention> | <CallConventions> <CallConvention> <OptCallConventions> ::= <CallConvention> | <OptCallConventions> <CallConvention> | ![ParmOrder] [CleanUp] [RegParms] <CallConvention> ::= REGISTER !Left-to-right Routine Yes | PASCAL !Left-to-right Routine No | CDECL !Right-to-left Caller No | STDCALL !Right-to-left Routine No | SAFECALL !Right-to-left Routine No <CallObsolete> ::= INLINE !for backward compatibility only; has no effect on the compiler. | ASSEMBLER !for backward compatibility only; has no effect on the compiler. | NEAR !for 16-bits programming only, has no effect in 32 bit applications | FAR !for 16-bits programming only, has no effect in 32 bit applications | EXPORT !for 16-bits programming only, has no effect in 32 bit applications !------------------------------------------------------------------------------ ! A S S E M B L E R I N S T R U C T I O N S !------------------------------------------------------------------------------ ! The asm 'grammar' below is rather tolerant in accepting assembler code and needs ! further elaboration. The main problem is that end of lines are not detected, so ! the separators between the instructions cannot be found, so an <AsmItem> cannot ! be grouped in a meaningfull way with another <AsmItem> into a true <AsmInstruction> ! A fundamental solution could be to start a new lexical "context" in this grammar, with ! that forces the lexical scanner to recognize an assembler specific list of keywords ! Unfortunately, this is not supported by the Gold parser <AsmLanguage> ::= <AsmInstruction> | <AsmLanguage> <AsmInstruction> <AsmInstruction> ::= <AsmItem> | <AsmInstruction> <AsmItem> | <AsmInstruction> ',' <AsmItem> | <AsmInstruction> ';' <AsmItem> ::= <AsmLabel> | <AsmExpr> <AsmLabel> ::= <AsmLocal> ':' | <AsmId> ':' <AsmExpr> ::= <AsmFactor> | '-' <AsmFactor> | <AsmExpr> '+' <AsmFactor> | <AsmExpr> '*' <AsmFactor> | <AsmExpr> '-' <AsmFactor> | <AsmExpr> '.' <AsmFactor> | '[' <AsmExpr> ']' | '(' <AsmExpr> ')' ! <AsmId> '(' <AsmExpr> ')' | SynError <AsmFactor> ::= <AsmId> | <AsmLocal> | <ICONST> | <RCONST> | <SCONST> <AsmId> ::= <RefId> | '&' <RefId> | REPEAT | WHILE | IF | AND | OR | XOR | SHR | SHL | DIV | NOT ! plus many other keywords as well that may serve as an identifier <AsmLocal> ::= '@' <LCONST> | '@' <AsmId> | '@' <AsmLocal> | '@' END
E
EC
ELLA
ESQL
Eiffel
Emacs Lisp
Erlang
F
F#
FALSE
FP
Factor
Fan
Forth
Fortran
GAP
Gnuplot
Groovy
HaXe
Haskell
IDL
Icon
Io
J
JSON
JScript.NET
Java
"Name" = 'LALR(1) Java nonunicode grammar' "Version" = '1.0 alpha 110' "Author" = 'Dmitry Gazko' "About" = 'Based on partial conversion of Sun Java 1.0-2.0 specification' {String Char} = {Printable} - ["] {Quote} = [''] {IdLetter} = {Letter} + [_$] {IdAlphaNumeric} = {Alphanumeric} + [_$] {HexDigit} = {Digit} + [abcdefABCDEF] {OctalCharSet} = [01234567] {NoZeroDigit} = [123456789] {LongTypeSuffix} =[lL] {FloatTypeSuffix} =[dfDF] {ExponentPartIndicator} = [eE] {Sign} = [-+] {CharSign} = [abtnfr"\] + {Quote} {CharSign1} = {String Char} - [\] {HexEscapeSign} =[uUxX] Identifier = {IdLetter}{IdAlphaNumeric}* StringLiteral = '"'{String Char}*'"' FloatingPointLiteral = {Digit}+'.'{Digit}+{FloatTypeSuffix}? | {Digit}+{FloatTypeSuffix} | '.'{Digit}+{FloatTypeSuffix}? FloatingPointLiteralExponent = {Digit}+'.'{Digit}+{ExponentPartIndicator}{Sign}?{Digit}+{FloatTypeSuffix}? | {Digit}+{ExponentPartIndicator}{Sign}?{Digit}+{FloatTypeSuffix}? | '.'{Digit}+{ExponentPartIndicator}{Sign}?{Digit}+{FloatTypeSuffix}? BooleanLiteral = 'true' | 'false' IndirectCharLiteral = {Quote}{CharSign1}{Quote} StandardEscapeCharLiteral = {Quote}'\'{CharSign}{Quote} OctalEscapeCharLiteral ={Quote}'\'{OctalCharSet}+{Quote} HexEscapeCharLiteral ={Quote}'\'{HexEscapeSign}{HexDigit}+{Quote} NullLiteral = 'null' StartWithNoZeroDecimalIntegerLiteral = {NoZeroDigit}{Digit}*{LongTypeSuffix}? StartWithZeroDecimalIntegerLiteral = '0'{LongTypeSuffix}? HexIntegerLiteral = '0'('x'|'X'){HexDigit}+{LongTypeSuffix}? OctalIntegerLiteral = '0'{OctalCharSet}+{LongTypeSuffix}? "Case Sensitive" = 'True' "Start Symbol" = <CompilationUnit> Comment Start = '/*' Comment End = '*/' Comment Line = '//' <CharacterLiteral> ::= IndirectCharLiteral | StandardEscapeCharLiteral | OctalEscapeCharLiteral | HexEscapeCharLiteral <DecimalIntegerLiteral> ::= StartWithZeroDecimalIntegerLiteral | StartWithNoZeroDecimalIntegerLiteral <FloatPointLiteral> ::= FloatingPointLiteral | FloatingPointLiteralExponent <IntegerLiteral> ::= <DecimalIntegerLiteral> | HexIntegerLiteral | OctalIntegerLiteral <Literal> ::= <IntegerLiteral> | <FloatPointLiteral> | BooleanLiteral | <CharacterLiteral> | StringLiteral | NullLiteral <Type> ::= <PrimitiveType> | <ReferenceType> <PrimitiveType> ::= <NumericType> | 'boolean' <NumericType> ::= <IntegralType> | <FloatingPointType> <IntegralType> ::= 'byte' | 'short' | 'int' | 'long' | 'char' <FloatingPointType> ::= 'float' | 'double' <ReferenceType> ::= <ClassOrInterfaceType> | <ArrayType> <ClassOrInterfaceType> ::= <Name> <ClassType> ::= <ClassOrInterfaceType> <InterfaceType> ::= <ClassOrInterfaceType> <ArrayType> ::= <PrimitiveType> '[' ']' | <Name> '[' ']' | <ArrayType> '[' ']' <Name> ::= <SimpleName> | <QualifiedName> <SimpleName> ::= Identifier <QualifiedName> ::= <Name> '.' Identifier <CompilationUnit> ::= <PackageDeclaration> <ImportDeclarations> <TypeDeclarations> | <PackageDeclaration> <ImportDeclarations> | <PackageDeclaration> <TypeDeclarations> | <PackageDeclaration> | <ImportDeclarations> <TypeDeclarations> | <ImportDeclarations> | <TypeDeclarations> | <ImportDeclarations> ::= <ImportDeclaration> | <ImportDeclarations> <ImportDeclaration> <TypeDeclarations> ::= <TypeDeclaration> | <TypeDeclarations> <TypeDeclaration> <PackageDeclaration> ::= 'package' <Name> ';' <ImportDeclaration> ::= <SingleTypeImportDeclaration> | <TypeImportOnDemandDeclaration> <SingleTypeImportDeclaration> ::= 'import' <Name> ';' <TypeImportOnDemandDeclaration> ::= 'import' <Name> '.' '*' ';' <TypeDeclaration> ::= <ClassDeclaration> | <InterfaceDeclaration> | ';' <Modifiers> ::= <Modifier> | <Modifiers> <Modifier> <Modifier> ::= 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' <ClassDeclaration> ::= <Modifiers> 'class' Identifier <Super> <Interfaces> <ClassBody> | <Modifiers> 'class' Identifier <Super> <ClassBody> | <Modifiers> 'class' Identifier <Interfaces> <ClassBody> | <Modifiers> 'class' Identifier <ClassBody> | 'class' Identifier <Super> <Interfaces> <ClassBody> | 'class' Identifier <Super> <ClassBody> | 'class' Identifier <Interfaces> <ClassBody> | 'class' Identifier <ClassBody> <Super> ::= 'extends' <ClassType> <Interfaces> ::= 'implements' <InterfaceTypeList> <InterfaceTypeList> ::= <InterfaceType> | <InterfaceTypeList> ',' <InterfaceType> <ClassBody> ::= '{' <ClassBodyDeclarations> '}' | '{' '}' <ClassBodyDeclarations> ::= <ClassBodyDeclaration> | <ClassBodyDeclarations> <ClassBodyDeclaration> <ClassBodyDeclaration> ::= <ClassMemberDeclaration> | <StaticInitializer> | <ConstructorDeclaration> <ClassMemberDeclaration> ::= <FieldDeclaration> | <MethodDeclaration> <FieldDeclaration> ::= <Modifiers> <Type> <VariableDeclarators> ';' | <Type> <VariableDeclarators> ';' <VariableDeclarators> ::= <VariableDeclarator> | <VariableDeclarators> ',' <VariableDeclarator> <VariableDeclarator> ::= <VariableDeclaratorId> | <VariableDeclaratorId> '=' <VariableInitializer> <VariableDeclaratorId> ::= Identifier | <VariableDeclaratorId> '[' ']' <VariableInitializer> ::= <Expression> | <ArrayInitializer> <MethodDeclaration> ::= <MethodHeader> <MethodBody> <MethodHeader> ::= <Modifiers> <Type> <MethodDeclarator> <Throws> | <Modifiers> <Type> <MethodDeclarator> | <Type> <MethodDeclarator> <Throws> | <Type> <MethodDeclarator> | <Modifiers> 'void' <MethodDeclarator> <Throws> | <Modifiers> 'void' <MethodDeclarator> | 'void' <MethodDeclarator> <Throws> | 'void' <MethodDeclarator> <MethodDeclarator> ::= Identifier '(' <FormalParameterList> ')' | Identifier '(' ')' | <MethodDeclarator> '[' ']' <FormalParameterList> ::= <FormalParameter> | <FormalParameterList> ',' <FormalParameter> <FormalParameter> ::= <Type> <VariableDeclaratorId> <Throws> ::= 'throws' <ClassTypeList> <ClassTypeList> ::= <ClassType> | <ClassTypeList> ',' <ClassType> <MethodBody> ::= <Block> | ';' <StaticInitializer> ::= 'static' <Block> <ConstructorDeclaration> ::= <Modifiers> <ConstructorDeclarator> <Throws> <ConstructorBody> | <Modifiers> <ConstructorDeclarator> <ConstructorBody> | <ConstructorDeclarator> <Throws> <ConstructorBody> | <ConstructorDeclarator> <ConstructorBody> <ConstructorDeclarator> ::= <SimpleName> '(' <FormalParameterList> ')' | <SimpleName> '(' ')' <ConstructorBody> ::= '{' <ExplicitConstructorInvocation> <BlockStatements> '}' | '{' <ExplicitConstructorInvocation> '}' | '{' <BlockStatements> '}' | '{' '}' <ExplicitConstructorInvocation> ::= 'this' '(' <ArgumentList> ')' ';' | 'this' '(' ')' ';' | 'super' '(' <ArgumentList> ')' ';' | 'super' '(' ')' ';' <InterfaceDeclaration> ::= <Modifiers> 'interface' Identifier <ExtendsInterfaces> <InterfaceBody> | <Modifiers> 'interface' Identifier <InterfaceBody> | 'interface' Identifier <ExtendsInterfaces> <InterfaceBody> | 'interface' Identifier <InterfaceBody> <ExtendsInterfaces> ::= 'extends' <InterfaceType> | <ExtendsInterfaces> ',' <InterfaceType> <InterfaceBody> ::= '{' <InterfaceMemberDeclarations> '}' | '{' '}' <InterfaceMemberDeclarations> ::= <InterfaceMemberDeclaration> | <InterfaceMemberDeclarations> <InterfaceMemberDeclaration> <InterfaceMemberDeclaration> ::= <ConstantDeclaration> | <AbstractMethodDeclaration> <ConstantDeclaration> ::= <FieldDeclaration> <AbstractMethodDeclaration> ::= <MethodHeader> ';' <ArrayInitializer> ::= '{' <VariableInitializers> ',' '}' | '{' <VariableInitializers> '}' | '{' ',' '}' | '{' '}' <VariableInitializers> ::= <VariableInitializer> | <VariableInitializers> ',' <VariableInitializer> <Block> ::= '{' <BlockStatements> '}' | '{' '}' <BlockStatements> ::= <BlockStatement> | <BlockStatements> <BlockStatement> <BlockStatement> ::= <LocalVariableDeclarationStatement> | <Statement> <LocalVariableDeclarationStatement> ::= <LocalVariableDeclaration> ';' <LocalVariableDeclaration> ::= <Type> <VariableDeclarators> <Statement> ::= <StatementWithoutTrailingSubstatement> | <LabeledStatement> | <IfThenStatement> | <IfThenElseStatement> | <WhileStatement> | <ForStatement> <StatementNoShortIf> ::= <StatementWithoutTrailingSubstatement> | <LabeledStatementNoShortIf> | <IfThenElseStatementNoShortIf> | <WhileStatementNoShortIf> | <ForStatementNoShortIf> <StatementWithoutTrailingSubstatement> ::= <Block> | <EmptyStatement> | <ExpressionStatement> | <SwitchStatement> | <DoStatement> | <BreakStatement> | <ContinueStatement> | <ReturnStatement> | <SynchronizedStatement> | <ThrowStatement> | <TryStatement> <EmptyStatement> ::= ';' <LabeledStatement> ::= Identifier ':' <Statement> <LabeledStatementNoShortIf> ::= Identifier ':' <StatementNoShortIf> <ExpressionStatement> ::= <StatementExpression> ';' <StatementExpression> ::= <Assignment> | <PreIncrementExpression> | <PreDecrementExpression> | <PostIncrementExpression> | <PostDecrementExpression> | <MethodInvocation> | <ClassInstanceCreationExpression> <IfThenStatement> ::= 'if' '(' <Expression> ')' <Statement> <IfThenElseStatement> ::= 'if' '(' <Expression> ')' <StatementNoShortIf> 'else' <Statement> <IfThenElseStatementNoShortIf> ::= 'if' '(' <Expression> ')' <StatementNoShortIf> 'else' <StatementNoShortIf> <SwitchStatement> ::= 'switch' '(' <Expression> ')' <SwitchBlock> <SwitchBlock> ::= '{' <SwitchBlockStatementGroups> <SwitchLabels> '}' | '{' <SwitchBlockStatementGroups> '}' | '{' <SwitchLabels> '}' | '{' '}' <SwitchBlockStatementGroups> ::= <SwitchBlockStatementGroup> | <SwitchBlockStatementGroups> <SwitchBlockStatementGroup> <SwitchBlockStatementGroup> ::= <SwitchLabels> <BlockStatements> <SwitchLabels> ::= <SwitchLabel> | <SwitchLabels> <SwitchLabel> <SwitchLabel> ::= 'case' <ConstantExpression> ':' | 'default' ':' <WhileStatement> ::= 'while' '(' <Expression> ')' <Statement> <WhileStatementNoShortIf> ::= 'while' '(' <Expression> ')' <StatementNoShortIf> <DoStatement> ::= 'do' <Statement> 'while' '(' <Expression> ')' ';' <ForStatement> ::= 'for' '(' <ForInit> ';' <Expression> ';' <ForUpdate> ')' <Statement> | 'for' '(' <ForInit> ';' <Expression> ';' ')' <Statement> | 'for' '(' <ForInit> ';' ';' <ForUpdate> ')' <Statement> | 'for' '(' <ForInit> ';' ';' ')' <Statement> | 'for' '(' ';' <Expression> ';' <ForUpdate> ')' <Statement> | 'for' '(' ';' <Expression> ';' ')' <Statement> | 'for' '(' ';' ';' <ForUpdate> ')' <Statement> | 'for' '(' ';' ';' ')' <Statement> <ForStatementNoShortIf> ::= 'for' '(' <ForInit> ';' <Expression> ';' <ForUpdate> ')' <StatementNoShortIf> | 'for' '(' <ForInit> ';' <Expression> ';' ')' <StatementNoShortIf> | 'for' '(' <ForInit> ';' ';' <ForUpdate> ')' <StatementNoShortIf> | 'for' '(' <ForInit> ';' ';' ')' <StatementNoShortIf> | 'for' '(' ';' <Expression> ';' <ForUpdate> ')' <StatementNoShortIf> | 'for' '(' ';' <Expression> ';' ')' <StatementNoShortIf> | 'for' '(' ';' ';' <ForUpdate> ')' <StatementNoShortIf> | 'for' '(' ';' ';' ')' <StatementNoShortIf> <ForInit> ::= <StatementExpressionList> | <LocalVariableDeclaration> <ForUpdate> ::= <StatementExpressionList> <StatementExpressionList> ::= <StatementExpression> | <StatementExpressionList> ',' <StatementExpression> <BreakStatement> ::= 'break' Identifier ';' | 'break' ';' <ContinueStatement> ::= 'continue' Identifier ';' | 'continue' ';' <ReturnStatement> ::= 'return' <Expression> ';' | 'return' ';' <ThrowStatement> ::= 'throw' <Expression> ';' <SynchronizedStatement> ::= 'synchronized' '(' <Expression> ')' <Block> <TryStatement> ::= 'try' <Block> <Catches> | 'try' <Block> <Catches> <Finally> | 'try' <Block> <Finally> <Catches> ::= <CatchClause> | <Catches> <CatchClause> <CatchClause> ::= 'catch' '(' <FormalParameter> ')' <Block> <Finally> ::= 'finally' <Block> <Primary> ::= <PrimaryNoNewArray> | <ArrayCreationExpression> <PrimaryNoNewArray> ::= <Literal> | 'this' | '(' <Expression> ')' | <ClassInstanceCreationExpression> | <FieldAccess> | <MethodInvocation> | <ArrayAccess> <ClassInstanceCreationExpression> ::= 'new' <ClassType> '(' <ArgumentList> ')' | 'new' <ClassType> '(' ')' <ArgumentList> ::= <Expression> | <ArgumentList> ',' <Expression> <ArrayCreationExpression> ::= 'new' <PrimitiveType> <DimExprs> <Dims> | 'new' <PrimitiveType> <DimExprs> | 'new' <ClassOrInterfaceType> <DimExprs> <Dims> | 'new' <ClassOrInterfaceType> <DimExprs> <DimExprs> ::= <DimExpr> | <DimExprs> <DimExpr> <DimExpr> ::= '[' <Expression> ']' <Dims> ::= '[' ']' | <Dims> '[' ']' <FieldAccess> ::= <Primary> '.' Identifier | 'super' '.' Identifier <MethodInvocation> ::= <Name> '(' <ArgumentList> ')' | <Name> '(' ')' | <Primary> '.' Identifier '(' <ArgumentList> ')' | <Primary> '.' Identifier '(' ')' | 'super' '.' Identifier '(' <ArgumentList> ')' | 'super' '.' Identifier '(' ')' <ArrayAccess> ::= <Name> '[' <Expression> ']' | <PrimaryNoNewArray> '[' <Expression> ']' <PostfixExpression> ::= <Primary> | <Name> | <PostIncrementExpression> | <PostDecrementExpression> <PostIncrementExpression> ::= <PostfixExpression> '++' <PostDecrementExpression> ::= <PostfixExpression> '--' <UnaryExpression> ::= <PreIncrementExpression> | <PreDecrementExpression> | '+' <UnaryExpression> | '-' <UnaryExpression> | <UnaryExpressionNotPlusMinus> <PreIncrementExpression> ::= '++' <UnaryExpression> <PreDecrementExpression> ::= '--' <UnaryExpression> <UnaryExpressionNotPlusMinus> ::= <PostfixExpression> | '~' <UnaryExpression> | '!' <UnaryExpression> | <CastExpression> <CastExpression> ::= '(' <PrimitiveType> <Dims> ')' <UnaryExpression> | '(' <PrimitiveType> ')' <UnaryExpression> | '(' <Expression> ')' <UnaryExpressionNotPlusMinus> | '(' <Name> <Dims> ')' <UnaryExpressionNotPlusMinus> <MultiplicativeExpression> ::= <UnaryExpression> | <MultiplicativeExpression> '*' <UnaryExpression> | <MultiplicativeExpression> '/' <UnaryExpression> | <MultiplicativeExpression> '%' <UnaryExpression> <AdditiveExpression> ::= <MultiplicativeExpression> | <AdditiveExpression> '+' <MultiplicativeExpression> | <AdditiveExpression> '-' <MultiplicativeExpression> <ShiftExpression> ::= <AdditiveExpression> | <ShiftExpression> '<<' <AdditiveExpression> | <ShiftExpression> '>>' <AdditiveExpression> | <ShiftExpression> '>>>' <AdditiveExpression> <RelationalExpression> ::= <ShiftExpression> | <RelationalExpression> '<' <ShiftExpression> | <RelationalExpression> '>' <ShiftExpression> | <RelationalExpression> '<=' <ShiftExpression> | <RelationalExpression> '>=' <ShiftExpression> | <RelationalExpression> 'instanceof' <ReferenceType> <EqualityExpression> ::= <RelationalExpression> | <EqualityExpression> '==' <RelationalExpression> | <EqualityExpression> '!=' <RelationalExpression> <AndExpression> ::= <EqualityExpression> | <AndExpression> '&' <EqualityExpression> <ExclusiveOrExpression> ::= <AndExpression> | <ExclusiveOrExpression> '^' <AndExpression> <InclusiveOrExpression> ::= <ExclusiveOrExpression> | <InclusiveOrExpression> '|' <ExclusiveOrExpression> <ConditionalAndExpression> ::= <InclusiveOrExpression> | <ConditionalAndExpression> '&&' <InclusiveOrExpression> <ConditionalOrExpression> ::= <ConditionalAndExpression> | <ConditionalOrExpression> '||' <ConditionalAndExpression> <ConditionalExpression> ::= <ConditionalOrExpression> | <ConditionalOrExpression> '?' <Expression> ':' <ConditionalExpression> <AssignmentExpression> ::= <ConditionalExpression> | <Assignment> <Assignment> ::= <LeftHandSide> <AssignmentOperator> <AssignmentExpression> <LeftHandSide> ::= <Name> | <FieldAccess> | <ArrayAccess> <AssignmentOperator> ::= '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '>>>=' | '&=' | '^=' | '|=' <Expression> ::= <AssignmentExpression> <ConstantExpression> ::= <Expression>
JavaScript
JoCaml
Joy
JudoScript
Korn Shell
LSE64
LaTeX
LabVIEW
Lisaac
Lisp
! ----------------------------------------------------------------------- ! LISP ! ! LISt Programming ! ! "One can even conjecture that Lisp owes its survival specifically to the ! fact that its programs are lists, which everyone, including me, has ! regarded as a disadvantage." ! ! - John McCarthy, "Early History of Lisp" ! ! ! "Lisp is worth learning for the profound enlightenment experience you will ! have when you finally get it; that experience will make you a better programmer ! for the rest of your days, even if you never actually use Lisp itself a lot." ! ! - Eric Raymond, "How to Become a Hacker" ! ! ! "Lisp was far more powerful and flexible than any other language of its day; in ! fact, it is still a better design than most languages of today, twenty-five ! years later. Lisp freed ITS's hackers to think in unusual and creative ways. It ! was a major factor in their successes, and remains one of hackerdom's favorite ! languages." ! ! - Eric Raymond, in Open Sources on MIT's first OS, ITS ! ! The LISP programming language is one of the oldest still use today; second only to ! FORTRAN. It was invented by mathematician John McCarthy and organizes information into ! abstract "lists". This metaphor is used universially for both data and functions; ! in fact, the LISP runtime engine makes no differentiation between the two. This allows ! the programmer to perform actions that would be impossible in most programming languages ! such as, but not limited to, passing code as a parameter to a function, executing data, ! and modifying the program at runtime. ! ! For more information on LISP, please visit www.lisp.org. ! ! Updates: ! 3/5/2003: Added dotted pairs and backslash overrides to the language. ! ! Note: This is an ad hoc version of the language. If there are any flaws, ! please visit www.DevinCook.com/GOLDParser and I will update the grammar. ! ! ! ----------------------------------------------------------------------- "Name" = 'LISP' "Author" = 'John McCarthy' "Version" = 'Standard' "About" = 'LISP is an abstract language that organizes ALL data around "lists".' "Start Symbol" = <s-Expression> {Atom Char} = {Printable} - {Whitespace} - [()"\''] {String Char} = {Printable} - ["\] Atom = ( {Atom Char} | '\'{Printable} )+ String = '"' ( {String Char} | '\'{Printable} )* '"' <s-Expression> ::= <Quote> Atom | <Quote> '(' <Series> ')' | <Quote> '(' <s-Expression> '.' <s-Expression> ')' !Dotted Pair | String !Strings are never evaluated <Series> ::= <s-Expression> <Series> | <Quote> ::= '' !Quote = do not evaluate |
Logo
Logtalk
LotusScript
Lua
Lucid
M4
MAXScript
MIRC Scripting Language
MS SQL
Make
Maple
Mathematica
Maxima
Metafont
Modula-3
NewLISP
Nial
OCaml
Oberon-2
Object Pascal
Objective-C
Octave
Omega
OpenEdge/Progress
Oz
PHP
PL/I
PL/SQL
Pascal
! ----------------------------------------------------------------------- ! Standard Pascal Grammar ! ----------------------------------------------------------------------- "Name" = 'Pascal' "Version" = '1973' "Author" = 'Niklaus Wirth' "About" = 'PASCAL was developed by NIKLAUS WIRTH of the ETH Technical Institute of Zuerich in 1970-1971.(published in 1973)' "Case Sensitive" = False "Start Symbol" = <Program> {Hex Digit} = {Digit} + [abcdefABCDEF] {Id Head} = {Letter} + [_] {Id Tail} = {Id Head} + {Digit} {String Ch} = {Printable} - [''] {Char Ch} = {Printable} - [''] DecLiteral = [123456789]{digit}* HexLiteral = '$'{Hex Digit}+ FloatLiteral = {Digit}*.{Digit}+ StringLiteral = ''( {String Ch} | '\'{Printable} )* '' CharLiteral = '' ( {Char Ch} | '\'{Printable} )'' id = {Id Head}{Id Tail}* <constant> ::= DecLiteral | StringLiteral | FloatLiteral | HexLiteral | CharLiteral !=========================================== Program <Program> ::= <ProgramHeader> <Declarations> <CompoundStatement> '.' <ProgramHeader> ::= PROGRAM id ';' | PROGRAM id '(' <IdList> ')' ';' <Declarations> ::= <ConstantDefinitions> <TypeDefinitions> <VariableDeclarations> <ProcedureDeclarations> <ConstantDefinitions> ::= CONST <ConstantDefinitionList> | <ConstantDefinitionList> ::= <ConstantDef> | <ConstantDef> <ConstantDefinitionList> <ConstantDef> ::= id '=' <constant> ';' <TypeDefinitions> ::= TYPE <TypeDefinitionList> | <TypeDefinitionList> ::= <TypeDef> | <TypeDef> <TypeDefinitionList> <TypeDef> ::= id '=' <TypeSpecifier> ';' <VariableDeclarations> ::= VAR <VariableDeclarationList> | <VariableDeclarationList> ::= <VariableDec> | <VariableDec> <VariableDeclarationList> <VariableDec> ::= <IdList> ':' <TypeSpecifier> ';' <ProcedureDeclarations> ::= <ProcedureDec> <ProcedureDeclarations> | <ProcedureDec> ::= <ProcedureHeader> FORWARD ';' | <ProcedureHeader> <Declarations> <CompoundStatement> ';' | <FunctionHeader> FORWARD ';' | <FunctionHeader> <Declarations> <CompoundStatement> ';' <ProcedureHeader> ::= PROCEDURE id <Arguments> ';' <FunctionHeader> ::= FUNCTION id <Arguments> ':' <TypeSpecifier> ';' <Arguments> ::= '(' <ArgumentList> ')' | <ArgumentList> ::= <Arg> | <Arg> ';' <ArgumentList> <Arg> ::= <IdList> ':' <TypeSpecifier> | VAR <IdList> ':' <TypeSpecifier> <CompoundStatement> ::= BEGIN <StatementList> END <StatementList> ::= <Statement> | <Statement> ';' <StatementList> <Statement> ::= <CompoundStatement> | <AssignmentStatement> | <ProcedureCall> | <ForStatement> | <WhileStatement> | <IfStatement> | <CaseStatement> | <RepeatStatement> | <AssignmentStatement> ::= <Variable> ':=' <Expression> <ProcedureCall> ::= id <Actuals> <ForStatement> ::= FOR id ':=' <Expression> TO <Expression> DO <Statement> | FOR id ':=' <Expression> DOWNTO <Expression> DO <Statement> <WhileStatement> ::= WHILE <Expression> DO <Statement> <IfStatement> ::= IF <Expression> THEN <Statement> ELSE <Statement> <RepeatStatement> ::= REPEAT <StatementList> UNTIL <Expression> <CaseStatement> ::= CASE <Expression> OF <CaseList> END <CaseList> ::= <Case> | <Case> ';' <CaseList> <Case> ::= <ConstantList> ':' <Statement> <ConstantList> ::= <constant> | <constant> ',' <ConstantList> <Expression> ::= <SimpleExpression> | <SimpleExpression> '=' <SimpleExpression> | <SimpleExpression> '<>' <SimpleExpression> | <SimpleExpression> '<' <SimpleExpression> | <SimpleExpression> '<=' <SimpleExpression> | <SimpleExpression> '>' <SimpleExpression> | <SimpleExpression> '>=' <SimpleExpression> <SimpleExpression> ::= <Term> | <SimpleExpression> '+' <Term> | <SimpleExpression> '-' <Term> | <SimpleExpression> OR <Term> <Term> ::= <Factor> | <Term> '*' <Factor> | <Term> '/' <Factor> | <Term> 'DIV' <Factor> | <Term> 'MOD' <Factor> | <Term> 'AND' <Factor> <Factor> ::= '(' <Expression> ')' | '+' <Factor> | '-' <Factor> | NOT <Factor> | <constant> | <Variable> <FunctionCall> ::= id <Actuals> <Actuals> ::= '(' <ExpressionList> ')' | <ExpressionList> ::= <Expression> | <Expression> ',' <ExpressionList> <Variable> ::= id | <Variable> '.' id | <Variable> '^' | <Variable> '[' <ExpressionList> ']' <TypeSpecifier> ::= id | '^' <TypeSpecifier> | '(' <IdList> ')' | <constant> '..' <constant> | ARRAY '[' <DimensionList> ']' OF <TypeSpecifier> | RECORD <FieldList> END | FILE OF <TypeSpecifier> <DimensionList> ::= <Dimension> | <Dimension> ',' <DimensionList> <Dimension> ::= <constant> '..' <constant> | id <FieldList> ::= <Field> | <Field> ';' <FieldList> <Field> ::= <IdList> ':' <TypeSpecifier> <IdList> ::= id | id ',' <IdList>
Perl
Pike
Plain TeX
Pop11
PostScript
PowerShell
Prolog
Python
Q
R
REXX
RapidQ
Raven
Rhope
Ruby
SAS
SETL
SMEQL
SNUSP
SQL
Scala
Scheme
Script3D
Seed7
Self
Slate
Smalltalk
Standard ML
TI-83 BASIC
TI-89 BASIC
Tcl
Toka
Tr
Transact-SQL
Twelf
UNIX Shell
UnixPipes
Unlambda
V
VBScript
Vedit macro language
Visual Basic
Visual Basic .NET
! ----------------------------------------------------------------------- ! Visual Basic .NET ! ! Visual Basic .NET is the latest version in the long evoluation of the ! BASIC programming language. The Visual Basic .NET programming language ! is far more "clean" and orthagonal than its predecessors. Although some ! of the old constructs exist, the language is far easier to read and write. ! ! Major syntax changes include, but are not limited to: ! ! 1. The primative file access of VB6 was replaced by a class library. As ! a result, special statements such as ! ! Open "test" For Input As #1 ! ! no longer exist. ! ! 2. Class module files were replaced by 'Class ... End Class' declarations ! ! 3. Module files were replaced by 'Module ... End Module' declarations ! ! 4. Structured error handling was added with C++ style Try ... Catch ! statements. The old nonstructured approach is still, unfortunately, ! available. ! ! Unfortnately, the designers of Visual Basic .NET did not remove the ! datatype postfix characters on identifiers. In the original BASIC, ! variables types were determined by $ for strings and % for integers. ! QuickBasic expanded the postix notation to include other symbols ! for long integers, singles, etc... ! ! Part of the ID terminal definition was commented out to prevent the ! old format. You can allow the postfix characters if you like. ! ! This grammar also does not contain the compiler directives. ! ! Note: This is an ad hoc version of the language. If there are any flaws, ! please visit www.DevinCook.com/GOLDParser ! ! Updates: ! 04/082005 ! Devin Cook ! 1. Removed minus sign from the IntLiteral and RealLiteral ! definitions. These can cause some parse errors when expressions ! like "2-2" are read. In this case it would have been interpreted ! as "2" and "-2" rather than "2", "-" and "2". ! 2. Members of an enumeration can be defined with any expression. ! 3. Made some very minor comment changes - mainly for readability. ! ! 03/27/2005 ! Adrian Moore [adrianrob@hotmail.com] ! 1. Add support for Implements in Class ! 2. Add support for AddressOf keyword ! 3. No longer fails if variable starts with _ ! ! 02/24/2004 ! Vladimir Morozov [vmoroz@hotmail.com] fixed a few flaws in the ! grammar. 1. The definition for strings did not allow the double ! double-quote override. 2. A real literal does not need to have a ! fraction if followed by an exponent. 3. Escaped identifiers can ! contain a null string and 4. Rem works the same as the ' ! ! ! USE GOLD PARSER BUILDER VERSION 2.1 AND LATER TO COMPILE THIS GRAMMAR. ! Earlier versions cannot handle the complexity. ! ----------------------------------------------------------------------- "Name" = 'Visual Basic .NET' "Author" = 'John G. Kemeny and Thomas E. Kurtz' "Version" = '.NET' "About" = 'Visual Basic .NET is the latest version in the long evoluation of the' | 'BASIC programming language.' "Case Sensitive" = False "Start Symbol" = <Program> ! ----------------------------------------------------------------- Sets {String Chars} = {Printable} - ["] {Date Chars} = {Printable} - [#] {ID Name Chars} = {Printable} - ['['']'] {Hex Digit} = {Digit} + [abcdef] {Oct Digit} = [01234567] {WS} = {Whitespace} - {CR} - {LF} {Id Tail} = {Alphanumeric} + [_] ! ----------------------------------------------------------------- Terminals NewLine = {CR}{LF} | {CR} | ':' Whitespace = {WS}+ | '_' {WS}* {CR} {LF}? Comment Line = '' | Rem !Fixed by Vladimir Morozov LABEL = {Letter}{ID Tail}*':' !Fixed by Vladimir Morozov ID = [_]?{Letter}{ID Tail}* ! [%&@!#$]? !Archaic postfix chars | '[' {ID Name Chars}* ']' QualifiedID = ({Letter}{ID Tail}* | '['{ID Name Chars}*']') ( '.'({Letter}{ID Tail}* | '['{ID Name Chars}*']') )+ MemberID = '.' {Letter}{ID Tail}* | '.[' {ID Name Chars}* ']' !Fixed by Vladimir Morozov StringLiteral = '"' ( {String Chars} | '""' )* '"' CharLiteral = '"' {String Chars}* '"C' IntLiteral = {digit}+ [FRDSIL]? RealLiteral = {digit}* '.' {digit}+ ( 'E' [+-]? {Digit}+ )? [FR]? | {digit}+ 'E' [+-]? {Digit}+ [FR]? DateLiteral = '#'{Date chars}'#' HexLiteral = '&H'{Hex Digit}+ [SIL]? OctLiteral = '&O'{Oct Digit}+ [SIL]? ! ----------------------------------------------------------------- Rules <Program> ::= <NameSpace Item> <Program> | <Imports> <Program> | <Option Decl> <Program> | ! ------------------------------------------------------------------- ! (Shared attributes) ! ------------------------------------------------------------------- <NL> ::= NewLine <NL> | NewLine <Modifiers> ::= <Modifier> <Modifiers> | <Modifier> ::= Shadows | Shared | MustInherit | NotInheritable | Overridable | NotOverridable | MustOverride | Overrides | Overloads | Default | ReadOnly | WriteOnly | <Access> <Access Opt> ::= <Access> | <Access> ::= Public | Private | Friend | Protected <Var Member> ::= <Attributes> <Access> <Var Decl> <NL> !Variables | <Attributes> <Access Opt> Const <Var Decl> <NL> !Constants | <Attributes> <Access Opt> Static <Var Decl> <NL> <Implements> ::= Implements <ID List> <ID List> ::= <Identifier> ',' <ID List> | <Identifier> <Option Decl> ::= Option <IDs> <NL> <IDs> ::= ID <IDs> | ID <Type> ::= As <Attributes> <Identifier> | <Compare Op> ::= '=' | '<>' | '<' | '>' | '>=' | '<=' ! ------------------------------------------------------------------- ! NameSpace ! ------------------------------------------------------------------- <NameSpace> ::= NameSpace ID <NL> <NameSpace Items> End NameSpace <NL> <NameSpace Items> ::= <NameSpace Item> <NameSpace Items> | <NameSpace Item> ::= <Class> | <Declare> | <Delegate> | <Enumeration> | <Interface> | <Structure> | <Module> | <Namespace> ! ------------------------------------------------------------------- ! Attributes ! ------------------------------------------------------------------- <Attributes> ::= '<' <Attribute List> '>' | <Attribute List> ::= <Attribute> ',' <Attribute List> | <Attribute> <Attribute> ::= <Attribute Mod> ID <Argument List Opt> <Attribute Mod> ::= Assembly | Module | ! ------------------------------------------------------------------- ! Delegates ! ------------------------------------------------------------------- <Delegate> ::= <Attributes> <Modifiers> Delegate <Method> | <Attributes> <Modifiers> Delegate <Declare> ! ------------------------------------------------------------------- ! Imports ! ------------------------------------------------------------------- <Imports> ::= Imports <Identifier> <NL> | Imports ID '=' <Identifier> <NL> ! ------------------------------------------------------------------- ! Events ! ------------------------------------------------------------------- <Event Member> ::= <Attributes> <Modifiers> Event ID <Parameters Or Type> <Implements Opt> <NL> <Parameters Or Type> ::= <Param List> | As <Identifier> <Implements Opt> ::= <Implements> | ! ------------------------------------------------------------------- ! Class ! ------------------------------------------------------------------- <Class> ::= <Attributes> <Modifiers> Class ID <NL> <Class Items> End Class <NL> <Class Items> ::= <Class Item> <Class Items> | <Class Item> ::= <Declare> | <Method> | <Property> | <Var Member> | <Enumeration> | <Inherits> | <Class Implements> <Inherits> ::= Inherits <Identifier> <NL> <Class Implements> ::= Implements <ID List> <NL> ! ------------------------------------------------------------------- ! Structures ! ------------------------------------------------------------------- <Structure> ::= <Attributes> <Modifiers> Structure ID <NL> <Structure List> End Structure <NL> <Structure List> ::= <Structure Item> <Structure List> | <Structure Item> ::= <Implements> | <Enumeration> | <Structure> | <Class> | <Delegate> | <Var Member> | <Event Member> | <Declare> | <Method> | <Property> ! ------------------------------------------------------------------- ! Module ! ------------------------------------------------------------------- <Module> ::= <Attributes> <Modifiers> Module ID <NL> <Module Items> End Module <NL> <Module Items> ::= <Module Item> <Module Items> | <Module Item> ::= <Declare> | <Method> | <Property> | <Var Member> | <Enumeration> | <Option Decl> ! ------------------------------------------------------------------- ! Interface ! ------------------------------------------------------------------- <Interface> ::= <Attributes> <Modifiers> Interface ID <NL> <Interface Items> End Interface <NL> <Interface Items> ::= <Interface Item> <Interface Items> | <Interface Item> ::= <Implements> | <Event Member> | <Enum Member> | <Method Member> | <Property Member> <Enum Member> ::= <Attributes> <Modifiers> Enum ID <NL> <Method Member> ::= <Attributes> <Modifiers> Sub <Sub ID> <Param List> <Handles Or Implements> <NL> | <Attributes> <Modifiers> Function ID <Param List> <Type> <Handles Or Implements> <NL> <Property Member> ::= <Attributes> <Modifiers> Property ID <Param List> <Type> <Handles Or Implements> <NL> ! ------------------------------------------------------------------- ! Parameters ! ------------------------------------------------------------------- <Param List Opt> ::= <Param List> | <Param List> ::= '(' <Param Items> ')' | '(' ')' <Param Items> ::= <Param Item> ',' <Param Items> | <Param Item> <Param Item> ::= <Param Passing> ID <Type> <Param Passing> ::= ByVal | ByRef | Optional | ParamArray | ! ------------------------------------------------------------------- ! Arguments ! ------------------------------------------------------------------- <Argument List Opt> ::= <Argument List> | <Argument List> ::= '(' <Argument Items> ')' <Argument Items> ::= <Argument> ',' <Argument Items> | <Argument> <Argument> ::= <Expression> | Id ':=' <Expression> | !NULL ! ------------------------------------------------------------------- ! Declares (External Procedures) ! ------------------------------------------------------------------- <Declare> ::= <Attributes> <Modifiers> Declare <Charset> Sub ID Lib StringLiteral <Alias> <Param List Opt> <NL> | <Attributes> <Modifiers> Declare <Charset> Function ID Lib StringLiteral <Alias> <Param List Opt> <Type> <NL> <Charset> ::= Ansi | Unicode | Auto | !Null <Alias> ::= Alias StringLiteral | ! ------------------------------------------------------------------- ! Methods ! ------------------------------------------------------------------- <Method> ::= <Attributes> <Modifiers> Sub <Sub ID> <Param List> <Handles Or Implements> <NL> <Statements> End Sub <NL> | <Attributes> <Modifiers> Function ID <Param List> <Type> <Handles Or Implements> <NL> <Statements> End Function <NL> <Sub ID> ::= ID | New !Class creation <Handles Or Implements> ::= <Implements> | <Handles> | <Handles> ::= Handles <ID List> ! ------------------------------------------------------------------- ! Properties ! ------------------------------------------------------------------- <Property> ::= <Attributes> <Modifiers> Property ID <Param List> <Type> <NL> <Property Items> End Property <NL> <Property Items> ::= <Property Item> <Property Items> | <Property Item> ::= Get <NL> <Statements> End Get <NL> | Set <Param List> <NL> <Statements> End Set <NL> ! ------------------------------------------------------------------- ! Enumerations ! ------------------------------------------------------------------- <Enumeration> ::= <Attributes> <Modifiers> Enum ID <NL> <Enum List> End Enum <NL> <Enum List> ::= <Enum Item> <Enum List> | <Enum Item> ::= Id '=' <Expression> <NL> | Id <NL> ! ------------------------------------------------------------------- ! Variable Declaration ! ------------------------------------------------------------------- <Var Decl> ::= <Var Decl Item> ',' <Var Decl> | <Var Decl Item> <Var Decl Item> ::= <Var Decl ID> As <Identifier> <Argument List Opt> | <Var Decl ID> As <Identifier> '=' <Expression> !Initialize | <Var Decl ID> As New <Identifier> <Argument List Opt> | <Var Decl ID> | <Var Decl ID> '=' <Expression> !Initialize <Var Decl ID> ::= ID <Argument List Opt> ! ------------------------------------------------------------------- ! Normal Statements ! ------------------------------------------------------------------- <Statements> ::= <Statement> <Statements> | <Statement> ::= <Loop Stm> | <For Stm> | <If Stm> | <Select Stm> | <SyncLock Stm> | <Try Stm> | <With Stm> | <Option Decl> | <Local Decl> | <Non-Block Stm> <NL> !Note the <NL>. A non-block statement can be a full statement | LABEL <NL> <Non-Block Stm> ::= Call <Variable> | ReDim <Var Decl> | ReDim Preserve <Var Decl> | Erase ID | Throw <Value> | RaiseEvent <Identifier> <Argument List Opt> | AddHandler <Expression> ',' <Expression> | RemoveHandler <Expression> ',' <Expression> | Exit Do | Exit For | Exit Function | Exit Property | Exit Select | Exit Sub | Exit Try | Exit While | GoTo ID !Argh - they still have this | Return <Value> | Error <Value> !Raise an error by number | On Error GoTo IntLiteral ! 0 This is obsolete. | On Error GoTo '-' IntLiteral !-1 This is obsolete. | On Error GoTo Id | On Error Resume Next | Resume ID | Resume Next | <Variable> <Assign Op> <Expression> | <Variable> | <Method Call> <Assign Op> ::= '=' | '^=' | '*=' | '/=' | '\=' | '+=' | '-=' | '&=' | '<<=' | '>>=' ! ------------------------------------------------------------------- ! Local declarations ! ------------------------------------------------------------------- <Local Decl> ::= Dim <Var Decl> <NL> | Const <Var Decl> <NL> | Static <Var Decl> <NL> ! ------------------------------------------------------------------- ! Do Statement ! ------------------------------------------------------------------- <Loop Stm> ::= Do <Test Type> <Expression> <NL> <Statements> Loop <NL> | Do <NL> <Statements> Loop <Test Type> <Expression> <NL> | While <Expression> <NL> <Statements> End While <NL> <Test Type> ::= While | Until ! ------------------------------------------------------------------- ! For Statement ! ------------------------------------------------------------------- <For Stm> ::= For <Identifier> '=' <Expression> To <Expression> <Step Opt> <NL> <Statements> Next <NL> | For Each <Variable> In <Variable> <NL> <Statements> Next <NL> <Step Opt> ::= Step <Expression> | ! ------------------------------------------------------------------- ! If Statement ! ------------------------------------------------------------------- <If Stm> ::= If <Expression> <Then Opt> <NL> <Statements> <If Blocks> End If <NL> | If <Expression> Then <Non-Block Stm> <NL> | If <Expression> Then <Non-Block Stm> Else <Non-Block Stm> <NL> <Then Opt> ::= Then !!The reserved word 'Then' is optional for Block-If statements | <If Blocks> ::= ElseIf <Expression> <Then Opt> <NL> <Statements> <If Blocks> | Else <NL> <Statements> | ! ------------------------------------------------------------------- ! Select Statement ! ------------------------------------------------------------------- <Select Stm> ::= Select <Case Opt> <Expression> <NL> <Select Blocks> End Select <NL> <Case Opt> ::= Case !!The "Case" after Select is optional in VB.NEt | <Select Blocks> ::= Case <Case Clauses> <NL> <Statements> <Select Blocks> | Case Else <NL> <Statements> | <Case Clauses> ::= <Case Clause> ',' <Case Clauses> | <Case Clause> <Case Clause> ::= <Is Opt> <Compare Op> <Expression> | <Expression> | <Expression> To <Expression> <Is Opt> ::= Is | !Null ! ------------------------------------------------------------------- ! SyncLock Statement ! ------------------------------------------------------------------- <SyncLock Stm> ::= SyncLock <NL> <Statements> End SyncLock <NL> ! ------------------------------------------------------------------- ! Try Statement ! ------------------------------------------------------------------- <Try Stm> ::= Try <NL> <Statements> <Catch Blocks> End Try <NL> <Catch Blocks> ::= <Catch Block> <Catch Blocks> | <Catch Block> <Catch Block> ::= Catch <Identifier> As ID <NL> <Statements> | Catch <NL> <Statements> ! ------------------------------------------------------------------- ! With Statement ! ------------------------------------------------------------------- <With Stm> ::= With <Value> <NL> <Statements> End With <NL> ! ------------------------------------------------------------------- ! Expressions ! ------------------------------------------------------------------- <Expression> ::= <And Exp> Or <Expression> | <And Exp> OrElse <Expression> | <And Exp> XOr <Expression> | <And Exp> <And Exp> ::= <Not Exp> And <And Exp> | <Not Exp> AndAlso <And Exp> | <Not Exp> <Not Exp> ::= NOT <Compare Exp> | <Compare Exp> <Compare Exp> ::= <Shift Exp> <Compare Op> <Compare Exp> !e.g. x < y | TypeOf <Add Exp> Is <Object> | <Shift Exp> Is <Object> | <Shift Exp> Like <Value> | <Shift Exp> <Shift Exp> ::= <Concat Exp> '<<' <Shift Exp> | <Concat Exp> '>>' <Shift Exp> | <Concat Exp> <Concat Exp> ::= <Add Exp> '&' <Concat Exp> | <Add Exp> <Add Exp> ::= <Modulus Exp> '+' <Add Exp> | <Modulus Exp> '-' <Add Exp> | <Modulus Exp> <Modulus Exp> ::= <Int Div Exp> Mod <Modulus Exp> | <Int Div Exp> <Int Div Exp> ::= <Mult Exp> '\' <Int Div Exp> | <Mult Exp> <Mult Exp> ::= <Negate Exp> '*' <Mult Exp> | <Negate Exp> '/' <Mult Exp> | <Negate Exp> <Negate Exp> ::= '-' <Power Exp> | <Power Exp> <Power Exp> ::= <Power Exp> '^' <Value> | <Value> <Value> ::= '(' <Expression> ')' | New <Identifier> <Argument List Opt> | IntLiteral | HexLiteral | OctLiteral | StringLiteral | CharLiteral | RealLiteral | DateLiteral | True | False | Me | MyClass | MyBase | Nothing | <Variable> | AddressOf <Identifier> <Object> ::= <Identifier> !Object identifiers | Me | MyClass | MyBase | Nothing <Variable> ::= <Identifier> <Argument List Opt> <Method Calls> <Method Calls> ::= <Method Call> <Method Calls> | <Method Call> ::= MemberID <Argument List Opt> <Identifier> ::= ID | QualifiedID !Any type of identifier
Visual Objects
Wrapl
XSLT
XTalk
- Programming Tasks
- BNF GRAMMAR
- 4D
- ALGOL 60
- ALGOL 68
- APL
- AWK
- ActionScript
- Ada
- Agda2
- AmigaE
- AppleScript
- Assembly
- AutoHotkey
- BASIC
- Bc
- Befunge
- Brainf***
- C
- C sharp
- C++
- Caml
- Clean
- Clojure
- Cobol
- ColdFusion
- Common Lisp
- Component Pascal
- Coq
- D
- DOS Batch File
- Dc
- Delphi
- E
- EC
- ELLA
- ESQL
- Eiffel
- Emacs Lisp
- Erlang
- F
- F Sharp
- FALSE
- FP
- Factor
- Fan
- Forth
- Fortran
- GAP
- Gnuplot
- Groovy
- HaXe
- Haskell
- IDL
- Icon
- Io
- J
- JSON
- JScript.NET
- Java
- JavaScript
- JoCaml
- Joy
- JudoScript
- Korn Shell
- LSE64
- LaTeX
- LabVIEW
- Lisaac
- Lisp
- Logo
- Logtalk
- LotusScript
- Lua
- Lucid
- M4
- MAXScript
- MIRC Scripting Language
- MS SQL
- Make
- Maple
- Mathematica
- Maxima
- Metafont
- Modula-3
- NewLISP
- Nial
- OCaml
- Oberon-2
- Object Pascal
- Objective-C
- Octave
- Omega
- OpenEdge/Progress
- Oz
- PHP
- PL/I
- PL/SQL
- Pascal
- Perl
- Pike
- PlainTeX
- Pop11
- PostScript
- PowerShell
- Prolog
- Python
- Q
- R
- REXX
- RapidQ
- Raven
- Rhope
- Ruby
- SAS
- SETL
- SMEQL
- SNUSP
- SQL
- Scala
- Scheme
- Script3D
- Seed7
- Self
- Slate
- Smalltalk
- Standard ML
- TI-83 BASIC
- TI-89 BASIC
- Tcl
- Toka
- Tr
- Transact-SQL
- Twelf
- UNIX Shell
- UnixPipes
- Unlambda
- V
- VBScript
- Vedit macro language
- Visual Basic
- Visual Basic .NET
- Visual Objects
- Wrapl
- XSLT
- XTalk