private SToken ProcessSuperSub(SToken oneToken, SEntity aEntity)
{
if (oneToken.TokenType == STokenType.ABSTRACT)
{
aEntity.IsAbstract = true;
//get new token for next step
oneToken = SLexer.Tokenizer(_dataStream);
}
if (oneToken.TokenType == STokenType.SUPERTYPE)
{ // remove OF token after supertype token
oneToken = SLexer.Tokenizer(_dataStream);
ProcessSupertypeOf(aEntity);
//get new token for next step
oneToken = SLexer.Tokenizer(_dataStream);
}
if (oneToken.TokenType == STokenType.SUBTYPE)
{ // remove of token after supertype token
oneToken = SLexer.Tokenizer(_dataStream);
ProcessSubtypeOf(aEntity);
//get new token for next step
oneToken = SLexer.Tokenizer(_dataStream);
}
return(SLexer.Tokenizer(_dataStream));
}
private void ProcessType()
{
SToken oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType != STokenType.SIMPLEID)
{
throw new Exception("Syntax error in Type Name Definition");
}
SType st = ProcessTypeSub(oneToken);
oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType == STokenType.WHERE)
{
oneToken = DummySubLoop();
}
while (oneToken.TokenType != STokenType.END_TYPE)
{
IgnoredToken(oneToken);
oneToken = SLexer.Tokenizer(_dataStream);
}
CleanUpSemiColon();
SchemaSet.TypeList.Add(st.Name, st);
}
private void ProcessSubtypeOf(SEntity aEntity)
{
SToken oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType != STokenType.LEFTPARENTHESIS)
{
throw new Exception("Syntax Error : Supertype Definition (");
}
oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType != STokenType.SIMPLEID)
{
throw new Exception("Syntax Error : Supertype Definition simpleId");
}
aEntity.SubTypesOf.Add(getEntity(oneToken.StringValue));
oneToken = SLexer.Tokenizer(_dataStream);
while (oneToken.TokenType != STokenType.RIGHTPARENTHESIS)
{
if (oneToken.TokenType != STokenType.COMMA)
{
throw new Exception("Syntax Error : Supertype Definition ,");
}
oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType != STokenType.SIMPLEID)
{
throw new Exception("Syntax Error : Supertype Definition simpleid2");
}
aEntity.SuperTypesOf.Add(getEntity(oneToken.StringValue));
oneToken = SLexer.Tokenizer(_dataStream);
}
//
//oneToken = SchemaLexer.Tokenizer(DataStream);
}
private void ProcessRule()
{
var token = SLexer.Tokenizer(_dataStream);
while (token.TokenType != STokenType.END_RULE)
{
token = SLexer.Tokenizer(_dataStream);
}
token = SLexer.Tokenizer(_dataStream);
}
private void ProcessFuction()
{
SToken Token = SLexer.Tokenizer(_dataStream);
while (Token.TokenType != STokenType.END_FUNCTION)
{
Token = SLexer.Tokenizer(_dataStream);
}
Token = SLexer.Tokenizer(_dataStream);
}
private void CleanUpSemiColon()
{
// clean up semicolon
SToken oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType != STokenType.SEMICOLON)
{
throw new Exception("Syntax error : " + SLexer.CurrentRow.ToString() + " : " + SLexer.CurrentColumn.ToString());
}
}
private void ProcessSchemaTitle()
{
SToken oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType != STokenType.SIMPLEID)
{
throw new Exception("Syntax error in Schema Name Definition");
}
SchemaSet.SchemaName = oneToken.StringValue;
oneToken = SLexer.Tokenizer(_dataStream);
//SchemaEntity aEntity = getEntity(oneToken.StringValue);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
private SToken DummySubLoop()
{
SToken oneToken = SLexer.Tokenizer(_dataStream);
while (oneToken.TokenType == STokenType.SIMPLEID)
{
while (oneToken.TokenType != STokenType.SEMICOLON)
{
oneToken = SLexer.Tokenizer(_dataStream);
}
oneToken = SLexer.Tokenizer(_dataStream);
}
return(oneToken);
}
private void ProcessAttribute(
SEntity oneEntity,
string AttributeName)
{
SAttribute satt = new SAttribute(AttributeName);
SToken oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType != STokenType.COLON)
{
throw new Exception("Error in attribute : " + SLexer.CurrentRow + " : " + SLexer.CurrentColumn);
}
satt.Type = ProcessParameter();
oneEntity.ParameterList.Add(satt);
}
private void collection(STypeCollection sTypeCol)
{
// Left brackett
SToken oneToken = SLexer.Tokenizer(_dataStream);
// lbound
oneToken = SLexer.Tokenizer(_dataStream);
sTypeCol.LBound = getBound(oneToken);
oneToken = SLexer.Tokenizer(_dataStream);
oneToken = SLexer.Tokenizer(_dataStream);
sTypeCol.UBound = getBound(oneToken);
// right bracket
oneToken = SLexer.Tokenizer(_dataStream);
// of
oneToken = SLexer.Tokenizer(_dataStream);
// type
oneToken = SLexer.Tokenizer(_dataStream);
SParamType sp = SParameter.TokenTypeToAttribType(oneToken.TokenType);
switch (oneToken.TokenType)
{
case STokenType.BOOLEAN:
case STokenType.REAL:
case STokenType.INTEGER:
case STokenType.LOGICAL:
case STokenType.NUMBER:
case STokenType.STRING:
case STokenType.ARRAY:
case STokenType.LIST:
case STokenType.SET:
case STokenType.BAG:
sTypeCol.CollectionType = sp;
sTypeCol.CollectionName = SParameter.TypeToString(sp);
break;
case STokenType.SIMPLEID:
sTypeCol.CollectionName = oneToken.StringValue;
break;
default:
if (_logFile != null)
{
_logFile.WriteLine(oneToken.TokenType.ToString() + " : " + oneToken.StringValue);
}
break;
}
}
/// <summary>
/// returns list of schema token surrouned by parenthesis from Stream
/// </summary>
/// <param name="tokenList"></param>
private void GetInsideSingleParenthesis(List <SToken> tokenList)
{
tokenList.Clear();
// dummy token to begin
SToken oneToken = SLexer.Tokenizer(_dataStream);
int counter = 0;
while (oneToken.TokenType != STokenType.RIGHTPARENTHESIS)
{
if (counter == 0)
{
if (oneToken.TokenType != STokenType.LEFTPARENTHESIS)
{
throw new Exception("Syntax error in Single Parenthesis : Type 1");
}
}
else
{
oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType == STokenType.COMMA)
{
}
else if (oneToken.TokenType == STokenType.RIGHTPARENTHESIS)
{
break;
}
else
{
throw new Exception("Syntax error in Single Parenthesis : Type 2");
}
}
oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType == STokenType.SIMPLEID)
{
tokenList.Add(oneToken);
counter += 1;
}
else
{
throw new Exception("Syntax error in Single Parenthesis : Type 3");
}
}
}
private void ProcessInverse(SEntity sEntity, SToken sToken)
{
SAttributeInverse sAttributeInverse = new SAttributeInverse(sToken.StringValue);
SToken oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType != STokenType.COLON)
{
throw new Exception("Error in inverse attribute : " + SLexer.CurrentRow + " : " + SLexer.CurrentColumn);
}
sAttributeInverse.Type = ProcessInverseParameter();
oneToken = SLexer.Tokenizer(_dataStream);
// referencing entity's attribute name
oneToken = SLexer.Tokenizer(_dataStream);
sAttributeInverse.InversingAttributeName = oneToken.StringValue;
sEntity.InverseList.Add(sAttributeInverse);
// semi colon
oneToken = SLexer.Tokenizer(_dataStream);
}
/// <summary>
/// Parser main
/// </summary>
private void Parse()
{
SToken oneToken = SLexer.Tokenizer(_dataStream);
//int pCounter = 0;
while (oneToken.TokenType != STokenType.EOF)
{
//AddToken(oneToken, InstanceData, DataStream);
switch (oneToken.TokenType)
{
case STokenType.SCHEMA:
ProcessSchemaTitle();
break;
case STokenType.ENTITY:
ProcessEntity();
break;
case STokenType.TYPE:
ProcessType();
break;
case STokenType.FUNCTION:
ProcessFuction();
break;
case STokenType.RULE:
ProcessRule();
break;
case STokenType.END_SCHEMA:
ProcessSchemaEnd();
break;
default:
IgnoredToken(oneToken);
break;
}
oneToken = SLexer.Tokenizer(_dataStream);
}
}
private void ProcessSupertypeOf(SEntity aEntity)
{
//319 supertype_constraint = abstract_entity_declaration |
// abstract_supertype_declaration | supertype_rule .
//164 abstract_entity_declaration = ABSTRACT .
//166 abstract_supertype_declaration = ABSTRACT SUPERTYPE [ subtype_constraint ] .
//313 subtype_constraint = OF ’(’ supertype_expression ’)’ .
//320 supertype_expression = supertype_factor { ANDOR supertype_factor } .
//321 supertype_factor = supertype_term { AND supertype_term } .
//323 supertype_term = entity_ref | one_of | ’(’ supertype_expression ’)’ .
//263 one_of = ONEOF ’(’ supertype_expression { ’,’ supertype_expression } ’)’ .
//322 supertype_rule = SUPERTYPE subtype_constraint .
int parenthesisCounter = 0;
SToken oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType != STokenType.LEFTPARENTHESIS)
{
throw new Exception("Syntax Error : Supertype Definition (");
}
else
{
parenthesisCounter += 1;
}
while (parenthesisCounter != 0)
{
oneToken = SLexer.Tokenizer(_dataStream);
switch (oneToken.TokenType)
{
case STokenType.LEFTPARENTHESIS:
parenthesisCounter += 1;
break;
case STokenType.RIGHTPARENTHESIS:
parenthesisCounter -= 1;
break;
case STokenType.ONEOF:
case STokenType.COMMA:
break;
case STokenType.SIMPLEID:
aEntity.SuperTypesOf.Add(getEntity(oneToken.StringValue));
break;
default:
string logout = String.Format("Undefined supertype definition at row : {0}, column : {1}",
SLexer.CurrentRow,
SLexer.CurrentColumn);
if (_logFile != null)
{
_logFile.WriteLine(logout);
}
break;
}
}
//if (oneToken.TokenType != SchemaTokenType.ONEOF)
// throw new Exception("Syntax Error : Supertype Definition oneof");
//oneToken = SchemaLexer.Tokenizer(DataStream);
//if (oneToken.TokenType != SchemaTokenType.LEFTPARENTHESIS)
// throw new Exception("Syntax Error : Supertype Definition (2");
//oneToken = SchemaLexer.Tokenizer(DataStream);
//if (oneToken.TokenType != SchemaTokenType.SIMPLEID)
// throw new Exception("Syntax Error : Supertype Definition simpleId");
//aEntity.SuperTypesOf.Add(getEntity(oneToken.StringValue));
//oneToken = SchemaLexer.Tokenizer(DataStream);
//while (oneToken.TokenType != SchemaTokenType.RIGHTPARENTHESIS)
//{
// if (oneToken.TokenType != SchemaTokenType.COMMA)
// throw new Exception("Syntax Error : Supertype Definition ,");
// oneToken = SchemaLexer.Tokenizer(DataStream);
// if (oneToken.TokenType != SchemaTokenType.SIMPLEID)
// throw new Exception("Syntax Error : Supertype Definition simpleid2");
// aEntity.SuperTypesOf.Add(getEntity(oneToken.StringValue));
// oneToken = SchemaLexer.Tokenizer(DataStream);
//}
//// for second parenthesis
//oneToken = SchemaLexer.Tokenizer(DataStream);
}
/// <summary>
/// not a complete derive implementation
/// intended to identify omitted value in instance population
/// </summary>
/// <param name="oneEntity"></param>
/// <param name="AttributeName"></param>
private void ProcessDerivedAttribute(
SEntity oneEntity,
SToken mToken)
{
SAttributeDerived drvAtt;
//SParam sParam;
if (mToken.TokenType == STokenType.SELF)
{
//drvAtt = new SAttributeDerived(AttribType.DERIVED);
// defines self drived attribute
// reverse_solidus
mToken = SLexer.Tokenizer(_dataStream);
// super entity
mToken = SLexer.Tokenizer(_dataStream);
if (mToken.TokenType != STokenType.SIMPLEID)
{
throw new InvalidDataException(string.Format(
"schema is not in syntax at {0} : {1}",
oneEntity.Name, mToken.TokenType.ToString()));
}
string orgSuperTypeName = mToken.StringValue;
// period
mToken = SLexer.Tokenizer(_dataStream);
// attribute name
mToken = SLexer.Tokenizer(_dataStream);
string sAttName = mToken.StringValue;
drvAtt = new SAttributeDerived(sAttName);
drvAtt.OriginatingSuperType = orgSuperTypeName;
drvAtt.Name = sAttName;
drvAtt.isInherited = true;
// colon
mToken = SLexer.Tokenizer(_dataStream);
drvAtt.Type = ProcessParameter();
oneEntity.DerivedList.Add(drvAtt);
}
else //if (mToken.TokenType == SchemaTokenType.SIMPLEID)
{
string sAttName = mToken.StringValue;
drvAtt = new SAttributeDerived(sAttName);
drvAtt.Name = sAttName;
drvAtt.isInherited = false;
mToken = SLexer.Tokenizer(_dataStream);
drvAtt.Type = ProcessParameter();
oneEntity.DerivedList.Add(drvAtt);
}
//mToken = SLexer.Tokenizer(DataStream);
//oneEntity.AttributeList.Add(oneAttribute);
while (mToken.TokenType != STokenType.SEMICOLON)
{
mToken = SLexer.Tokenizer(_dataStream);
}
}
private SParameter ProcessInverseParameter()
{
SToken oneToken = SLexer.Tokenizer(_dataStream);
bool isOptional = false;
if (oneToken.TokenType == STokenType.OPTIONAL)
{
oneToken = SLexer.Tokenizer(_dataStream);
isOptional = true;
}
bool isUnique = false;
if (oneToken.TokenType == STokenType.UNIQUE)
{
isUnique = true;
oneToken = SLexer.Tokenizer(_dataStream);
}
SParamType stype = SParameter.TokenTypeToAttribType(oneToken.TokenType);
SParameter sParam;
if (stype == SParamType.SET ||
stype == SParamType.LIST ||
stype == SParamType.ARRAY ||
stype == SParamType.BAG)
{
sParam = new SParamCollection(stype);
var sParamCol = sParam as SParamCollection;
// get leftbracket
oneToken = SLexer.Tokenizer(_dataStream);
// after adding lower bound, upper bound lexer
oneToken = SLexer.Tokenizer(_dataStream);
sParamCol.LBound = getBound(oneToken);
// get colon
oneToken = SLexer.Tokenizer(_dataStream);
// get upper bound
oneToken = SLexer.Tokenizer(_dataStream);
sParamCol.UBound = getBound(oneToken);
// get rightbracket
oneToken = SLexer.Tokenizer(_dataStream);
// get of
oneToken = SLexer.Tokenizer(_dataStream);
sParamCol.ParamReference = ProcessInverseParameter();
}
else if (stype == SParamType.NAMED)
{
sParam = new SParamNamed(oneToken.StringValue);
}
else
{
sParam = new SParameter(stype);
}
sParam.IsUnique = isUnique;
sParam.IsOptional = isOptional;
// either semi colon or left parenthesis
//oneToken = SLexer.Tokenizer(DataStream);
//if (!(sParam is SParamCollection))
//{
// oneToken = SLexer.Tokenizer(_dataStream);
// if (oneToken.TokenType == STokenType.LEFTPARENTHESIS)
// {
// oneToken = SLexer.Tokenizer(_dataStream); // integer
// // add integer
// sParam.TypeLength = (short)oneToken.IntegerValue;
// oneToken = SLexer.Tokenizer(_dataStream); // right parenthesis
// oneToken = SLexer.Tokenizer(_dataStream);
// if (oneToken.TokenType == STokenType.FIXED)
// {
// // process fixed
// sParam.IsFixed = true;
// // semicolon
// oneToken = SLexer.Tokenizer(_dataStream);
// }
// }
//}
//SAttribute oneAttribute = new SAttribute(AttributeName, sParam);
return(sParam);
}
private void ProcessSchemaEnd()
{
SLexer.Tokenizer(_dataStream);
}
private SType ProcessTypeSub(SToken oneToken)
{
SType ret;
string t_TypeName = oneToken.StringValue;
// tokenlist for syntax checking
List <SToken> tokenList = new List <SToken>();
oneToken = SLexer.Tokenizer(_dataStream);
#region switch
switch (oneToken.TokenType)
{
case STokenType.BOOLEAN:
case STokenType.REAL:
case STokenType.INTEGER:
case STokenType.LOGICAL:
case STokenType.NUMBER:
ret = new SType(t_TypeName, SParameter.TokenTypeToAttribType(oneToken.TokenType));
CleanUpSemiColon();
break;
case STokenType.STRING:
ret = new STypeString(t_TypeName);
ret.Kind = SParameter.TokenTypeToAttribType(oneToken.TokenType);
oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType == STokenType.LEFTPARENTHESIS)
{
// process width
oneToken = SLexer.Tokenizer(_dataStream);
((STypeString)ret).StringLength = (short)oneToken.IntegerValue;
oneToken = SLexer.Tokenizer(_dataStream); // right parenthesis
oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType == STokenType.FIXED)
{
// process fixed
((STypeString)ret).IsFixed = true;
// semicolon
oneToken = SLexer.Tokenizer(_dataStream);
}
}
break;
case STokenType.SIMPLEID:
ret = new STypeSimple(t_TypeName, oneToken.StringValue);
ret.Kind = SParameter.TokenTypeToAttribType(oneToken.TokenType);
CleanUpSemiColon();
break;
case STokenType.ARRAY:
case STokenType.LIST:
case STokenType.SET:
case STokenType.BAG:
ret = new STypeCollection(t_TypeName, oneToken.TokenType);
ret.Kind = SParameter.TokenTypeToAttribType(oneToken.TokenType);
collection((STypeCollection)ret);
break;
case STokenType.ENUMERATION:
ret = new STypeEnum(t_TypeName);
ret.Kind = SParameter.TokenTypeToAttribType(oneToken.TokenType);
oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType != STokenType.OF)
{
throw new Exception("Syntax error in Schema Name Definition");
}
GetInsideSingleParenthesis(tokenList);
foreach (SToken aToken in tokenList)
{
if (aToken.TokenType == STokenType.SIMPLEID)
{
((STypeEnum)ret).EnumList.Add(aToken.StringValue);
}
else
{
throw new Exception("Syntax error in Enumeration Type Definition : " + ret.Name);
}
}
CleanUpSemiColon();
break;
case STokenType.SELECT:
ret = new STypeSelect(t_TypeName);
ret.Kind = SParameter.TokenTypeToAttribType(oneToken.TokenType);
GetInsideSingleParenthesis(tokenList);
foreach (SToken aToken in tokenList)
{
if (aToken.TokenType == STokenType.SIMPLEID)
{
((STypeSelect)ret).SelectList.Add(aToken.StringValue, null);
}
else
{
throw new Exception("Syntax error in Select Type Definition : " + ret.Name);
}
}
CleanUpSemiColon();
break;
default:
ret = null;
if (_logFile != null)
{
_logFile.WriteLine(oneToken.TokenType.ToString() + " : " + oneToken.StringValue);
}
break;
}
#endregion // switch
return(ret);
}
private void ProcessEntity()
{
SToken oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType != STokenType.SIMPLEID)
{
throw new Exception("Syntax error in Entity Definition");
}
SEntity aEntity = getEntity(oneToken.StringValue);
oneToken = SLexer.Tokenizer(_dataStream);
if (oneToken.TokenType == STokenType.SEMICOLON)
{ //get new token for next step
oneToken = SLexer.Tokenizer(_dataStream);
}
if (oneToken.TokenType == STokenType.ABSTRACT ||
oneToken.TokenType == STokenType.SUPERTYPE ||
oneToken.TokenType == STokenType.SUBTYPE)
{
oneToken = ProcessSuperSub(oneToken, aEntity);
}
if (oneToken.TokenType == STokenType.SIMPLEID)
{
while (oneToken.TokenType == STokenType.SIMPLEID)
{
ProcessAttribute(aEntity, oneToken.StringValue);
oneToken = SLexer.Tokenizer(_dataStream);
}
}
if (oneToken.TokenType == STokenType.DERIVE)
{
// oneToken = DummySubLoop();
// next one after derived
oneToken = SLexer.Tokenizer(_dataStream);
while (oneToken.TokenType == STokenType.SIMPLEID || oneToken.TokenType == STokenType.SELF)
{
ProcessDerivedAttribute(aEntity, oneToken);
oneToken = SLexer.Tokenizer(_dataStream);
}
}
if (oneToken.TokenType == STokenType.INVERSE)
{
//oneToken = DummySubLoop();
oneToken = SLexer.Tokenizer(_dataStream);
while (oneToken.TokenType == STokenType.SIMPLEID)
{
ProcessInverse(aEntity, oneToken);
oneToken = SLexer.Tokenizer(_dataStream);
}
}
if (oneToken.TokenType == STokenType.UNIQUE)
{
oneToken = DummySubLoop();
}
if (oneToken.TokenType == STokenType.UNDEFINED)
{
oneToken = DummySubLoop();
}
if (oneToken.TokenType == STokenType.WHERE)
{
oneToken = DummySubLoop();
}
if (oneToken.TokenType == STokenType.END_ENTITY)
{
oneToken = SLexer.Tokenizer(_dataStream); // semi colon
}
}
