Skip to main content


Eclipse Community Forums
Forum Search:

Search      Help    Register    Login    Home
Home » Modeling » TMF (Xtext) » issues with hidden and formatter
issues with hidden and formatter [message #713767] Tue, 09 August 2011 02:22 Go to next message
Henrik Lindberg is currently offline Henrik LindbergFriend
Messages: 2509
Registered: July 2009
Senior Member
Hi,
I have an issue with formatting and hidden(), and I am looking for a way
to work around the problem (if possible).

I need to flip hidden on off when parsing expressions like:
$a = "text text ${ 1 + 2 } text text"

(The ${ ... } part is expression interpolation into the string.

I can post the entire grammar (geppetto for Puppet development, but it
is a bit big), but I wonder if I am bit by a known bug, and if I can
work around it.

The problem in my case is that when string interpolation has been used,
the formatter removes all whitespace between tokens after the expression.

I searched for open bugs, and it is a bit difficult to understand a
couple of them (like https://bugs.eclipse.org/bugs/show_bug.cgi?id=335964).

Attempting to work around the issue, I tried numerous combinations of
hidden(), hidden(WS, SL_COMMENT, ...), and I tried inserting rules with
extra rules with assignment (instead of data rules).

I also tried to make the ending '"' be a special rule with data
conversion (did not help).

It seems that the formatter is confused by a call hierarchy of

hidden(WS)
hidden() // "text ${
hidden(WS) // expr + expr
hidden() // } text"
hidden(WS)

Curiously, when the parser is not matching an interpolation expression,
the formatter removes white space after the closing '"' if followed by
something else that is hidden, but the expressions after that have white
space as expected.

.... clueless ...
Hope someone can help.
Regards
- henrik
Re: issues with hidden and formatter [message #713847 is a reply to message #713767] Tue, 09 August 2011 07:10 Go to previous messageGo to next message
Sebastian Zarnekow is currently offline Sebastian ZarnekowFriend
Messages: 3109
Registered: July 2009
Senior Member
Hi Henrik,

without having had a look at the puppet grammar, this is what works fine
for us in MWE2:

FQN:
ID ('.' ID)*;

StringLiteral hidden ():
begin="'"
parts+=PlainString?
(parts+=PropertyReference parts+=PlainString?)*
end="'"
| begin='"'
parts+=PlainString?
(parts+=PropertyReference parts+=PlainString?)*
end='"'
;

PropertyReference hidden():
'${' PropertyReferenceImpl '}';

PropertyReferenceImpl returns PropertyReference hidden(WS, ML_COMMENT,
SL_COMMENT):
referable=[DeclaredProperty|FQN];

PlainString:
value=ConstantValue;

// To identify other keywords as allowed parts in a string,
// we use a customized lexer with predicates.
// This allows us to use e.g. single quotes without escape sequences
// in double quoted strings and vice versa.
ConstantValue:
(WS|
ANY_OTHER|
ID|
"\\'" |
'\\"' |
"\\${" |
"\\\\")+;

The formatting seems to work, too although I've to admit that we
explicitly define noSpace aource the PropertyReferenceImpl.

We used another approach in Xtend which does not rely on a specialized
lexer. If the MWE2 solution would not work for you, I'll double check
the Xtend grammar in combination with a formatter for embedded expressions.

Regards,
Sebastian
--
Need professional support for Eclipse Modeling?
Go visit: http://xtext.itemis.com

On 09.08.11 04:22, Henrik Lindberg wrote:
> Hi,
> I have an issue with formatting and hidden(), and I am looking for a way
> to work around the problem (if possible).
>
> I need to flip hidden on off when parsing expressions like:
> $a = "text text ${ 1 + 2 } text text"
>
> (The ${ ... } part is expression interpolation into the string.
>
> I can post the entire grammar (geppetto for Puppet development, but it
> is a bit big), but I wonder if I am bit by a known bug, and if I can
> work around it.
>
> The problem in my case is that when string interpolation has been used,
> the formatter removes all whitespace between tokens after the expression.
>
> I searched for open bugs, and it is a bit difficult to understand a
> couple of them (like https://bugs.eclipse.org/bugs/show_bug.cgi?id=335964).
>
> Attempting to work around the issue, I tried numerous combinations of
> hidden(), hidden(WS, SL_COMMENT, ...), and I tried inserting rules with
> extra rules with assignment (instead of data rules).
>
> I also tried to make the ending '"' be a special rule with data
> conversion (did not help).
>
> It seems that the formatter is confused by a call hierarchy of
>
> hidden(WS)
> hidden() // "text ${
> hidden(WS) // expr + expr
> hidden() // } text"
> hidden(WS)
>
> Curiously, when the parser is not matching an interpolation expression,
> the formatter removes white space after the closing '"' if followed by
> something else that is hidden, but the expressions after that have white
> space as expected.
>
> ... clueless ...
> Hope someone can help.
> Regards
> - henrik
Re: issues with hidden and formatter [message #713948 is a reply to message #713847] Tue, 09 August 2011 13:07 Go to previous messageGo to next message
Henrik Lindberg is currently offline Henrik LindbergFriend
Messages: 2509
Registered: July 2009
Senior Member
At first glance, that is how my interpolation is also configured,
although the expressions are a bit more complicated.

I also use an external lexer (in the style of mwe2).

Will do one more check (maybe I was cross-eyed yesterday), and then post
the relevant part of the grammar.

- henrik

On 8/9/11 9:10 AM, Sebastian Zarnekow wrote:
> Hi Henrik,
>
> without having had a look at the puppet grammar, this is what works fine
> for us in MWE2:
>
> FQN:
> ID ('.' ID)*;
>
> StringLiteral hidden ():
> begin="'"
> parts+=PlainString?
> (parts+=PropertyReference parts+=PlainString?)*
> end="'"
> | begin='"'
> parts+=PlainString?
> (parts+=PropertyReference parts+=PlainString?)*
> end='"'
> ;
>
> PropertyReference hidden():
> '${' PropertyReferenceImpl '}';
>
> PropertyReferenceImpl returns PropertyReference hidden(WS, ML_COMMENT,
> SL_COMMENT):
> referable=[DeclaredProperty|FQN];
>
> PlainString:
> value=ConstantValue;
>
> // To identify other keywords as allowed parts in a string,
> // we use a customized lexer with predicates.
> // This allows us to use e.g. single quotes without escape sequences
> // in double quoted strings and vice versa.
> ConstantValue:
> (WS|
> ANY_OTHER|
> ID|
> "\\'" |
> '\\"' |
> "\\${" |
> "\\\\")+;
>
> The formatting seems to work, too although I've to admit that we
> explicitly define noSpace aource the PropertyReferenceImpl.
>
> We used another approach in Xtend which does not rely on a specialized
> lexer. If the MWE2 solution would not work for you, I'll double check
> the Xtend grammar in combination with a formatter for embedded expressions.
>
> Regards,
> Sebastian
Re: issues with hidden and formatter [message #713995 is a reply to message #713948] Tue, 09 August 2011 14:19 Go to previous messageGo to next message
Henrik Lindberg is currently offline Henrik LindbergFriend
Messages: 2509
Registered: July 2009
Senior Member
I think I am doing things the same way. Below is the relevant part of
the grammar (or look at github
https://github.com/cloudsmith/geppetto/blob/master/org.cloudsmith.geppetto.pp.dsl/src/org/cloudsmith/geppetto/pp/dsl/PP.xtext):

StringExpression returns pp::Expression
: SingleQuotedString
| UnquotedString
| DoubleQuotedString
;

QuotedString returns pp::IQuotedString
: DoubleQuotedString
| SingleQuotedString
;

SingleQuotedString returns pp::SingleQuotedString
: {pp::SingleQuotedString} text = sqText
;

// Special declarations to aid syntax coloring of a $ in a special place.
DQT_DOLLAR : '$' ;

// Double quoted string with expression interpolation
// handles:
// - $ <non variable char or {> is a verbatim $ included in the string
// - $varname - evaluated and included in the string
// - ${ expression } - evaluated and included in the string
//
DoubleQuotedString returns pp::DoubleQuotedString hidden()
: '"' textExpression = TextExpression '"'
;

// Lowest precedence TextExpression
TextExpression returns pp::TextExpression hidden():
DollarTextExpression
;

DollarTextExpression returns pp::TextExpression hidden():
VariableTextExpression (
{pp::VerbatimTE.leading=current}
text = DQT_DOLLAR
trailing=TextExpression?
)*
;

VariableTextExpression returns pp::TextExpression hidden():
ExpressionTextExpression (
{pp::VariableTE.leading=current}
varName = dollarVariable
trailing = TextExpression?
)*
;

ExpressionTextExpression returns pp::TextExpression hidden():
// allow comments between ${ and }
// validate expression is not null == warning
StringPart (
{pp::ExpressionTE.leading=current}
'${' expression = ExpressionWithHidden '}'
trailing = TextExpression?
)*
;

// Consumation without creation is ok, if made optional where it is
assigned, it is not possible to
// insert WS and comments into ExpressioNTextExpression.
ExpressionWithHidden returns pp::Expression hidden(WS, SL_COMMENT,
ML_COMMENT):
Expression?
;

StringPart returns pp::TextExpression hidden():
{pp::VerbatimTE} text = doubleStringCharacters? ;

UnquotedString returns pp::Expression :
// allow comments between ${ and }
// validate that Expression is not empty == warning
{pp::UnquotedString} '${' expression = Expression? '}'
;

// Has data conversion that strips leading/trailing single quotes
sqText returns ecore::EString hidden():
'\'' singleStringCharacters? '\''
;

// Has validation rule that checks regex validity
LiteralRegex returns pp::LiteralRegex
: value = REGULAR_EXPRESSION
;

// VALIDATION: checks that the name is a NAME (and not a reference).
LiteralName returns pp::LiteralName
: value = unionNameOrReference
;

VariableExpression returns pp::VariableExpression
: varName = dollarVariable
;

dollarVariable hidden()
: '$' (variable | keyword)
;

keyword : ('and' | 'case' | 'class' | 'default' | 'define' | 'else' |
'elsif' | 'in' |'inherits'
| 'import' | 'node' | 'or' | 'undef' | 'true' | 'false' | 'if')
;

variable hidden()
// a puppet grammar glitch allows '::' any number of times (\w*::)*\w+.
Validation checks correctness.
: WORD_CHARS
;

// captures names and references, complicated by the fact that a keyword
may be part of the name
// if the name contains '::' - for more info see the PPLexer
unionNameOrReference hidden()
: WORD_CHARS | 'class' | 'default'
;

doubleStringCharacters hidden()
// special rules in lexer will deliver everything as one of these when
in a string
: (WORD_CHARS
| ANY_OTHER
| WS
| '\\"'
| '\\\''
| '\\$'
| '\\${'
| '\\\\'
)+
;

singleStringCharacters hidden()
// special rules in lexer will deliver everything as one of these when
in a string
: (WORD_CHARS
| ANY_OTHER
| WS
| '$' // terminates dq-, but not sq- string
| '${' // terminates dq-, but not sq- string
| '\\"'
| '\\\''
| '\\$'
| '\\${'
| '\\\\'
)+
;

On 8/9/11 3:07 PM, Henrik Lindberg wrote:
> At first glance, that is how my interpolation is also configured,
> although the expressions are a bit more complicated.
>
> I also use an external lexer (in the style of mwe2).
>
> Will do one more check (maybe I was cross-eyed yesterday), and then post
> the relevant part of the grammar.
>
> - henrik
>
> On 8/9/11 9:10 AM, Sebastian Zarnekow wrote:
>> Hi Henrik,
>>
>> without having had a look at the puppet grammar, this is what works fine
>> for us in MWE2:
>>
>> FQN:
>> ID ('.' ID)*;
>>
>> StringLiteral hidden ():
>> begin="'"
>> parts+=PlainString?
>> (parts+=PropertyReference parts+=PlainString?)*
>> end="'"
>> | begin='"'
>> parts+=PlainString?
>> (parts+=PropertyReference parts+=PlainString?)*
>> end='"'
>> ;
>>
>> PropertyReference hidden():
>> '${' PropertyReferenceImpl '}';
>>
>> PropertyReferenceImpl returns PropertyReference hidden(WS, ML_COMMENT,
>> SL_COMMENT):
>> referable=[DeclaredProperty|FQN];
>>
>> PlainString:
>> value=ConstantValue;
>>
>> // To identify other keywords as allowed parts in a string,
>> // we use a customized lexer with predicates.
>> // This allows us to use e.g. single quotes without escape sequences
>> // in double quoted strings and vice versa.
>> ConstantValue:
>> (WS|
>> ANY_OTHER|
>> ID|
>> "\\'" |
>> '\\"' |
>> "\\${" |
>> "\\\\")+;
>>
>> The formatting seems to work, too although I've to admit that we
>> explicitly define noSpace aource the PropertyReferenceImpl.
>>
>> We used another approach in Xtend which does not rely on a specialized
>> lexer. If the MWE2 solution would not work for you, I'll double check
>> the Xtend grammar in combination with a formatter for embedded
>> expressions.
>>
>> Regards,
>> Sebastian
>
Re: issues with hidden and formatter [message #714185 is a reply to message #713995] Wed, 10 August 2011 02:21 Go to previous messageGo to next message
Henrik Lindberg is currently offline Henrik LindbergFriend
Messages: 2509
Registered: July 2009
Senior Member
I should have said that I am using a specialized lexer (like mwe2).
I now also tried a couple of other variants (this - the head version in
the geppetto repository may be slightly different from what I posted
earlier). None of my experiments helped though.

Help appreciated.

- henrik

On 8/9/11 4:19 PM, Henrik Lindberg wrote:
> I think I am doing things the same way. Below is the relevant part of
> the grammar (or look at github
> https://github.com/cloudsmith/geppetto/blob/master/org.cloudsmith.geppetto.pp.dsl/src/org/cloudsmith/geppetto/pp/dsl/PP.xtext):
>
>
> StringExpression returns pp::Expression
> : SingleQuotedString
> | UnquotedString
> | DoubleQuotedString
> ;
>
> QuotedString returns pp::IQuotedString
> : DoubleQuotedString
> | SingleQuotedString
> ;
>
> SingleQuotedString returns pp::SingleQuotedString
> : {pp::SingleQuotedString} text = sqText
> ;
>
> // Special declarations to aid syntax coloring of a $ in a special place.
> DQT_DOLLAR : '$' ;
>
> // Double quoted string with expression interpolation
> // handles:
> // - $ <non variable char or {> is a verbatim $ included in the string
> // - $varname - evaluated and included in the string
> // - ${ expression } - evaluated and included in the string
> //
> DoubleQuotedString returns pp::DoubleQuotedString hidden()
> : '"' textExpression = TextExpression '"'
> ;
>
> // Lowest precedence TextExpression
> TextExpression returns pp::TextExpression hidden():
> DollarTextExpression
> ;
>
> DollarTextExpression returns pp::TextExpression hidden():
> VariableTextExpression (
> {pp::VerbatimTE.leading=current}
> text = DQT_DOLLAR
> trailing=TextExpression?
> )*
> ;
>
> VariableTextExpression returns pp::TextExpression hidden():
> ExpressionTextExpression (
> {pp::VariableTE.leading=current}
> varName = dollarVariable
> trailing = TextExpression?
> )*
> ;
>
> ExpressionTextExpression returns pp::TextExpression hidden():
> // allow comments between ${ and }
> // validate expression is not null == warning
> StringPart (
> {pp::ExpressionTE.leading=current}
> '${' expression = ExpressionWithHidden '}'
> trailing = TextExpression?
> )*
> ;
>
> // Consumation without creation is ok, if made optional where it is
> assigned, it is not possible to
> // insert WS and comments into ExpressioNTextExpression.
> ExpressionWithHidden returns pp::Expression hidden(WS, SL_COMMENT,
> ML_COMMENT):
> Expression?
> ;
>
> StringPart returns pp::TextExpression hidden():
> {pp::VerbatimTE} text = doubleStringCharacters? ;
>
> UnquotedString returns pp::Expression :
> // allow comments between ${ and }
> // validate that Expression is not empty == warning
> {pp::UnquotedString} '${' expression = Expression? '}'
> ;
>
> // Has data conversion that strips leading/trailing single quotes
> sqText returns ecore::EString hidden():
> '\'' singleStringCharacters? '\''
> ;
>
> // Has validation rule that checks regex validity
> LiteralRegex returns pp::LiteralRegex
> : value = REGULAR_EXPRESSION
> ;
>
> // VALIDATION: checks that the name is a NAME (and not a reference).
> LiteralName returns pp::LiteralName
> : value = unionNameOrReference
> ;
>
> VariableExpression returns pp::VariableExpression
> : varName = dollarVariable
> ;
>
> dollarVariable hidden()
> : '$' (variable | keyword)
> ;
>
> keyword : ('and' | 'case' | 'class' | 'default' | 'define' | 'else' |
> 'elsif' | 'in' |'inherits'
> | 'import' | 'node' | 'or' | 'undef' | 'true' | 'false' | 'if')
> ;
>
> variable hidden()
> // a puppet grammar glitch allows '::' any number of times (\w*::)*\w+.
> Validation checks correctness.
> : WORD_CHARS
> ;
>
> // captures names and references, complicated by the fact that a keyword
> may be part of the name
> // if the name contains '::' - for more info see the PPLexer
> unionNameOrReference hidden()
> : WORD_CHARS | 'class' | 'default'
> ;
>
> doubleStringCharacters hidden()
> // special rules in lexer will deliver everything as one of these when
> in a string
> : (WORD_CHARS
> | ANY_OTHER
> | WS
> | '\\"'
> | '\\\''
> | '\\$'
> | '\\${'
> | '\\\\'
> )+
> ;
>
> singleStringCharacters hidden()
> // special rules in lexer will deliver everything as one of these when
> in a string
> : (WORD_CHARS
> | ANY_OTHER
> | WS
> | '$' // terminates dq-, but not sq- string
> | '${' // terminates dq-, but not sq- string
> | '\\"'
> | '\\\''
> | '\\$'
> | '\\${'
> | '\\\\'
> )+
> ;
>
> On 8/9/11 3:07 PM, Henrik Lindberg wrote:
>> At first glance, that is how my interpolation is also configured,
>> although the expressions are a bit more complicated.
>>
>> I also use an external lexer (in the style of mwe2).
>>
>> Will do one more check (maybe I was cross-eyed yesterday), and then post
>> the relevant part of the grammar.
>>
>> - henrik
>>
>> On 8/9/11 9:10 AM, Sebastian Zarnekow wrote:
>>> Hi Henrik,
>>>
>>> without having had a look at the puppet grammar, this is what works fine
>>> for us in MWE2:
>>>
>>> FQN:
>>> ID ('.' ID)*;
>>>
>>> StringLiteral hidden ():
>>> begin="'"
>>> parts+=PlainString?
>>> (parts+=PropertyReference parts+=PlainString?)*
>>> end="'"
>>> | begin='"'
>>> parts+=PlainString?
>>> (parts+=PropertyReference parts+=PlainString?)*
>>> end='"'
>>> ;
>>>
>>> PropertyReference hidden():
>>> '${' PropertyReferenceImpl '}';
>>>
>>> PropertyReferenceImpl returns PropertyReference hidden(WS, ML_COMMENT,
>>> SL_COMMENT):
>>> referable=[DeclaredProperty|FQN];
>>>
>>> PlainString:
>>> value=ConstantValue;
>>>
>>> // To identify other keywords as allowed parts in a string,
>>> // we use a customized lexer with predicates.
>>> // This allows us to use e.g. single quotes without escape sequences
>>> // in double quoted strings and vice versa.
>>> ConstantValue:
>>> (WS|
>>> ANY_OTHER|
>>> ID|
>>> "\\'" |
>>> '\\"' |
>>> "\\${" |
>>> "\\\\")+;
>>>
>>> The formatting seems to work, too although I've to admit that we
>>> explicitly define noSpace aource the PropertyReferenceImpl.
>>>
>>> We used another approach in Xtend which does not rely on a specialized
>>> lexer. If the MWE2 solution would not work for you, I'll double check
>>> the Xtend grammar in combination with a formatter for embedded
>>> expressions.
>>>
>>> Regards,
>>> Sebastian
>>
>
Re: issues with hidden and formatter [message #714189 is a reply to message #714185] Wed, 10 August 2011 02:33 Go to previous messageGo to next message
Henrik Lindberg is currently offline Henrik LindbergFriend
Messages: 2509
Registered: July 2009
Senior Member
On 8/10/11 4:21 AM, Henrik Lindberg wrote:
> I should have said that I am using a specialized lexer (like mwe2).
> I now also tried a couple of other variants (this - the head version in
> the geppetto repository may be slightly different from what I posted
> earlier). None of my experiments helped though.
>
> Help appreciated.
>
> - henrik
>
I also tried to format with an explicit space after the closing " using
this configuration:
// FormattingConfig c

PPGrammarAccess ga = (PPGrammarAccess) getGrammarAccess();
c.setSpace(" ").after(
ga.getDoubleQuotedStringAccess().getQuotationMarkKeyword_2()
);

But, also has no effect.
- henrik
Re: issues with hidden and formatter [message #714561 is a reply to message #713767] Wed, 10 August 2011 20:17 Go to previous messageGo to next message
Henrik Lindberg is currently offline Henrik LindbergFriend
Messages: 2509
Registered: July 2009
Senior Member
There is now a JUnit test in the cloudsmith/geppetto repository at
github that shows the issue.

org.cloudsmith.geppetto.pp.dsl.tests.TestFailingSerialization

Regards
- henrik

On 8/9/11 4:22 AM, Henrik Lindberg wrote:
> Hi,
> I have an issue with formatting and hidden(), and I am looking for a way
> to work around the problem (if possible).
>
> I need to flip hidden on off when parsing expressions like:
> $a = "text text ${ 1 + 2 } text text"
>
> (The ${ ... } part is expression interpolation into the string.
>
> I can post the entire grammar (geppetto for Puppet development, but it
> is a bit big), but I wonder if I am bit by a known bug, and if I can
> work around it.
>
> The problem in my case is that when string interpolation has been used,
> the formatter removes all whitespace between tokens after the expression.
>
> I searched for open bugs, and it is a bit difficult to understand a
> couple of them (like https://bugs.eclipse.org/bugs/show_bug.cgi?id=335964).
>
> Attempting to work around the issue, I tried numerous combinations of
> hidden(), hidden(WS, SL_COMMENT, ...), and I tried inserting rules with
> extra rules with assignment (instead of data rules).
>
> I also tried to make the ending '"' be a special rule with data
> conversion (did not help).
>
> It seems that the formatter is confused by a call hierarchy of
>
> hidden(WS)
> hidden() // "text ${
> hidden(WS) // expr + expr
> hidden() // } text"
> hidden(WS)
>
> Curiously, when the parser is not matching an interpolation expression,
> the formatter removes white space after the closing '"' if followed by
> something else that is hidden, but the expressions after that have white
> space as expected.
>
> .... clueless ...
> Hope someone can help.
> Regards
> - henrik
Re: issues with hidden and formatter [message #715788 is a reply to message #714561] Mon, 15 August 2011 14:49 Go to previous message
Henrik Lindberg is currently offline Henrik LindbergFriend
Messages: 2509
Registered: July 2009
Senior Member
I really appreciate help with getting this fixed.
Should I log an issue?

Regards
- henrik

On 8/10/11 10:17 PM, Henrik Lindberg wrote:
> There is now a JUnit test in the cloudsmith/geppetto repository at
> github that shows the issue.
>
> org.cloudsmith.geppetto.pp.dsl.tests.TestFailingSerialization
>
> Regards
> - henrik
>
> On 8/9/11 4:22 AM, Henrik Lindberg wrote:
>> Hi,
>> I have an issue with formatting and hidden(), and I am looking for a way
>> to work around the problem (if possible).
>>
>> I need to flip hidden on off when parsing expressions like:
>> $a = "text text ${ 1 + 2 } text text"
>>
>> (The ${ ... } part is expression interpolation into the string.
>>
>> I can post the entire grammar (geppetto for Puppet development, but it
>> is a bit big), but I wonder if I am bit by a known bug, and if I can
>> work around it.
>>
>> The problem in my case is that when string interpolation has been used,
>> the formatter removes all whitespace between tokens after the expression.
>>
>> I searched for open bugs, and it is a bit difficult to understand a
>> couple of them (like
>> https://bugs.eclipse.org/bugs/show_bug.cgi?id=335964).
>>
>> Attempting to work around the issue, I tried numerous combinations of
>> hidden(), hidden(WS, SL_COMMENT, ...), and I tried inserting rules with
>> extra rules with assignment (instead of data rules).
>>
>> I also tried to make the ending '"' be a special rule with data
>> conversion (did not help).
>>
>> It seems that the formatter is confused by a call hierarchy of
>>
>> hidden(WS)
>> hidden() // "text ${
>> hidden(WS) // expr + expr
>> hidden() // } text"
>> hidden(WS)
>>
>> Curiously, when the parser is not matching an interpolation expression,
>> the formatter removes white space after the closing '"' if followed by
>> something else that is hidden, but the expressions after that have white
>> space as expected.
>>
>> .... clueless ...
>> Hope someone can help.
>> Regards
>> - henrik
>
Previous Topic:How to open the file specified by "importURI"?
Next Topic:Running MWE2 with maven2
Goto Forum:
  


Current Time: Mon Apr 19 18:55:09 GMT 2021

Powered by FUDForum. Page generated in 0.02269 seconds
.:: Contact :: Home ::.

Powered by: FUDforum 3.0.2.
Copyright ©2001-2010 FUDforum Bulletin Board Software

Back to the top