Scribd Logo
Upload

Welcome to Scribd!

  • CFGS (AutoRecovered) - 2

    Uploaded by

    Bilal Ahmed
    18 views10 pages
    The document describes the grammar for defining classes and methods in an object-oriented programming language. It specifies the structure and components of classes, methods, and other programming elements through a set of rules and syntax.

    Original Description:

    Original Title

    CFGS (AutoRecovered)-2

    Copyright

    © © All Rights Reserved

    Available Formats

    DOCX, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    Report this Document
    The document describes the grammar for defining classes and methods in an object-oriented programming language. It specifies the structure and components of classes, methods, and other programming elements through a set of rules and syntax.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Flag for inappropriate content
    18 views10 pages

    CFGS (AutoRecovered) - 2

    Uploaded by

    Bilal Ahmed
    The document describes the grammar for defining classes and methods in an object-oriented programming language. It specifies the structure and components of classes, methods, and other programming elements through a set of rules and syntax.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Flag for inappropriate content
    of 10

    <S_CstNM> -->}<Main_Done>

    --> function <PubPriv'> static <function_sig> <S_CstNM>


    --> private static <Class_Vars> <S_CstNM>
    --> static class ID <Inherit> { <S_Cst> --> <Public'> static <ConsVar> <S_CstNM>
    <Structure> --> abstract class ID <Inherit> { <C_Cst>
    --> Sealed class ID { <S_Cst>

    <EOF> -->~

    <Inherit> --> : ID <ConsVar> --> DT <N_Dec>


    --> ε --> ID <ConsVar'>

    <S_Cst> --> } <Structure> <ConsVar'> --> ( <AL> ) <Body_MST>


    --> function <PubPriv'> static <function_sig> <S_Cst> --> ID <Object'>
    --> private static <Class_Vars> <S_Cst> --> [dim] <O_Arr'>
    --> <Public'> static <S_Cst'>
    --> } <Structure>
    --> DT <S_CstDT> <C_Cst> --> <PrivPres> <SC> <Class_Vars> <C_Cst>
    <S_Cst'> --> ID <S_CstID> --> function <AM> <Types> <C_Cst>
    --> void Main <S_Main> --> <Class_Vars> <C_Cst>
    --> <Public'> <C_Cst'>

    <S_CstDT> --> ID <Declare'> <S_Cst> <C_Cst'> --> static <C_Cst''>


    --> [<dim>] <S_CstDT'>
    --> Main <S_Main>

    --> DT <C_CstDT>
    <C_Cst''> --> ID <C_CstID>
    --> void Main <GC_Main>
    <S_CstDT'> --> ID <G_Arr'> <S_Cst>
    --> Main <S_Main>

    <S_CstID> --> ID <Object'> <S_Cst> <C_CstDT> --> ID <Declare'> <C_Cst>


    --> [<dim>] <S_CstID'> --> [<dim>] <C_CstDT'>
    --> Main <S_Main> --> void Main <GC_Main>
    --> () <Body_MST> <S_Cst>

    <S_CstID'> --> ID <O_Arr'> <S_Cst>


    --> Main <S_Main>
    --> Main <GC_Main>
    <S_Main> -->(<PL>)<BodyMST><S_CstNM>
    <C_CstDT'> --> ID <G_Arr'> <C_Cst> <ConCond’> -->abstract
    --> Main <GC_Main> -->$

    C_CstID> --> ID <Object'> <C_Cst>


    --> [<dim>] <C_CstID'>
    --> Main <GC_Main>
    --> ( <AL> ) <Body_MST> <C_Cst>

    <C_CstID'> --> ID <O_Arr'> <C_Cst>


    --> Main <GC_Main>

    <GC_Main> -->(<AL>)<Body_MST><GC_Nst>
    <GC_Nst> --> function <AM> <Types> <GC_Nst>
    --> }<Main_Done>
    --> <PrivPres> <SC> <Class_Vars> <GC_Nst>
    --> <Public'> <GC_ConsVar> <GC_Nst>

    <Main_Done> -->$
    --> static class ID <Inherit> { <S_CstNM>
    --> sealed class ID <Inherit> { <S_CstNM>

    <AssignOp> --> =
    --> Compound_Assign
    <GC_ConsVar> --> <Static'> <ConsVar>
    <Static’> --> static | $ <Ref> --> . ID <Ref>
    --> ( <PL> ) . ID <Ref>
    --> [ <Exp> ] <Ref>
    --> $
    <SST> --> <For_St> <SST_2> --> ;
    --> <If_St> --> . ID <SST_ID'>
    --> <While_St>
    --> <DoWhile_St>
    --> <Return_St> <Break> --> Break ;
    --> <Continue> <Continue> --> Continue ;
    --> <Break>
    --><Try_St>
    --> inc_dec <SP'> ID <Ref> ; <While_St> --> While ( <Exp> ) <Body>
    --> <SP> ID <Ref> <AssignOP> <Exp> ; <Body> --> ;
    --> DT <N_Dec> --> <BodyMST>
    --> ID <SST_ID> <DoWhile_St> -->do<BodyMST>while(<Exp>)

    <Try_St> -->try<BodyMST><CatchFinally>
    <CatchFinally> --><Finally>
    --><Catch><Finally’>

    <Finally> -->finally<BodyMST>
    <Finally’> -->finally<BodyMST>
    -->$
    <Catch> -->catch(<Exception> ID) <BodyMST><Catch’>
    <Catch’> --><Catch>
    -->$
    <Switch_St> -->Switch (ID) {<Switch_Body>}
    <Switch_Body> --><Case> <Default>
    <Case> -->case (<Const>) : <MST> <Case>
    -->$
    <Default> -->default : <MST> <Case>
    -->$
    <SST_ID> --> ID <Object'> <value'> --> ;
    --> <SST_ID'> --> ,ID<
    <SST_ID'> --> . ID <SST_ID'>
    --> [ <Exp> ] <SST_1> <Z> --> { <Y>
    --> ( <PL> ) <SST_2> --> $

    <Y> --><Z’>}
    --><Val_GArr>}

    --> inc_dec ; <Z’> --> {<Val_GArr>} <Z’’>


    --> <AssignOp> <Exp> ; --> $

    <Z’’> --> , {<Val_GArr> } <Z’’>


    --> $

    <SST_1> --> . ID <SST_ID'>


    --> inc_dec ;
    --> <AssignOp> <Exp> ;
    --> ;
    <If_St> --> if ( <Exp> ) <BodyMST> <OElse> --> [ <Exp> ] <For_Opt'>
    <OElse> --> else <OElse'> --> ( <PL> ) . ID <For_Opt>
    --> $ --> inc_dec <For_Opt''>

    <OElse'> --> if ( <Exp> ) <BodyMST> <OElse> --> <AssignOp> <Exp> <For_Opt''>


    --> <BodyMST>
    <For_Opt'> --> . ID <For_Opt>
    <For_St> --> For ( <St1> <St2> ; <St3> ) <Body> --> inc_dec <For_Opt''>
    <St1> --> <Dec> --> <AssignOp> <Exp> <For_Opt''>
    --> <AssignSt> <For_Opt''> --> $
    --> ; --> , ID <For_Opt>

    <Dec> --> DT ID <Declare'>

    <AssignSt> --> <SP'> ID <Ref> <AssignOP> <Exp> ;


    <St2> --> $
    --> <Cond>
    <St3> --> inc_dec <Var>
    --> ID <For_Opt>
    --> $

    <Cond> --> ID <Cond'>


    --> <Const> <Cond'>

    --> $
    <Cond'> --> ROR <Exp>

    <Return> --> return <Ret'> ; <Public'> --> Public


    --> $

    <Ret'> --> $ <RT'> --> [<dim>]


    --> <Exp> --> $
    <For_Opt> --> . ID <For_Opt>
    <RT> --> DT <RT'>
    --> ID <RT'>

    --> Void

    <AL> --> $
    --> <AL'>

    <AL'> --> ID <AL'''> ID <AL''>


    --> DT <AL'''> ID <AL''> <N_Dec> --> ID <Declare'>
    --> [<dim> ] ID <G_Arr'>
    <Al''> --> $ <O_Dec> --> ID <Object'>
    --> , <AL'> --> [<dim> ] ID <O_Arr'>

    <AL'''> --> $ <Declare'> --> ;


    --> [<dim>] --> , ID <Declare'>
    --> = <Init_List>

    <<PubPriv'> --> Public <G_Arr'> --> ;


    --> , ID <G_Arr'>
    --> Private --> = <Init_GArr> <G_Arr'>
    --> $
    <dim> --> ,
    --> $
    <function_sig> --> <RT> ID ( <AL> ) <Body_MST> <Init_GArr> --> ID
    --> new DT [ <Init_GArr'>
    <Class_Vars> --> DT <N_Dec> <Init_GArr'> --> <dim>] <Z>
    --> ID <O_Dec> --> <PL>] <Z>

    <Val_GArr> --> $
    --> <Const> <Val_GArr'>
    <Val_GArr'> --> $ <B'> --> && <C> <B'>
    --> , <Const> <Val_GArr'> <C> --> $
    --> <E> <C'>
    <Init_List'> --> ;
    --> , ID <Declare> <C'> --> ROR <E> <C'>
    --> $
    <Init_List> --> <SP'> ID <List1> <E> --> <T> <E'>
    --> <Const> <List2> <E'> --> PM <T> <E’>
    --> ( <Exp> ) <List2> --> $

    --> ! <F> <Init_List'> <T> --> <F> <T'>


    <T'> --> MDM <F> <T'>
    --> $

    <List1> --> = <Init_List> <F> --> ( <Exp> )


    --> . ID <List1> --> <Const>
    --> [ <Exp> ] <List3> --> ! <F>
    --> ( <PL> ) <List2> --> <SP'> ID <OptF>

    --> inc_dec <List2> <SP> --> this .


    --> <List2> --> base .
    <List2> --> <T'> <E'> <C'> <B'> <A> <Init_List'> <SP'> --> this.
    --> base .
    --> $
    <List3> --> = <Init_List> <SC> --> Static
    --> . ID <List1> --> $
    --> inc_dec <List2>
    --> <List2> <OptF> --> . ID <OptF>
    --> $
    <Exp> --> <B> <A> <Val_OArr'> --> ,F new ID ( <PL> ) <Val_OArr'>
    --> $
    <A> --> || <B> <A> <PL> --> $
    --> $ --> <Exp> <PL'>
    <B> --> <C> <B'> <PL'> --> , <Exp> <PL'>
    --> $
    --> [ <Exp> ] <OptF> <function_sig> --> <RT> ID ( <AL> ) <BodyMST>
    --> ( <PL> ) <OptF2> <AM> --> Public
    --> inc_dec --> Private
    --> $ --> Protected
    <OptF1> --> inc_dec --> override
    --> . ID <OptF> --> $
    <Types> -- > abstract <RT>ID (<AL>);
    --> <SC> <function_sig>
    <OptF2> --> . ID <OptF> <PrivPres> --> Protected
    --> $ --> Private
    <Body_MST> --> { <MST> }
    <MST> --> <SST> <MST>
    --> $

    <Object'> --> ; <Const> --> Int_Const


    --> , ID <Object'> --> Float_Const
    --> = <Init_Obj> <Object'> --> String_Const
    <Init_Obj> --> new ID ( <PL> ) --> Char_Const
    --> ID --> Bool_Const
    <O_Arr'> --> ;
    --> , ID <O_Arr'>
    --> = <Init_OArr> <O_Arr'>
    <Init_OArr'> --> ID
    --> new ID [ <Init_OArr'>
    <Init_OArr'> --> ] <W>
    --> <PL> ] <W>
    <Val_OArr> --> new ID (<PL> ) <Val_OArr'>

    <W> --> { <X>


    --> $

    <X> --><W’>}
    --><Val_OArr>}
    <W’> --> {<Val_OArr> } <W’’>
    --> $

    <W’’> --> , {<Val_OArr> } <W’’>


    --> $

    You might also like