static void
InitLine (void)
{
if (ltoken_getCode (nextToken) == LLT_EOL)
{
/* Nothing on line. */
InitReduce (INITLINE1);
}
else
{
Classification ();
InitReduce (INITLINE2);
}
if (ltoken_getCode (nextToken) != LLT_EOL)
{
LocalUserError (nextToken, "Unexpected tokens on line");
}
nextToken = LCLScanNextToken (); /* Discard EOL */
}
void STEPutil::STEPBoilerplate( )
{
// Increment FileId so entities start at #1 instead of #0.
instance_list->NextFileId();
registry->ResetSchemas();
registry->ResetEntities();
SdaiFile_name * fn = ( SdaiFile_name * ) sfile->HeaderDefaultFileName();
header_instances->Append( ( SDAI_Application_instance * ) fn, completeSE );
fn->name_( "'outfile.stp'" );
fn->time_stamp_( "''" );
fn->author_()->AddNode( new StringNode( "''" ) );
fn->organization_()->AddNode( new StringNode( "''" ) );
fn->preprocessor_version_( "''" );
fn->originating_system_( "''" );
fn->authorization_( "''" );
SdaiFile_description * fd = ( SdaiFile_description * ) sfile->HeaderDefaultFileDescription();
header_instances->Append( ( SDAI_Application_instance * ) fd, completeSE );
fd->description_()->AddNode( new StringNode( "''" ) );
fd->implementation_level_( "'1'" );
SdaiFile_schema * fs = ( SdaiFile_schema * ) sfile->HeaderDefaultFileSchema();
header_instances->Append( ( SDAI_Application_instance * ) fs, completeSE );
fs->schema_identifiers_()->AddNode( new StringNode( "'CONFIG_CONTROL_DESIGN'" ) );
// Build file data. The entities have been created and added in order such that no entity
// references a later entity. This is not required, but has been done to give a logical
// flow to the source and the resulting STEP file.
// Stand-in date and time.
SdaiDate_and_time * date_time = DateTime( );
// Global units and tolerance.
context = Geometric_Context( u_MM, u_DEG, "0.0001" );
// Primary coordinate system.
SdaiAxis2_placement_3d * orig_transform = DefaultAxis( );
// Basic context through product and shape representation
SdaiApplication_context * app_context = ( SdaiApplication_context * ) registry->ObjCreate( "APPLICATION_CONTEXT" );
instance_list->Append( ( SDAI_Application_instance * ) app_context, completeSE );
app_context->application_( "'configuration controlled 3d designs of mechanical parts and assemblies'" );
SdaiMechanical_context * mech_context = ( SdaiMechanical_context * ) registry->ObjCreate( "MECHANICAL_CONTEXT" );
instance_list->Append( ( SDAI_Application_instance * ) mech_context, completeSE );
mech_context->name_( "''" );
mech_context->discipline_type_( "'mechanical'" );
mech_context->frame_of_reference_( app_context );
SdaiApplication_protocol_definition * app_protocol = ( SdaiApplication_protocol_definition * ) registry->ObjCreate( "APPLICATION_PROTOCOL_DEFINITION" );
instance_list->Append( ( SDAI_Application_instance * ) app_protocol, completeSE );
app_protocol->status_( "'international standard'" );
app_protocol->application_protocol_year_( 1994 );
app_protocol->application_interpreted_model_schema_name_( "'config_control_design'" );
app_protocol->application_( app_context );
SdaiDesign_context * design_context = ( SdaiDesign_context * ) registry->ObjCreate( "DESIGN_CONTEXT" );
instance_list->Append( ( SDAI_Application_instance * ) design_context, completeSE );
design_context->name_( "''" );
design_context->life_cycle_stage_( "'design'" );
design_context->frame_of_reference_( app_context );
SdaiProduct * prod = ( SdaiProduct * ) registry->ObjCreate( "PRODUCT" );
instance_list->Append( ( SDAI_Application_instance * ) prod, completeSE );
prod->id_( "''" );
prod->name_( "'prodname'" );
prod->description_( "''" );
prod->frame_of_reference_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) mech_context ) );
SdaiProduct_related_product_category * prodcat = ( SdaiProduct_related_product_category * ) registry->ObjCreate( "PRODUCT_RELATED_PRODUCT_CATEGORY" );
instance_list->Append( ( SDAI_Application_instance * ) prodcat, completeSE );
prodcat->name_( "'assembly'" );
prodcat->description_( "''" );
prodcat->products_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod ) );
SdaiProduct_definition_formation_with_specified_source * prod_def_form = ( SdaiProduct_definition_formation_with_specified_source * ) registry->ObjCreate( "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE" );
instance_list->Append( ( SDAI_Application_instance * ) prod_def_form, completeSE );
prod_def_form->id_( "''" );
prod_def_form->description_( "''" );
prod_def_form->of_product_( prod );
prod_def_form->make_or_buy_( Source__made );
SdaiProduct_definition * prod_def = ( SdaiProduct_definition * ) registry->ObjCreate( "PRODUCT_DEFINITION" );
instance_list->Append( ( SDAI_Application_instance * ) prod_def, completeSE );
prod_def->id_( "''" );
prod_def->description_( "''" );
prod_def->frame_of_reference_( design_context );
prod_def->formation_( prod_def_form );
SdaiProduct_definition_shape * pshape = ( SdaiProduct_definition_shape * ) registry->ObjCreate( "PRODUCT_DEFINITION_SHAPE" );
instance_list->Append( ( SDAI_Application_instance * ) pshape, completeSE );
pshape->name_( "''" );
pshape->description_( "'ProductShapeDescription'" );
pshape->definition_( new SdaiCharacterized_definition( new SdaiCharacterized_product_definition( prod_def ) ) );
shape_rep = ( SdaiShape_representation * ) registry->ObjCreate( "SHAPE_REPRESENTATION" );
instance_list->Append( ( SDAI_Application_instance * ) shape_rep, completeSE );
shape_rep->name_( "''" ); // Document?
shape_rep->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) orig_transform ) );
shape_rep->context_of_items_( ( SdaiRepresentation_context * ) context );
SdaiShape_definition_representation * shape_def_rep = ( SdaiShape_definition_representation * ) registry->ObjCreate( "SHAPE_DEFINITION_REPRESENTATION" );
instance_list->Append( ( SDAI_Application_instance * ) shape_def_rep, completeSE );
shape_def_rep->definition_( pshape );
shape_def_rep->used_representation_( shape_rep );
// Stand-in person and org.
SdaiPerson * person = ( SdaiPerson * ) registry->ObjCreate( "PERSON" );
instance_list->Append( ( SDAI_Application_instance * ) person, completeSE );
person->id_( "''" );
person->last_name_( "'Doe'" );
person->first_name_( "'John'" );
SdaiOrganization * org = ( SdaiOrganization * ) registry->ObjCreate( "ORGANIZATION" );
instance_list->Append( ( SDAI_Application_instance * ) org, completeSE );
org->id_( "''" );
org->name_( "''" );
org->description_( "''" );
SdaiPerson_and_organization * per_org = ( SdaiPerson_and_organization * ) registry->ObjCreate( "PERSON_AND_ORGANIZATION" );
instance_list->Append( ( SDAI_Application_instance * ) per_org, completeSE );
per_org->the_person_( person );
per_org->the_organization_( org );
// Required roles.
SdaiPerson_and_organization_role * creator_role = ( SdaiPerson_and_organization_role * ) registry->ObjCreate( "PERSON_AND_ORGANIZATION_ROLE" );
instance_list->Append( ( SDAI_Application_instance * ) creator_role, completeSE );
creator_role->name_( "'creator'" );
SdaiPerson_and_organization_role * owner_role = ( SdaiPerson_and_organization_role * ) registry->ObjCreate( "PERSON_AND_ORGANIZATION_ROLE" );
instance_list->Append( ( SDAI_Application_instance * ) owner_role, completeSE );
owner_role->name_( "'design_owner'" );
SdaiPerson_and_organization_role * supplier_role = ( SdaiPerson_and_organization_role * ) registry->ObjCreate( "PERSON_AND_ORGANIZATION_ROLE" );
instance_list->Append( ( SDAI_Application_instance * ) supplier_role, completeSE );
supplier_role->name_( "'design_supplier'" );
// Basic approval.
SdaiApproval_status * approval_status = ( SdaiApproval_status * ) registry->ObjCreate( "APPROVAL_STATUS" );
instance_list->Append( ( SDAI_Application_instance * ) approval_status, completeSE );
approval_status->name_( "'approved'" );
SdaiApproval * approval = ( SdaiApproval * ) registry->ObjCreate( "APPROVAL" );
instance_list->Append( ( SDAI_Application_instance * ) approval, completeSE );
approval->status_( approval_status );
approval->level_( "''" );
SdaiApproval_date_time * app_date_time = ( SdaiApproval_date_time * ) registry->ObjCreate( "APPROVAL_DATE_TIME" );
instance_list->Append( ( SDAI_Application_instance * ) app_date_time, completeSE );
app_date_time->date_time_( new SdaiDate_time_select( date_time ) );
app_date_time->dated_approval_( approval );
SdaiApproval_role * app_role = ( SdaiApproval_role * ) registry->ObjCreate( "APPROVAL_ROLE" );
instance_list->Append( ( SDAI_Application_instance * ) app_role, completeSE );
app_role->role_( "'approver'" );
SdaiApproval_person_organization * app_per_org = ( SdaiApproval_person_organization * ) registry->ObjCreate( "APPROVAL_PERSON_ORGANIZATION" );
instance_list->Append( ( SDAI_Application_instance * ) app_per_org, completeSE );
app_per_org->person_organization_( new SdaiPerson_organization_select( per_org ) );
app_per_org->authorized_approval_( approval );
app_per_org->role_( app_role );
// Basic Classification.
SdaiSecurity_classification * clas = Classification( per_org, date_time, prod_def_form );
// Basic CC approval.
SdaiCc_design_approval * desapproval = ( SdaiCc_design_approval * ) registry->ObjCreate( "CC_DESIGN_APPROVAL" );
instance_list->Append( ( SDAI_Application_instance * ) desapproval, completeSE );
desapproval->assigned_approval_( approval );
desapproval->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod_def ) );
desapproval->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod_def_form ) );
desapproval->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) clas ) );
SdaiCc_design_person_and_organization_assignment * creatorpersonorg = ( SdaiCc_design_person_and_organization_assignment * ) registry->ObjCreate( "CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT" );
instance_list->Append( ( SDAI_Application_instance * ) creatorpersonorg, completeSE );
creatorpersonorg->assigned_person_and_organization_( per_org );
creatorpersonorg->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod_def ) );
creatorpersonorg->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod_def_form ) );
creatorpersonorg->role_( creator_role );
SdaiCc_design_person_and_organization_assignment * supplierpersonorg = ( SdaiCc_design_person_and_organization_assignment * ) registry->ObjCreate( "CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT" );
instance_list->Append( ( SDAI_Application_instance * ) supplierpersonorg, completeSE );
supplierpersonorg->assigned_person_and_organization_( per_org );
supplierpersonorg->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod_def_form ) );
supplierpersonorg->role_( supplier_role );
SdaiDate_time_role * datetimerole = ( SdaiDate_time_role * ) registry->ObjCreate( "DATE_TIME_ROLE" );
instance_list->Append( ( SDAI_Application_instance * ) datetimerole, completeSE );
datetimerole->name_( "'creation_date'" );
SdaiCc_design_date_and_time_assignment * assign = ( SdaiCc_design_date_and_time_assignment * ) registry->ObjCreate( "CC_DESIGN_DATE_AND_TIME_ASSIGNMENT" );
instance_list->Append( ( SDAI_Application_instance * ) assign, completeSE );
assign->assigned_date_and_time_( date_time );
assign->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod_def ) );
assign->role_( datetimerole );
SdaiCc_design_person_and_organization_assignment * ownerpersonorg = ( SdaiCc_design_person_and_organization_assignment * ) registry->ObjCreate( "CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT" );
instance_list->Append( ( SDAI_Application_instance * ) ownerpersonorg, completeSE );
ownerpersonorg->assigned_person_and_organization_( per_org );
ownerpersonorg->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod ) );
ownerpersonorg->role_( owner_role );
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"ei:qst:T:vV:",
"action operand condition [...] control volatility [device] [...]\n\n where a condition is: field operator value",
"Qualcomm Atheros Stream Classification Utility",
"e\tredirect stderr to stdout",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"q\tquiet mode",
"s\tdisplay symbol tables",
"t n\tread timeout is (n) milliseconds [" LITERAL (CHANNEL_TIMEOUT) "]",
"T x\tinserted vlan tag is x [" LITERAL (INT6KRULE_VLAN_TAG) "]",
"v\tverbose mode",
"V n\tcspec version is n [" LITERAL (INT6KRULE_CSPEC_VERSION) "]",
(char const *) (0)
};
#include "../plc/plc.c"
struct cspec cspec;
struct MMERule rule;
signed c;
memset (&rule, 0, sizeof (rule));
memset (&cspec, 0, sizeof (cspec));
cspec.VLAN_TAG = INT6KRULE_VLAN_TAG;
cspec.CSPEC_VERSION = INT6KRULE_CSPEC_VERSION;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (plc.flags, PLC_SILENCE);
break;
case 's':
printf ("\n");
printf (" Controls are ");
codelist (controls, SIZEOF (controls), COMMA, QUOTE, stdout);
printf (".\n");
printf (" Volatilities are ");
codelist (volatilities, SIZEOF (volatilities), COMMA, QUOTE, stdout);
printf (".\n");
printf (" Actions are ");
codelist (actions, SIZEOF (actions), COMMA, QUOTE, stdout);
printf (".\n");
printf (" Operands are ");
codelist (operands, SIZEOF (operands), COMMA, QUOTE, stdout);
printf (".\n");
printf (" Fields are ");
codelist (fields, SIZEOF (fields), COMMA, QUOTE, stdout);
printf (".\n");
printf (" Operators are ");
codelist (operators, SIZEOF (operators), COMMA, QUOTE, stdout);
printf (".\n");
printf (" States are ");
codelist (states, SIZEOF (states), COMMA, QUOTE, stdout);
printf (".\n");
printf ("\n");
return (0);
case 't':
channel.timeout = (signed)(uintspec (optarg, 0, UINT_MAX));
break;
case 'T':
cspec.VLAN_TAG = (uint32_t)(basespec (optarg, 16, sizeof (cspec.VLAN_TAG)));
cspec.VLAN_TAG = htonl (cspec.VLAN_TAG);
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
case 'V':
cspec.CSPEC_VERSION = (uint16_t)(basespec (optarg, 10, sizeof (cspec.CSPEC_VERSION)));
cspec.CSPEC_VERSION = HTOLE16 (cspec.CSPEC_VERSION);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (ParseRule (&argc, &argv, &rule, &cspec) == -1)
{
error (1, 0, "invalid rule");
}
openchannel (&channel);
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
if (!argc)
{
Classification (&plc, &rule);
}
while ((argc) && (* argv))
{
if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
Classification (&plc, &rule);
argc--;
argv++;
}
free (plc.message);
closechannel (&channel);
exit (0);
}
