__Mask GenericMask {
    __MaskDefault = Typ;
    __Spec = ProductSpec;
    __Spec = genericSpec;
        run_vddio = Meas;
        run_vddiob = Meas;
}

Mask:
 '__Mask' name=ID '{'
 ('__MaskDefault' '=' default_range=Range ';')?
 ('__Spec' '=' spec_table_names+=ID ';')*
 spec_var+=MaskElement*
 '}';

MaskElement:
 spec_name=ID '=' spec_range=Range ';';

Range:
 'Min' | 'Typ' | 'Max' | 'Meas';

	def void setIndentation4SpacesInsteadOfTabs()
	{
		val preferences = getPreferences
		val newMap = Maps.<String, String> newLinkedHashMap
		newMap.put(FormatterPreferenceKeys.indentation.id, '    ') // $NON-NLS-1$
		val result = new MapBasedPreferenceValues(preferences, newMap)
		request.preferences = result
	}

	def dispatch void format(Mask mask, extension IFormattableDocument document) {
		setIndentation4SpacesInsteadOfTabs()		
		val open = mask.regionFor.keyword("{")
		open.append[setNewLines(1)]
		val close = mask.regionFor.keyword("}")
		close.append[setNewLines(1)]
		interior(open, close)[indent]
		
		for ( ISemanticRegion keyword : mask.regionFor.keywords( ";" ) )
		{
			keyword.prepend[noSpace]
			keyword.append[setNewLines(1)]
		}
			
		for ( MaskElement element: mask.spec_var)
		{
			element.format()
		}
	}		

	def dispatch void format(MaskElement mask_var, extension IFormattableDocument document) {
		for ( ISemanticRegion keyword : mask_var.regionFor.keywords( ";" ) )
		{
			keyword.prepend[noSpace]
			keyword.append[setNewLines(1)]
		}
	}		

	def dispatch void format(MaskElement mask_var, extension IFormattableDocument document) {
		for ( ISemanticRegion keyword : mask_var.regionFor.keywords( ";" ) )
		{
			keyword.prepend[noSpace]
			keyword.append[setNewLines(1)]
		}
		val region = mask_var.regionFor.feature(UnaDslPackage.Literals.MASK_ELEMENT__SPEC_NAME)
		val r = new AbstractTextReplacer(document, region) {
            override createReplacements(ITextReplacerContext it) {
                val offset = region.offset
                it.addReplacement(region.textRegionAccess.rewriter.createReplacement(offset, 0, "                 "))
                it
                }
            }
            addReplacer(r)
	}	

class MyDslParsingTest {
	@Inject
	FormatterTestHelper h
	
	@Test
	def void testIt() {
		h.assertFormatted[
			toBeFormatted = '''
			__Mask GenericMask {
			    __MaskDefault = Typ;
			    __Spec = ProductSpec;
			    __Spec = genericSpec;
			        run_vddio = Meas;
			        run_vddiob = Meas;
			}
			'''
			expectation = '''
			__Mask GenericMask {
			    __MaskDefault = Typ;
			    __Spec = ProductSpec;
			    __Spec = genericSpec;
			    run_vddio = Meas;
			    run_vddiob = Meas;
			}
			'''
		]
	}	
	
}
	

	def void setIndentation( ISemanticRegion open, ISemanticRegion close, int indentLevel, extension IFormattableDocument document )
	{
		for ( var index = 0; index < indentLevel; index++ )
		{
			interior(open, close)[indent]
		}
	}

Unison:SyntaxRevision1709.19;
__Levels TL_Opens {
    __AlwaysExec = __Expression { __String = "FALSE"; __Type = BOOLEAN; }
    __Column[0] {
        __LevelsColumnType = __DCTestType;
        __Group = __Expression { __String = "PD_IOs_pl-pads_t5p5_pl+pads_analog_pl-boardRes_pl-USB0ID_pl-ResetN_pl"; }
        __ForceValue = __Expression { __String = "-pad_i_esd_min"; }
        __ForceRange = __Expression { __String = "-pad_i_esd_min*1.1"; }
        __MeasureRange = __Expression { __String = "-pad_vt_esd_max*1.1"; }
        __LowClamp = __Expression { __String = "max(-pad_vt_esd_max*1.3-Dx_Gx_V_Clamp_Acc_Offset,Tester_AbsoluteMaximumRatings_GX1x_V_min)"; }
        __HighClamp = __Expression { __String = "0V+Dx_Gx_V_Clamp_Acc_Offset"; }
        __LowLimit = __Expression { __String = "-pad_vt_esd_max"; }
    }
}

