Example #1
0
        protected void AddOperator(SParamType type, StreamWriter stream)
        {
            string bTypeName;
            string valueForm;

            switch (type)
            {
            case SParamType.NUMBER:
            case SParamType.REAL:
                bTypeName = "double";
                valueForm = "Math.Round(value, Precision)";
                //valueForm = "value";
                break;

            case SParamType.STRING:
                bTypeName = "string";
                valueForm = "value";
                break;

            case SParamType.INTEGER:
                bTypeName = "int";
                valueForm = "value";
                break;

            case SParamType.BOOLEAN:
                bTypeName = "bool";
                valueForm = "value";
                break;

            case SParamType.LOGICAL:
                bTypeName = "int";
                valueForm = "value";
                break;

            default:
                bTypeName = "";
                valueForm = "value";
                break;
            }



            var sb2 = new StringBuilder();

            sb2.Append(string.Format("\t\tpublic static implicit operator {0}({1} value)\r\n", Name, bTypeName));
            sb2.Append(string.Format("\t\t{{\r\n\t\t\treturn new {0}{{ Value = {1} }};\r\n\t\t}}\r\n", Name, valueForm));
            sb2.Append(string.Format("\t\tpublic static implicit operator {0}({1} obj)\r\n", bTypeName, Name));
            sb2.Append("\t\t{\r\n\t\t\treturn obj.Value;\r\n\t\t}\r\n");
            stream.Write(sb2.ToString());
        }
Example #2
0
        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;
            }
        }
Example #3
0
 public static string TypeToString(SParamType stype)
 {
     //p_AttType = stype;
     string ret;
     switch (stype)
     {
         case SParamType.ENTITY:
             ret = @"ENTITY";
             break;
         case SParamType.TYPE:
             ret = @"TYPE";
             break;
         case SParamType.NAMED:
             ret = @"NAMED";
             break;
         case SParamType.STRING:
             ret = @"STRING";
             break;
         case SParamType.REAL:
             ret = @"REAL";
             break;
         case SParamType.NUMBER:
             ret = @"NUMBER";
             break;
         case SParamType.INTEGER:
             ret = @"INTEGER";
             break;
         case SParamType.BOOLEAN:
             ret = @"BOOLEAN";
             break;
         case SParamType.ENUMERATION:
             ret = @"ENUMERATION";
             break;
         case SParamType.BINARY:
             ret = @"BINARY";
             break;
         case SParamType.LIST:
             ret = @"LIST";
             break;
         case SParamType.LOGICAL:
             ret = @"LOGICAL";
             break;
         case SParamType.SET:
             ret = @"SET";
             break;
         case SParamType.BAG:
             ret = @"BAG";
             break;
         case SParamType.ARRAY:
             ret = @"ARRAY";
             break;
         case SParamType.DERIVED:
             ret = @"DERIVED";
             break;
         case SParamType.SELFDERIVED:
             ret = @"SELFDERIVED";
             break;
         case SParamType.SELECT:
             ret = @"SELECT";
             break;
         case SParamType.UNSET:
         default:
             ret = @"UNSET";
             break;
     }
     return ret;
 }
Example #4
0
 public SParameter(SParamType stype)
 {
     SetType(stype);
 }
Example #5
0
 public ParamBinary(SParamType ParameterType)
     : base(ParameterType)
 {
 }
Example #6
0
        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);
        }
