예제 #1
0
		public void visit(compiler_directive_list _compiler_directive_list)
		{
			bw.Write((Int16)171);
			write_compiler_directive_list(_compiler_directive_list);
		}
예제 #2
0
		public void write_compiler_directive_list(compiler_directive_list _compiler_directive_list)
		{
			write_compiler_directive(_compiler_directive_list);
			if (_compiler_directive_list.directives == null)
			{
				bw.Write((byte)0);
			}
			else
			{
				bw.Write((byte)1);
				bw.Write(_compiler_directive_list.directives.Count);
				for(Int32 ssyy_i = 0; ssyy_i < _compiler_directive_list.directives.Count; ssyy_i++)
				{
					if (_compiler_directive_list.directives[ssyy_i] == null)
					{
						bw.Write((byte)0);
					}
					else
					{
						bw.Write((byte)1);
						_compiler_directive_list.directives[ssyy_i].visit(this);
					}
				}
			}
		}
예제 #3
0
        public override void visit(compiler_directive_list _compiler_directive_list)
        {

        }
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//CreateNonTerminalObject
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

public Object CreateNonTerminalObject()
{
switch ((RuleConstants)LRParser.ReductionRule.Index)
{
	case RuleConstants.RULE_PREPROCESSOR_PROGRAM :
	//<preprocessor_program> ::= <preprocessor_lexems> <empty>
			{
                        compilation_unit _compilation_unit = new compilation_unit();

                        _compilation_unit.Language = LanguageId.PascalABCNET;
                        if (LRParser.GetReductionSyntaxNode(0) != null)
                        {
                            parsertools.create_source_context(_compilation_unit, LRParser.GetReductionSyntaxNode(0), LRParser.GetReductionSyntaxNode(0));
                            CompilerDirectives.AddRange(((compiler_directive_list)LRParser.GetReductionSyntaxNode(0)).directives);
                            if (CompilerDirectives.Count != 0)
                                prepr.CompilerDirectives.AddRange(CompilerDirectives);
                        }

                        return _compilation_unit;
                    }
	case RuleConstants.RULE_PREPROCESSOR_LEXEMS :
	//<preprocessor_lexems> ::= <_preprocessor_lexems>
			return LRParser.GetReductionSyntaxNode(0);
	case RuleConstants.RULE_PREPROCESSOR_LEXEMS2 :
	//<preprocessor_lexems> ::= 
	//NONTERMINAL:<preprocessor_lexems> ::= 
	return null;
	//ENDNONTERMINAL
	case RuleConstants.RULE__PREPROCESSOR_LEXEMS :
	//<_preprocessor_lexems> ::= <preprocessor_lexem> <empty>
			{
                        compiler_directive_list _compiler_directive_list = new compiler_directive_list();

                        if (LRParser.GetReductionSyntaxNode(0) is compiler_directive)
                            _compiler_directive_list.directives.Add((compiler_directive)LRParser.GetReductionSyntaxNode(0));
                        parsertools.create_source_context(_compiler_directive_list, LRParser.GetReductionSyntaxNode(0), LRParser.GetReductionSyntaxNode(0));
                        return _compiler_directive_list;
                    }
	case RuleConstants.RULE__PREPROCESSOR_LEXEMS2 :
	//<_preprocessor_lexems> ::= <preprocessor_lexems> <preprocessor_lexem>
			{
                        compiler_directive_list _compiler_directive_list = (compiler_directive_list)LRParser.GetReductionSyntaxNode(0);
                        if (LRParser.GetReductionSyntaxNode(1) is compiler_directive)
                            _compiler_directive_list.directives.Add((compiler_directive)LRParser.GetReductionSyntaxNode(1));
                        parsertools.create_source_context(_compiler_directive_list, LRParser.GetReductionSyntaxNode(0), LRParser.GetReductionSyntaxNode(1));
                        return _compiler_directive_list;
                    }
	case RuleConstants.RULE_PREPROCESSOR_LEXEM_TK_NEWLINE :
	//<preprocessor_lexem> ::= 'TK_NEWLINE'
			return LRParser.GetReductionSyntaxNode(0);
	case RuleConstants.RULE_PREPROCESSOR_LEXEM_TK_SLASH :
	//<preprocessor_lexem> ::= 'TK_SLASH'
			{
                        if (prepr.sm.AllowWrite())
                            prepr.WriteToStream(((token_info)LRParser.GetReductionSyntaxNode(0)).source_context, ((token_info)LRParser.GetReductionSyntaxNode(0)).text);
                        return LRParser.GetReductionSyntaxNode(0);
                    }
	case RuleConstants.RULE_PREPROCESSOR_LEXEM_TK_SLASHEKV :
	//<preprocessor_lexem> ::= 'TK_SLASHEKV'
			{
                        if (prepr.sm.AllowWrite())
                            prepr.WriteToStream(((token_info)LRParser.GetReductionSyntaxNode(0)).source_context, ((token_info)LRParser.GetReductionSyntaxNode(0)).text);
                        return LRParser.GetReductionSyntaxNode(0);
                    }
	case RuleConstants.RULE_PREPROCESSOR_LEXEM_TK_AP :
	//<preprocessor_lexem> ::= 'TK_AP'
			{
                        if (prepr.sm.AllowWrite())
                            prepr.WriteToStream(((token_info)LRParser.GetReductionSyntaxNode(0)).source_context, ((token_info)LRParser.GetReductionSyntaxNode(0)).text);
                        return LRParser.GetReductionSyntaxNode(0);
                    }
	case RuleConstants.RULE_PREPROCESSOR_LEXEM_TK_KAV :
	//<preprocessor_lexem> ::= 'TK_KAV'
			{
                        if (prepr.sm.AllowWrite())
                            prepr.WriteToStream(((token_info)LRParser.GetReductionSyntaxNode(0)).source_context, ((token_info)LRParser.GetReductionSyntaxNode(0)).text);
                        return LRParser.GetReductionSyntaxNode(0);
                    }
	case RuleConstants.RULE_PREPROCESSOR_LEXEM_TK_PROGRAM_LINE :
	//<preprocessor_lexem> ::= 'TK_PROGRAM_LINE'
			{
                        if (prepr.sm.AllowWrite())
                            prepr.WriteToStream(((token_info)LRParser.GetReductionSyntaxNode(0)).source_context, ((token_info)LRParser.GetReductionSyntaxNode(0)).text);
                        return LRParser.GetReductionSyntaxNode(0);
                    }
	case RuleConstants.RULE_PREPROCESSOR_LEXEM_TK_DIRECTIVE :
	//<preprocessor_lexem> ::= 'TK_DIRECTIVE' <empty>
			{
                bool inline = ( ((token_info)LRParser.GetReductionSyntaxNode(0)).source_context.begin_position.line_num - ((token_info)LRParser.GetReductionSyntaxNode(0)).source_context.end_position.line_num == 0 );
                string token_text = ((token_info)LRParser.GetReductionSyntaxNode(0)).text;

                if (token_text[1] == '$' && inline)
                {
                        compiler_directive _compiler_directive = (compiler_directive)pascal_parsertools.MakeDirective((token_info)LRParser.GetReductionSyntaxNode(0));
                        _compiler_directive.source_context.FileName = prepr.CurrentFileName;
                        prepr.CurrentFileName = _compiler_directive.source_context.FileName;

                        //INCLUDE
                        if (_compiler_directive.Name.text == prepr.INCLUDE)
                        {
                            if (prepr.sm.AllowWrite())
                            {
                                string IncludeFileName = _compiler_directive.Directive.text;
                                if (prepr.ProcessedFileNames.Contains(IncludeFileName) || Path.GetFileName(prepr.CurrentFileName) == Path.GetFileName(IncludeFileName))
                                {
                                    prepr.Errors.Add(new CircularInclude(prepr.CurrentFileName, _compiler_directive.source_context, null, IncludeFileName));
                                }
                                else
                                {
                                    if (!(bool)prepr.SourceFilesProvider(IncludeFileName, SourceFileOperation.Exists))
                                        prepr.Errors.Add(new IncludeFileNotFound(prepr.CurrentFileName, _compiler_directive.source_context, null, IncludeFileName));
                                    string b = prepr.CurrentFileName;
                                    //string t = prepr.SourceText;
                                    //string[] sl = prepr.SourceLines;
                                    prepr.ProcessFile(IncludeFileName);
                                    prepr.CurrentFileName = b;
                                    //prepr.SourceText = t;
                                    //prepr.SourceLines = sl;
                                    prepr.ProcessedFileNames.Remove(IncludeFileName);
                                }
                            }
                            return _compiler_directive;
                        }
                        //DEFINE                        
                        if (_compiler_directive.Name.text == prepr.DEFINE)
                        {
                            if (prepr.sm.AllowWrite())
                            {
                                string directive = _compiler_directive.Directive.text;
                                string name = prepr.getFirstIdent(directive);
                                string text = prepr.getSecondIdent(directive);
                                prepr.AddDefineDirective(name, text, _compiler_directive);
                            }
                            return _compiler_directive;
                        }
                        //UNDEF                        
                        if (_compiler_directive.Name.text == prepr.UNDEF)
                        {
                            if (prepr.sm.AllowWrite())
                            {
                                string directive = _compiler_directive.Directive.text;
                                string name = prepr.getFirstIdent(directive);
                                if (name != null)
                                    if (prepr.DefineDirectiveDefinded(name))
                                        prepr.DeleteDefineDirective(name, _compiler_directive);
                            }
                            return _compiler_directive;
                        }
                        //IFDEF                        
                        if (_compiler_directive.Name.text == prepr.IFDEF)
                        {
                            string directive = _compiler_directive.Directive.text;
                            if (prepr.sm.AllowWrite())
                            {

                                if (directive != null)
                                {
                                    if (!prepr.DefineDirectiveDefinded(directive))
                                        prepr.sm.ChangeState(false, 1);
                                    else
                                        prepr.sm.ChangeState(true, 1);
                                }

                            }
                            else
                                prepr.sm.ChangeState(false, -1);
                            return _compiler_directive;
                        }
                        //IFNDEF                        
                        if (_compiler_directive.Name.text == prepr.IFNDEF)
                        {
                            string directive = _compiler_directive.Directive.text;
                            if (prepr.sm.AllowWrite())
                            {

                                if (directive != null)
                                {
                                    if (prepr.DefineDirectiveDefinded(directive))
                                        prepr.sm.ChangeState(false, 1);
                                    else
                                        prepr.sm.ChangeState(true, 1);
                                }

                            }
                            else
                                prepr.sm.ChangeState(false, -1);
                            return _compiler_directive;
                        }
                        //ELSE                        
                        if (_compiler_directive.Name.text == prepr.ELSE)
                        {
                            if (prepr.sm.GetEndifCount() == 0 || prepr.sm.AllowElse() == false)
                            {
                                prepr.Errors.Add(new UnexpectedElse(prepr.CurrentFileName, _compiler_directive.source_context));
                            }
                            else
                            {
                                if (prepr.sm.AllowWrite())
                                    prepr.sm.ChangeState(false, false);
                                else
                                {
                                    if (prepr.sm.LastCondition() == 1)
                                        prepr.sm.ChangeState(true, false);
                                    else
                                        prepr.sm.ChangeState(false, false);
                                }
                            }
                            return _compiler_directive;
                        }
                        //ENDIF                        
                        if (_compiler_directive.Name.text == prepr.ENDIF)
                        {
                            if (prepr.sm.GetEndifCount() == 0)
                            {
                                prepr.Errors.Add(new UnexpectedEndif(prepr.CurrentFileName, _compiler_directive.source_context));
                            }
                            else
                            {
                                if (prepr.sm.AllowWrite())
                                    prepr.sm.ChangeState(true, true);
                                else
                                {
                                    if (prepr.sm.LastEndifCondition() == 1)
                                        prepr.sm.ChangeState(true, true);
                                    else
                                        prepr.sm.ChangeState(false, true);
                                }
                            }
                            return _compiler_directive;
                        }
                        return _compiler_directive;
                  }
                return LRParser.GetReductionSyntaxNode(0);
              }
	case RuleConstants.RULE_EMPTY :
	//<empty> ::= 
	//NONTERMINAL:<empty> ::= 
	return null;
	//ENDNONTERMINAL
}
throw new RuleException("Unknown rule");
}  
		public void read_compiler_directive_list(compiler_directive_list _compiler_directive_list)
		{
			read_compiler_directive(_compiler_directive_list);
			if (br.ReadByte() == 0)
			{
				_compiler_directive_list.directives = null;
			}
			else
			{
				_compiler_directive_list.directives = new List<compiler_directive>();
				Int32 ssyy_count = br.ReadInt32();
				for(Int32 ssyy_i = 0; ssyy_i < ssyy_count; ssyy_i++)
				{
					_compiler_directive_list.directives.Add(_read_node() as compiler_directive);
				}
			}
		}
		public void visit(compiler_directive_list _compiler_directive_list)
		{
			read_compiler_directive_list(_compiler_directive_list);
		}
