Inheritance: Runtime.Object
Esempio n. 1
0
        void PushToOutputStreamIndividual(Runtime.Object obj)
        {
            var glue = obj as Runtime.Glue;
            var text = obj as Runtime.StringValue;

            bool includeInOutput = true;

            if (glue)
            {
                // Found matching left-glue for right-glue? Close it.
                Glue matchingRightGlue = null;
                if (glue.isLeft)
                {
                    matchingRightGlue = MatchRightGlueForLeftGlue(glue);
                }

                // Left/Right glue is auto-generated for inline expressions
                // where we want to absorb newlines but only in a certain direction.
                // "Bi" glue is written by the user in their ink with <>
                if (glue.isLeft || glue.isBi)
                {
                    TrimNewlinesFromOutputStream(matchingRightGlue);
                }

                includeInOutput = glue.isBi || glue.isRight;
            }

            else if (text)
            {
                if (currentGlueIndex != -1)
                {
                    // Absorb any new newlines if there's existing glue
                    // in the output stream.
                    // Also trim any extra whitespace (spaces/tabs) if so.
                    if (text.isNewline)
                    {
                        TrimFromExistingGlue();
                        includeInOutput = false;
                    }

                    // Able to completely reset when
                    else if (text.isNonWhitespace)
                    {
                        RemoveExistingGlue();
                    }
                }
                else if (text.isNewline)
                {
                    if (outputStreamEndsInNewline || !outputStreamContainsContent)
                    {
                        includeInOutput = false;
                    }
                }
            }

            if (includeInOutput)
            {
                _outputStream.Add(obj);
            }
        }
Esempio n. 2
0
 protected Parsed.Wrap<Runtime.Glue> Glue()
 {
     // Don't want to parse whitespace, since it might be important
     // surrounding the glue.
     var glueStr = ParseString("<>");
     if (glueStr != null) {
         var glue = new Runtime.Glue (Runtime.GlueType.Bidirectional);
         return new Parsed.Wrap<Runtime.Glue> (glue);
     } else {
         return null;
     }
 }
Esempio n. 3
0
        protected Parsed.Glue Glue()
        {
            // Don't want to parse whitespace, since it might be important
            // surrounding the glue.
            var glueStr = ParseString("<>");

            if (glueStr != null)
            {
                var glue = new Runtime.Glue(Runtime.GlueType.Bidirectional);
                return(new Parsed.Glue(glue));
            }
            else
            {
                return(null);
            }
        }
        Runtime.Glue MatchRightGlueForLeftGlue(Glue leftGlue)
        {
            if (!leftGlue.isLeft)
            {
                return(null);
            }

            for (int i = _outputStream.Count - 1; i >= 0; i--)
            {
                var c = _outputStream [i];
                var g = c as Glue;
                if (g && g.isRight && g.parent == leftGlue.parent)
                {
                    return(g);
                }
                else if (c is ControlCommand)   // e.g. BeginString
                {
                    break;
                }
            }

            return(null);
        }
        void TrimNewlinesFromOutputStream(Glue rightGlueToStopAt)
        {
            int  removeWhitespaceFrom = -1;
            int  rightGluePos         = -1;
            bool foundNonWhitespace   = false;

            // Work back from the end, and try to find the point where
            // we need to start removing content. There are two ways:
            //  - Start from the matching right-glue (because we just saw a left-glue)
            //  - Simply work backwards to find the first newline in a string of whitespace
            int i = _outputStream.Count - 1;

            while (i >= 0)
            {
                var obj  = _outputStream [i];
                var cmd  = obj as ControlCommand;
                var txt  = obj as StringValue;
                var glue = obj as Glue;

                if (cmd || (txt && txt.isNonWhitespace))
                {
                    foundNonWhitespace = true;
                    if (rightGlueToStopAt == null)
                    {
                        break;
                    }
                }
                else if (rightGlueToStopAt && glue == rightGlueToStopAt)
                {
                    rightGluePos = i;
                    break;
                }
                else if (txt && txt.isNewline && !foundNonWhitespace)
                {
                    removeWhitespaceFrom = i;
                }
                i--;
            }

            // Remove the whitespace
            if (removeWhitespaceFrom >= 0)
            {
                i = removeWhitespaceFrom;
                while (i < _outputStream.Count)
                {
                    var text = _outputStream [i] as StringValue;
                    if (text)
                    {
                        _outputStream.RemoveAt(i);
                    }
                    else
                    {
                        i++;
                    }
                }
            }

            // Remove the glue (it will come before the whitespace,
            // so index is still valid)
            // Also remove any other non-matching right glues that come after,
            // since they'll have lost their matching glues already
            if (rightGlueToStopAt && rightGluePos > -1)
            {
                i = rightGluePos;
                while (i < _outputStream.Count)
                {
                    if (_outputStream [i] is Glue && ((Glue)_outputStream [i]).isRight)
                    {
                        _outputStream.RemoveAt(i);
                    }
                    else
                    {
                        i++;
                    }
                }
            }

            OutputStreamDirty();
        }
Esempio n. 6
0
        Runtime.Glue MatchRightGlueForLeftGlue (Glue leftGlue)
        {
            if (!leftGlue.isLeft) return null;

            for (int i = _outputStream.Count - 1; i >= 0; i--) {
                var c = _outputStream [i];
                var g = c as Glue;
                if (g && g.isRight && g.parent == leftGlue.parent) {
                    return g;
                } else if (c is ControlCommand) // e.g. BeginString
                    break;
            }

            return null;
        }
Esempio n. 7
0
        void TrimNewlinesFromOutputStream(Glue rightGlueToStopAt)
        {
            int removeWhitespaceFrom = -1;
            int rightGluePos = -1;
            bool foundNonWhitespace = false;

            // Work back from the end, and try to find the point where
            // we need to start removing content. There are two ways:
            //  - Start from the matching right-glue (because we just saw a left-glue)
            //  - Simply work backwards to find the first newline in a string of whitespace
            int i = _outputStream.Count-1;
            while (i >= 0) {
                var obj = _outputStream [i];
                var cmd = obj as ControlCommand;
                var txt = obj as StringValue;
                var glue = obj as Glue;

                if (cmd || (txt && txt.isNonWhitespace)) {
                    foundNonWhitespace = true;
                    if( rightGlueToStopAt == null )
                        break;
                } else if (rightGlueToStopAt && glue == rightGlueToStopAt) {
                    rightGluePos = i;
                    break;
                } else if (txt && txt.isNewline && !foundNonWhitespace) {
                    removeWhitespaceFrom = i;
                }
                i--;
            }

            // Remove the whitespace
            if (removeWhitespaceFrom >= 0) {
                i=removeWhitespaceFrom;
                while(i < _outputStream.Count) {
                    var text = _outputStream [i] as StringValue;
                    if (text) {
                        _outputStream.RemoveAt (i);
                    } else {
                        i++;
                    }
                }
            }

            // Remove the glue (it will come before the whitespace,
            // so index is still valid)
            // Also remove any other non-matching right glues that come after,
            // since they'll have lost their matching glues already
            if (rightGlueToStopAt && rightGluePos > -1) {
                i = rightGluePos;
                while(i < _outputStream.Count) {
                    if (_outputStream [i] is Glue && ((Glue)_outputStream [i]).isRight) {
                        _outputStream.RemoveAt (i);
                    } else {
                        i++;
                    }
                }
            }
        }