Example #7
0
        protected void AddOperator(SParamType type, StreamWriter stream)
        {
            string bTypeName;
            string valueForm;
            switch (type)
            {
                case SParamType.NUMBER:
                case SParamType.REAL:
                    bTypeName = "double";
                    valueForm = "Math.Round(value, Precision)";
                    //valueForm = "value";
                    break;
                case SParamType.STRING:
                    bTypeName = "string";
                    valueForm = "value";
                    break;
                case SParamType.INTEGER:
                    bTypeName = "int";
                    valueForm = "value";
                    break;
                case SParamType.BOOLEAN:
                    bTypeName = "bool";
                    valueForm = "value";
                    break;
                case SParamType.LOGICAL:
                    bTypeName = "int";
                    valueForm = "value";
                    break;
                default:
                    bTypeName = "";
                    valueForm = "value";
                    break;
            }

            var sb2 = new StringBuilder();
            sb2.Append(string.Format("\t\tpublic static implicit operator {0}({1} value)\r\n", Name, bTypeName));
            sb2.Append(string.Format("\t\t{{\r\n\t\t\treturn new {0}{{ Value = {1} }};\r\n\t\t}}\r\n", Name, valueForm));
            sb2.Append(string.Format("\t\tpublic static implicit operator {0}({1} obj)\r\n", bTypeName, Name));
            sb2.Append("\t\t{\r\n\t\t\treturn obj.Value;\r\n\t\t}\r\n");
            stream.Write(sb2.ToString());
        }
Example #8
0
 public SType(string TypeName, SParamType SAtt)
 {
     Name = TypeName;
     Kind = SAtt;
 }
Example #9
0
 public void updateParameterType(SParamType ParameterType)
 {
     m_ParameterType     = ParameterType;
     m_ParameterTypeName = SParameter.TypeToString(m_ParameterType);
 }
Example #10
0
 public Parameter(SParamType ParameterType)
 {
     updateParameterType(ParameterType);
 }
Example #11
0
 public ParamBinary(SParamType ParameterType)
     : base(ParameterType)
 {
 }
Example #12
0
 public SParameter(SParamType stype)
 {
     SetType(stype);
 }
Example #13
0
 public SParamCollection(SParamType stype)
     : base(stype)
 {
 }
Example #14
0
        public static string TypeToString(SParamType stype)
        {
            //p_AttType = stype;
            string ret;

            switch (stype)
            {
            case SParamType.ENTITY:
                ret = @"ENTITY";
                break;

            case SParamType.TYPE:
                ret = @"TYPE";
                break;

            case SParamType.NAMED:
                ret = @"NAMED";
                break;

            case SParamType.STRING:
                ret = @"STRING";
                break;

            case SParamType.REAL:
                ret = @"REAL";
                break;

            case SParamType.NUMBER:
                ret = @"NUMBER";
                break;

            case SParamType.INTEGER:
                ret = @"INTEGER";
                break;

            case SParamType.BOOLEAN:
                ret = @"BOOLEAN";
                break;

            case SParamType.ENUMERATION:
                ret = @"ENUMERATION";
                break;

            case SParamType.BINARY:
                ret = @"BINARY";
                break;

            case SParamType.LIST:
                ret = @"LIST";
                break;

            case SParamType.LOGICAL:
                ret = @"LOGICAL";
                break;

            case SParamType.SET:
                ret = @"SET";
                break;

            case SParamType.BAG:
                ret = @"BAG";
                break;

            case SParamType.ARRAY:
                ret = @"ARRAY";
                break;

            case SParamType.DERIVED:
                ret = @"DERIVED";
                break;

            case SParamType.SELFDERIVED:
                ret = @"SELFDERIVED";
                break;

            case SParamType.SELECT:
                ret = @"SELECT";
                break;

            case SParamType.UNSET:
            default:
                ret = @"UNSET";
                break;
            }
            return(ret);
        }
Example #15
0
 public void SetType(SParamType stype)
 {
     p_ParamType       = stype;
     p_ParamTypeString = TypeToString(stype);
 }
Example #16
0
 public void SetType(SParamType stype)
 {
     p_ParamType = stype;
     p_ParamTypeString = TypeToString(stype);
 }
Example #17
0
 public SParamCollection(SParamType stype)
     : base(stype)
 {
 }
Example #18
0
 public Parameter(SParamType ParameterType)
 {
     updateParameterType(ParameterType);
 }
Example #19
0
 public void updateParameterType(SParamType ParameterType)
 {
     m_ParameterType = ParameterType;
     m_ParameterTypeName = SParameter.TypeToString(m_ParameterType);
 }
Example #20
0
 public SType(string TypeName, SParamType SAtt)
 {
     Name = TypeName;
     Kind = SAtt;
 }