예제 #7
0
 public override void visit(compiler_directive_list node)
 {
     prepare_collection(node.directives, "directives");
 }
 public override void visit(compiler_directive_list _compiler_directive_list)
 {
     throw new NotImplementedException();
 }
        public Object CreateNonTerminalObject()
        {
            switch ((RuleConstants) LRParser.ReductionRule.Index)
            {
		case RuleConstants.RULE_PREPROCESSOR_PROGRAM :
		//<preprocessor_program> ::= <directive_groups> <empty>
         
		{
			compilation_unit _compilation_unit=new compilation_unit();
			 
				_compilation_unit.Language=LanguageId.PascalABCNET;
                                if(LRParser.GetReductionSyntaxNode(0)!=null){
                                	parsertools.create_source_context(_compilation_unit,LRParser.GetReductionSyntaxNode(0),LRParser.GetReductionSyntaxNode(0));
					CompilerDirectives.AddRange(((compiler_directive_list)LRParser.GetReductionSyntaxNode(0)).directives);
				}
				
			return _compilation_unit;
		}


		case RuleConstants.RULE_DIRECTIVE_GROUPS :
		//<directive_groups> ::= <_directive_groups>
return LRParser.GetReductionSyntaxNode(0);

		case RuleConstants.RULE_DIRECTIVE_GROUPS2 :
		//<directive_groups> ::= 
		//NONTERMINAL:<directive_groups> ::= 
		return null;
		//ENDNONTERMINAL

		case RuleConstants.RULE__DIRECTIVE_GROUPS :
		//<_directive_groups> ::= <directive_group> <empty>
         
		{
			compiler_directive_list _compiler_directive_list=new compiler_directive_list();
			
						  if(LRParser.GetReductionSyntaxNode(0) is compiler_directive)
							_compiler_directive_list.directives.Add((compiler_directive)LRParser.GetReductionSyntaxNode(0));
						    parsertools.create_source_context(_compiler_directive_list,LRParser.GetReductionSyntaxNode(0),LRParser.GetReductionSyntaxNode(0));
			return _compiler_directive_list;
		}


		case RuleConstants.RULE__DIRECTIVE_GROUPS2 :
		//<_directive_groups> ::= <directive_groups> <directive_group>
         
		{
			compiler_directive_list _compiler_directive_list=(compiler_directive_list)LRParser.GetReductionSyntaxNode(0); 
						  if(LRParser.GetReductionSyntaxNode(1) is compiler_directive)
							_compiler_directive_list.directives.Add((compiler_directive)LRParser.GetReductionSyntaxNode(1));
						  parsertools.create_source_context(_compiler_directive_list,LRParser.GetReductionSyntaxNode(0),LRParser.GetReductionSyntaxNode(1));
			return _compiler_directive_list;
		}


		case RuleConstants.RULE_DIRECTIVE_GROUP_TKNEWLINE :
		//<directive_group> ::= 'TKNEWLINE'
return LRParser.GetReductionSyntaxNode(0);

		case RuleConstants.RULE_DIRECTIVE_GROUP_TKPROGRAM_LINE_PART :
		//<directive_group> ::= 'TKPROGRAM_LINE_PART'
return LRParser.GetReductionSyntaxNode(0);

		case RuleConstants.RULE_DIRECTIVE_GROUP_TKDIRECTIVE :
		//<directive_group> ::= 'TKDIRECTIVE' <empty>
         
		{
			compiler_directive _compiler_directive=(compiler_directive)pascal_parsertools.MakeDirective((token_info)LRParser.GetReductionSyntaxNode(0));
			return _compiler_directive;
		}


		case RuleConstants.RULE_EMPTY :
		//<empty> ::= 
		//NONTERMINAL:<empty> ::= 
		return null;
		//ENDNONTERMINAL

            }
            throw new RuleException("Unknown rule");
        }