p4-16-allowed-constructs.dot

digraph p4_16_allowed_construct_nesting {

    node [shape=box];
    rankdir=LR;

    toplevel [label="top level"];
    legend_bold_orange_box [label="Things inside dashed lines\nare either only allowed in,\nor most useful within,\narchitecture model files." style=dashed color=orange];

    toplevel -> typeDeclaration;
    typeDeclaration [label="type declarations for\nparser, control, package" style=dashed color=orange];
    toplevel -> externDeclaration;
    externDeclaration [label="extern function and\n object declarations" style=dashed color=orange];
    toplevel -> parserDeclaration;
    parserDeclaration [label="parser"];
    toplevel -> constantDeclaration1;
    constantDeclaration1 [label="const"];
    toplevel -> typedefDeclaration;
    typedefDeclaration [label="typedef"];
    toplevel -> headerTypeDeclaration;
    headerTypeDeclaration [label="header"];
    toplevel -> headerUnionDeclaration;
    headerUnionDeclaration [label="header_union"];
    toplevel -> structTypeDeclaration;
    structTypeDeclaration [label="struct"];
    toplevel -> enumErrorMatchKindDeclaration;
    enumErrorMatchKindDeclaration [label="enum\nerror\nmatch_kind"];
    toplevel -> Instantiation;
    Instantiation [label="instantiation of:\nextern object\nparser value set\npackage (there\nmust be one\ncalled 'main')"];
    toplevel -> functionDefinition;
    functionDefinition [label="function definition"];
    toplevel -> actionDeclaration;
    actionDeclaration [label="action"];
    toplevel -> controlDeclaration;
    controlDeclaration [label="control"];

    // this is 'parser <name> (<parameters>) { ... }'
    parserDeclaration -> constantOrVariableDeclaration2;
    constantOrVariableDeclaration2 [label="const, variable decl"];
    parserDeclaration -> Instantiation2;
    Instantiation2 [label="instantiation of:\nextern object\nparser\nparser value set"];
    parserDeclaration -> parserState;

    parserState [label="state"];
    parserState -> constantOrVariableDeclaration3;
    constantOrVariableDeclaration3 [label="const, variable decl"];
    parserState -> assignmentActionMethodCallStatement3;
    assignmentActionMethodCallStatement3 [label="assignment\nfunction call\nextern call\nNO: action call, switch, exit"];
    parserState -> parserApplyCallStatement3;
    parserApplyCallStatement3 [label="<subparser>.apply()"];
    parserState -> blockStatement3;
    blockStatement3 [label="block statement\n{ ... }"];
    blockStatement3 -> blockStatementInParserState;
    blockStatementInParserState [label="anything allowed\ndirectly inside state\nexcept transition,\nwhich must be last"];
    parserState -> conditionalStatement8;
    conditionalStatement8 [label="if"];
    conditionalStatement8 -> blockStatementInParserState;
    parserState -> transitionStatement1;
    parserState -> transitionStatement2;
    transitionStatement1 [label="transition <statename>"];
    transitionStatement2 [label="transition select ..."];
    transitionStatement2 -> parserValueSetCall;
    parserValueSetCall [label="parser value set\nas key set\nexpression"];

    controlDeclaration -> constantOrVariableDeclaration4;
    constantOrVariableDeclaration4 [label="const, variable decl"];
    controlDeclaration -> Instantiation4;
    Instantiation4 [label="instantiation of:\nextern object\ncontrol"];
    controlDeclaration -> actionDeclaration;
    controlDeclaration -> tableDeclaration;
    controlDeclaration -> controlBody;
    controlBody [label="control body\napply { }"];

    tableDeclaration [label="table"];
    tableDeclaration -> tablePropertyKey;
    tablePropertyKey [label="key = { ... }"];
    tableDeclaration -> tablePropertyActions;
    tablePropertyActions [label="actions = { ... }"];
    tableDeclaration -> tablePropertyDefaultAction;
    tablePropertyDefaultAction [label="default_action = <action_name>;"];

    functionDefinition -> constantOrVariableDeclaration7;
    constantOrVariableDeclaration7 [label="const, variable decl"];
    functionDefinition -> assignmentFunctionCallStatement1;
    assignmentFunctionCallStatement1 [label="assignment\nfunction call\nextern call\nreturn <expr>\nNO: action call\nNO: exit"];
    functionDefinition -> conditionalStatement7;
    conditionalStatement7 [label="if"];
    conditionalStatement7 -> blockStatementInFunctionDefinition;
    blockStatementInFunctionDefinition [label="anything allowed\ndirectly inside function"];

    actionDeclaration -> constantOrVariableDeclaration5;
    constantOrVariableDeclaration5 [label="const, variable decl"];
    actionDeclaration -> assignmentActionMethodCallStatement5;
    assignmentActionMethodCallStatement5 [label="assignment\nfunction call\naction call\nextern call"];
    actionDeclaration -> returnOrExitStatement5;
    returnOrExitStatement5 [label="return, exit"];
    actionDeclaration -> conditionalStatement5;
    conditionalStatement5 [label="if\n(language spec allows\nimplementations not to\nsupport 'if' inside actions)"];
    conditionalStatement5 -> blockStatementInActionDeclaration;
    actionDeclaration -> blockStatement5;
    blockStatement5 [label="block statement\n{ ... }"];
    blockStatement5 -> blockStatementInActionDeclaration;
    blockStatementInActionDeclaration [label="anything allowed\ndirectly inside action"];

    // I am making up actionCallStatement.  It might most closely
    // correspond in P4_16 grammar to assignmentOrMethodCallStatement.
    //actionCallStatement

    controlBody -> constantOrVariableDeclaration6;
    constantOrVariableDeclaration6 [label="const, variable decl"];
    controlBody -> assignmentActionMethodCallStatement6;
    assignmentActionMethodCallStatement6 [label="assignment\nfunction call\naction call\nextern call"];
    controlBody -> tableApplyCall6;
    tableApplyCall6 [label="<table>.apply()"];
    controlBody -> controlCallStatement6;
    controlCallStatement6 [label="<control_name>.apply()"];
    controlBody -> returnOrExitStatement6;
    returnOrExitStatement6 [label="return, exit"];
    controlBody -> switchStatement6;
    switchStatement6 [label="switch (<table>.apply().action_run) { ... }"];
    switchStatement6 -> blockStatementInControlBody;
    controlBody -> conditionalStatement6;
    conditionalStatement6 [label="if"];
    conditionalStatement6 -> blockStatementInControlBody;
    controlBody -> blockStatement6;
    blockStatement6 [label="block statement\n{ ... }"];
    blockStatement6 -> blockStatementInControlBody;
    blockStatementInControlBody [label="anything allowed\ndirectly inside control body"];


    legend_oval [label="Things inside\novals are types,\nwith arrow A->B if\ntype A can contain\ntype B as a member." shape=oval];

    {
    rank=same;
    containerStructOrTuple [shape=oval label="struct or tuple"];
    //containerStruct [shape=oval label="struct"];
    //containerTuple [shape=oval label="tuple"];
    containerHeaderStack [shape=oval label="header stack"];
    containerList [shape=oval label="list"];
    }

    {
    rank=same;
    containerHeaderUnion [shape=oval label="header_union"];
    }

    {
    rank=same;
    containerHeader [shape=oval label="header"];
    }

    {
    rank=same;
    elementBitW [shape=oval label="bit<W>"];
    elementIntW [shape=oval label="int<W>"];
    elementVarbitW [shape=oval label="varbit<W>"];
    elementError [shape=oval label="error"];
    elementBool [shape=oval label="bool"];
    elementSerializableEnum [shape=oval label="enum (serializable)"];
    elementNonSerializableEnum [shape=oval label="enum (not serializable)"];
    }

    elementInt [shape=oval label="int"];
    elementString [shape=oval label="string"];
    elementMatchKind [shape=oval label="match_kind"];
    elementAnythingAllowedInStructOrTuple [shape=oval label="anything allowed\nin struct\nor tuple"];

    containerHeaderStack -> containerHeader;
    containerHeaderStack -> containerHeaderUnion;

    containerHeader -> elementBitW;
    containerHeader -> elementIntW;
    containerHeader -> elementVarbitW;
    containerHeader -> elementBool;
    containerHeader -> elementSerializableEnum;
    containerHeader -> elementStruct;

    elementStruct [shape=oval label="struct\n(When inside header,\nits 'leaf types' must\nbe only those allowed\nwithin a header.)"];

    containerHeaderUnion -> containerHeader;

    containerStructOrTuple -> elementBitW;
    containerStructOrTuple -> elementIntW;
    containerStructOrTuple -> elementVarbitW;
    containerStructOrTuple -> elementError;
    containerStructOrTuple -> elementBool;
    containerStructOrTuple -> elementSerializableEnum;
    containerStructOrTuple -> elementNonSerializableEnum;
    containerStructOrTuple -> containerHeader;
    containerStructOrTuple -> containerHeaderUnion;
    containerStructOrTuple -> containerHeaderStack;
    containerStructOrTuple -> containerStructOrTuple;

    containerList -> elementInt;
    containerList -> elementString;
    containerList -> elementMatchKind;
    containerList -> containerList;
    containerList -> elementAnythingAllowedInStructOrTuple
}