public ScaleType(string name, string refpoint, UnitType unit, NumExpr offset) :
     base(MeasureType.DefaultNamespace, name)
 {
     RefPoint = refpoint;
     Unit     = unit;
     Offset   = offset;
 }
        public void Encode(ASTSum node)
        {
            NumExpr rhs = m_stack.Pop();
            NumExpr lhs = m_stack.Pop();

            m_stack.Push(new NumExpr(lhs.IsTrueValue && rhs.IsTrueValue, lhs.Value + rhs.Value, String.Format("{0} + {1}", lhs.Code, rhs.Code)));
        }
        public void Encode(ASTUnary node)
        {
            NumExpr expr = m_stack.Pop();

            m_stack.Push(node.Plus ?
                         new NumExpr(expr.IsTrueValue, expr.Value, String.Format("+{0}", expr.Code)) :
                         new NumExpr(expr.IsTrueValue, expr.Value.Negate(), String.Format("-{0}", expr.Code))
                         );
        }
        //<Dim Expr> ::= <Dim Expr> '|' <Dim Term>
        //           |   <Dim Term>
        public bool GetDimExpr(UnitType candidate, NumericType numType)
        {
            ASTNode basic = GetDimTerm(candidate, numType);

            if (basic == null)
            {
                return(false);
            }

            candidate.Sense  = m_senseEncoder.Encode(basic);
            candidate.Factor = m_exprEncoder.Encode(basic, numType);
            basic.Normalized().Bind(candidate);

            while (m_symbol == Lexer.Symbol.Pipe)
            {
                GetToken();

                ASTNode alternate = GetDimTerm(candidate, numType);
                if (alternate == null)
                {
                    return(false);
                }

                SenseExpr sense = m_senseEncoder.Encode(alternate);
                if (sense.Value != candidate.Sense.Value)
                {
                    Note("{0}: inconsistent dimensions: {1} == {2} != {3} == {4}.",
                         candidate.Name, candidate.Sense.Code, candidate.Sense.Value, sense.Value, sense.Code);
                    return(false);
                }
                NumExpr factor = m_exprEncoder.Encode(alternate, numType);
                if (factor.IsTrueValue && candidate.Factor.IsTrueValue && (factor.Value != candidate.Factor.Value))
                {
                    Note("{0}: inconsistent conversion factors: {1} == {2} != {3} == {4}.",
                         candidate.Name, candidate.Factor.Code, candidate.Factor.Value, factor.Value, factor.Code);
                    return(false);
                }
                alternate.Normalized().Bind(candidate);
            }
            return(true);
        }
Exemple #5
0
 public UnitType(string name, SenseExpr sense, NumExpr factor) :
     this(name)
 {
     Sense  = sense;
     Factor = factor;
 }
        public void Encode(ASTParenthesized node)
        {
            NumExpr expr = m_stack.Pop();

            m_stack.Push(new NumExpr(expr.IsTrueValue, expr.Value, String.Format("({0})", expr.Code)));
        }
Exemple #7
0
        // <Scale> ::= 'scale' Identifier <Format> Identifier '=' Identifier <Num Expr> ';'
        //      1st identifier = scale identifier,
        //      2nd identifier = ref.point identifier,
        //      3rd identifier = unit identifier,
        private bool ParseScale()
        {
            // Identifier (scale name)
            string scaleName = GetEntityName("scale");

            if (scaleName == null)
            {
                return(false);
            }

            // Format
            string format = GetFormat(scaleName, String.Empty);

            if (format == null)
            {
                return(false);
            }

            // Identifier (refpoint)
            string refpoint = GetReferencePoint(scaleName);

            if (refpoint == null)
            {
                return(false);
            }

            // "="
            if (m_symbol == Lexer.Symbol.EQ)
            {
                GetToken();
            }
            else
            {
                Note("{0}: \"{1}\" found while expected equal sign \"=\".", scaleName, m_token);
                return(false);
            }

            // Identifier (unit)
            UnitType unit = GetScaleUnit(refpoint, scaleName);

            if (unit == null)
            {
                return(false);
            }

            // Scale offset <Num Expr>
            ASTNode offsetAST = GetNumExpr(scaleName, unit.Factor.Value.Type);

            if (offsetAST == null)
            {
                return(false);
            }

            // Semicolon ";"
            bool done = GetSemicolon(scaleName);

            if (done)
            {
                NumExpr   offsetExpr = m_exprEncoder.Encode(offsetAST, unit.Factor.Value.Type);
                ScaleType scale      = new ScaleType(scaleName, refpoint, unit, offsetExpr);
                scale.Format = String.IsNullOrWhiteSpace(format) ? unit.Format : format;
                ScaleType relative = GetRelativeScale(scale);
                if (relative != null)
                {
                    relative.AddRelative(scale);
                }
                m_scales.Add(scale);
            }
            return(done);
        }