UnaFile:
 header=Header (una_elements+=Levels)*;

Header:
 'Unison:SyntaxRevision' version=Decimal ';';

Levels:
 '__Levels' name=ID '{'
 ('__AlwaysExec' '=' always_exec=ExpressionType)?
 (columns_list+=Column)*
 '}';

Column:
 '__Column' '[' index=INT ']' '{'
 '__LevelsColumnType' '=' column_type=('__VIType' | '__DigitalType' | '__DCTestType' | '__SeqPowerType') ';'
 ('__Title' '=' title=ID ';')?
 statements+=LevelColumnStatement*
 '}';

LevelColumnStatement:
(level_param_type=('__Group' | 'PowerSupply' | 'StepSize' | '__ForceValue' | '__ForceRange' | '__LowClamp' | '__HighClamp' | '__MeasureRange' | '__LowLimit' | '__HighLimit' | 
  'ExecSeq' | 'Delay' | 'Vil' | 'Vih' | 'Vol' | 'Voh' | 'Iol' | 'Ioh' | 'Vref' | 'Rlv' | 'ClampLo' | 'ClampHi'
) '=' level_param_value=ExpressionType);

ExpressionType:{ExpressionType}
 '__Expression' '{' ('__String' '=' expr=STRING ';')? ('__Type' '=' type=ExpressionTypeValue ';')? ('__Mode' '=' dir=Direction ';')?
 '}';

ExpressionTypeValue:
 'ANY_REAL' | 'PIN' | 's' | 'BOOLEAN' | 'INTEGER' | 'SyncType:';

	def void setIndentationPreferences( )
	{
		val preferences = getPreferences
		val newMap = Maps.<String, String> newLinkedHashMap
		newMap.put(FormatterPreferenceKeys.indentation.id, ' ') // $NON-NLS-1$
		val result = new MapBasedPreferenceValues(preferences, newMap)
		request.preferences = result
	}
        def void setIndentation( ISemanticRegion open, ISemanticRegion close, int indentLevel, extension IFormattableDocument document )
	{
		for ( var index = 0; index < indentLevel; index++ )
		{
			interior(open, close)[indent]
		}
	}
	def void setIndentationWith4Spaces( ISemanticRegion open, ISemanticRegion close, extension IFormattableDocument document )
	{
		setIndentation(open, close, FOUR_SPACES, document )
	}

	def dispatch void format(UnaFile unaFile, extension IFormattableDocument document) {
		setIndentationPreferences( )
		unaFile.header.format
		for (UnaElement unaElements : unaFile.una_elements) {
			unaElements.format;
		}
	}

	def dispatch void format(Header header, extension IFormattableDocument document) {
		header.append[setNewLines(1)]
		header.regionFor.keyword( "Unison:SyntaxRevision" ).append[noSpace]
		header.regionFor.keyword( ";" ).prepend[noSpace]
	}

	def dispatch void format(Levels level, extension IFormattableDocument document) {

		level.append[setNewLines(1)]
		val open = level.regionFor.keyword("{")
		val close = level.regionFor.keyword("}")
		open.append[setNewLines(1)]
		setIndentationWith4Spaces(open, close, document)
		
		level.always_exec.format()
		for ( Column column: level.columns_list)
		{
			column.format()
		}	
	}
			
	def dispatch void format(Column col, extension IFormattableDocument document) {

		col.append[setNewLines(1)]
		val open = col.regionFor.keyword("{")
		val close = col.regionFor.keyword("}")
		open.append[setNewLines(1)]
		setIndentationWith4Spaces(open, close, document)
		
		for ( ISemanticRegion keyword : col.regionFor.keywords( ";" ) )
		{
			keyword.prepend[noSpace]
			keyword.append[setNewLines(1)]
		}
		col.regionFor.keyword( "[" ).prepend[noSpace]
		col.regionFor.keyword( "[" ).append[noSpace]
		col.regionFor.keyword( "]" ).prepend[noSpace]
		
		
		for ( LevelColumnStatement col_statement: col.statements)
		{
			col_statement.format()
		}
	}
		
	def dispatch void format(LevelColumnStatement col_statement, extension IFormattableDocument document) {
		col_statement.level_param_value.format()
	}	

	def dispatch void format(ExpressionType expression, extension IFormattableDocument document) {
		for ( ISemanticRegion keyword : expression.regionFor.keywords( ";" ) )
		{
			keyword.prepend[noSpace]
		}
		expression.regionFor.keyword( "}" ).append[setNewLines(1)]
	}