ПК>name1 = value1
ПК>name2 = value2
ПК>

{str_data_class    "smsg_2::smpp::a_smpp_transmitter_t::connection_state_monitor"
    {priority 5}
    {font_size 10}
    {if    {== "st_not_connected"}
        {pixmap    "etc/gemont_1/img/xpm/red_cross_24x16.xpm" }
        {bkcolor    "magenta"}
    }
    {if {== "st_connected"}
        {bkcolor    "blue"}
    }
    {if {== "st_bind"}
        {pixmap "etc/gemont_1/img/xpm/conn_exists_24x16.xpm" }
        {bkcolor    "green"}
    }
    {if {== "st_shutdown"}
        {bkcolor    "yellow"}
    }
}

{str_data_class    "smsg_2::smpp_smsc::a_smsc_t::m_connection_monitor_data"
    {priority 9}
    {font_size 11}
    {if    {== "st_not_bind"}
        {pixmap    "etc/gemont_1/img/xpm/red_cross_24x16.xpm" }
        {bkcolor    "magenta"}
        {sound    "etc/gemont_1/snd/wav/siren.wav"}
        {log_event {level "error"}
            {message "Нет соединения с SMSC"}}
    }
    {if {== "st_bind"}
        {pixmap "etc/gemont_1/img/xpm/conn_exists_24x16.xpm" }
        {bkcolor    "green"}
        {sound    "etc/gemont_1/snd/wav/online.wav"}
        {log_event {level "info"}
            {message "Есть соединение с SMSC"}}
    }
    {if {== "st_shutdown"}
        {bkcolor    "yellow"}
        {sound    "etc/gemont_1/snd/wav/tada.wav"}
    }
}

class Editor : public DocWatcher {
    // Private so Editor objects can not be copied
    Editor(const Editor &) : DocWatcher() {}
    Editor &operator=(const Editor &) { return *this; }

protected:    // ScintillaBase subclass needs access to much of Editor

    /** On GTK+, Scintilla is a container widget holding two scroll bars
     * whereas on Windows there is just one window with both scroll bars turned on. */
    Window wMain;    ///< The Scintilla parent window

    /** Style resources may be expensive to allocate so are cached between uses.
     * When a style attribute is changed, this cache is flushed. */
    bool stylesValid;
    ViewStyle vs;
    Palette palette;

    int printMagnification;
    int printColourMode;
    int printWrapState;
    int cursorMode;
    int controlCharSymbol;

    bool hasFocus;
    bool hideSelection;
    bool inOverstrike;
    int errorStatus;
    bool mouseDownCaptures;

    /** In bufferedDraw mode, graphics operations are drawn to a pixmap and then copied to
     * the screen. This avoids flashing but is about 30% slower. */
    bool bufferedDraw;
    /** In twoPhaseDraw mode, drawing is performed in two phases, first the background
    * and then the foreground. This avoids chopping off characters that overlap the next run. */
    bool twoPhaseDraw;

    int xOffset;        ///< Horizontal scrolled amount in pixels
    int xCaretMargin;    ///< Ensure this many pixels visible on both sides of caret
    bool horizontalScrollBarVisible;
    int scrollWidth;
    bool verticalScrollBarVisible;
    bool endAtLastLine;

    Surface *pixmapLine;
    Surface *pixmapSelMargin;
    Surface *pixmapSelPattern;
    Surface *pixmapIndentGuide;
    Surface *pixmapIndentGuideHighlight;

    LineLayoutCache llc;

    KeyMap kmap;

    Caret caret;
    Timer timer;
    Timer autoScrollTimer;
    enum { autoScrollDelay = 200 };

    Point lastClick;
    unsigned int lastClickTime;
    int dwellDelay;
    int ticksToDwell;
    bool dwelling;
    enum { selChar, selWord, selLine } selectionType;
    Point ptMouseLast;
    bool inDragDrop;
    bool dropWentOutside;
    int posDrag;
    int posDrop;
    int lastXChosen;
    int lineAnchor;
    int originalAnchorPos;
    int currentPos;
    int anchor;
    int targetStart;
    int targetEnd;
    int searchFlags;
    int topLine;
    int posTopLine;

    bool needUpdateUI;
    Position braces[2];
    int bracesMatchStyle;
    int highlightGuideColumn;

    int theEdge;

    enum { notPainting, painting, paintAbandoned } paintState;
    PRectangle rcPaint;
    bool paintingAllText;

    int modEventMask;

    SelectionText drag;
    enum { selStream, selRectangle, selRectangleFixed } selType;
    int xStartSelect;
    int xEndSelect;
    bool primarySelection;

    int caretXPolicy;
    int caretXSlop;    ///< Ensure this many pixels visible on both sides of caret

    int caretYPolicy;
    int caretYSlop;    ///< Ensure this many lines visible on both sides of caret

    int visiblePolicy;
    int visibleSlop;

    int searchAnchor;

    bool recordingMacro;

    int foldFlags;
    ContractionState cs;

    // Wrapping support
    enum { eWrapNone, eWrapWord } wrapState;
    int wrapWidth;
    int docLineLastWrapped;

    Document *pdoc;

    Editor();
    virtual ~Editor();
    virtual void Initialise() = 0;
    virtual void Finalise();

    void InvalidateStyleData();
    void InvalidateStyleRedraw();
    virtual void RefreshColourPalette(Palette &pal, bool want);
    void RefreshStyleData();
    void DropGraphics();

    virtual PRectangle GetClientRectangle();
    PRectangle GetTextRectangle();

    int LinesOnScreen();
    int LinesToScroll();
    int MaxScrollPos();
    Point LocationFromPosition(int pos);
    int XFromPosition(int pos);
    int PositionFromLocation(Point pt);
    int PositionFromLocationClose(Point pt);
    int PositionFromLineX(int line, int x);
    int LineFromLocation(Point pt);
    void SetTopLine(int topLineNew);

    bool AbandonPaint();
    void RedrawRect(PRectangle rc);
    void Redraw();
    void RedrawSelMargin();
    PRectangle RectangleFromRange(int start, int end);
    void InvalidateRange(int start, int end);

    int CurrentPosition();
    bool SelectionEmpty();
    int SelectionStart(int line=-1);
    int SelectionEnd(int line=-1);
    void SetSelection(int currentPos_, int anchor_);
    void SetSelection(int currentPos_);
    void SetEmptySelection(int currentPos_);
    bool RangeContainsProtected(int start, int end) const;
    bool SelectionContainsProtected() const;
    int MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd=true);
    int MovePositionTo(int newPos, bool extend=false, bool ensureVisible=true);
    int MovePositionSoVisible(int pos, int moveDir);
    void SetLastXChosen();

    void ScrollTo(int line, bool moveThumb=true);
    virtual void ScrollText(int linesToMove);
    void HorizontalScrollTo(int xPos);
    void MoveCaretInsideView(bool ensureVisible=true);
    int DisplayFromPosition(int pos);
    void EnsureCaretVisible(bool useMargin=true, bool vert=true, bool horiz=true);
    void ShowCaretAtCurrentPosition();
    void DropCaret();
    void InvalidateCaret();

    void NeedWrapping(int docLineStartWrapping=0);
    bool WrapLines();
    void LinesJoin();
    void LinesSplit(int pixelWidth);

    int SubstituteMarkerIfEmpty(int markerCheck, int markerDefault);
    void PaintSelMargin(Surface *surface, PRectangle &rc);
    LineLayout *RetrieveLineLayout(int lineNumber);
    void LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayout *ll,
        int width=LineLayout::wrapWidthInfinite);
    ColourAllocated TextBackground(ViewStyle &vsDraw, bool overrideBackground, ColourAllocated background, bool inSelection, int styleMain, int i, LineLayout *ll);
    void DrawIndentGuide(Surface *surface, int lineVisible, int lineHeight, int start, PRectangle rcSegment, bool highlight);
    void DrawEOL(Surface *surface, ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll,
        int line, int lineEnd, int xStart, int subLine, int subLineStart,
        bool overrideBackground, ColourAllocated background);
    void DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVisible, int xStart,
        PRectangle rcLine, LineLayout *ll, int subLine=0);
    void RefreshPixMaps(Surface *surfaceWindow);
    void Paint(Surface *surfaceWindow, PRectangle rcArea);
    long FormatRange(bool draw, RangeToFormat *pfr);
    int TextWidth(int style, const char *text);

    virtual void SetVerticalScrollPos() = 0;
    virtual void SetHorizontalScrollPos() = 0;
    virtual bool ModifyScrollBars(int nMax, int nPage) = 0;
    virtual void ReconfigureScrollBars();
    void SetScrollBars();
    void ChangeSize();

    void AddChar(char ch);
    virtual void AddCharUTF(char *s, unsigned int len, bool treatAsDBCS=false);
    void ClearSelection();
    void ClearAll();
        void ClearDocumentStyle();
    void Cut();
    void PasteRectangular(int pos, const char *ptr, int len);
    virtual void Copy() = 0;
    virtual bool CanPaste();
    virtual void Paste() = 0;
    void Clear();
    void SelectAll();
    void Undo();
    void Redo();
    void DelChar();
    void DelCharBack(bool allowLineStartDeletion);
    virtual void ClaimSelection() = 0;

    virtual void NotifyChange() = 0;
    virtual void NotifyFocus(bool focus);
    virtual int GetCtrlID() { return ctrlID; }
    virtual void NotifyParent(SCNotification scn) = 0;
    virtual void NotifyStyleToNeeded(int endStyleNeeded);
    void NotifyChar(int ch);
    void NotifyMove(int position);
    void NotifySavePoint(bool isSavePoint);
    void NotifyModifyAttempt();
    virtual void NotifyDoubleClick(Point pt, bool shift);
    void NotifyUpdateUI();
    void NotifyPainted();
    bool NotifyMarginClick(Point pt, bool shift, bool ctrl, bool alt);
    void NotifyNeedShown(int pos, int len);
    void NotifyDwelling(Point pt, bool state);
    void NotifyZoom();

    void NotifyModifyAttempt(Document *document, void *userData);
    void NotifySavePoint(Document *document, void *userData, bool atSavePoint);
    void CheckModificationForWrap(DocModification mh);
    void NotifyModified(Document *document, DocModification mh, void *userData);
    void NotifyDeleted(Document *document, void *userData);
    void NotifyStyleNeeded(Document *doc, void *userData, int endPos);
    void NotifyMacroRecord(unsigned int iMessage, uptr_t wParam, sptr_t lParam);

    void PageMove(int direction, bool extend=false);
    void ChangeCaseOfSelection(bool makeUpperCase);
    void LineTranspose();
    void LineDuplicate();
    virtual void CancelModes();
    void NewLine();
    void CursorUpOrDown(int direction, bool extend=false);
    int StartEndDisplayLine(int pos, bool start);
    virtual int KeyCommand(unsigned int iMessage);
    virtual int KeyDefault(int /* key */, int /*modifiers*/);
    int KeyDown(int key, bool shift, bool ctrl, bool alt, bool *consumed=0);

    int GetWhitespaceVisible();
    void SetWhitespaceVisible(int view);

    void Indent(bool forwards);

    long FindText(uptr_t wParam, sptr_t lParam);
    void SearchAnchor();
    long SearchText(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
    long SearchInTarget(const char *text, int length);
    void GoToLine(int lineNo);

    char *CopyRange(int start, int end);
    void CopySelectionRange(SelectionText *ss);
    void SetDragPosition(int newPos);
    void DisplayCursor(Window::Cursor c);
    virtual void StartDrag();
    void DropAt(int position, const char *value, bool moving, bool rectangular);
    /** PositionInSelection returns 0 if position in selection, -1 if position before selection, and 1 if after.
     * Before means either before any line of selection or before selection on its line, with a similar meaning to after. */
    int PositionInSelection(int pos);
    bool PointInSelection(Point pt);
    bool PointInSelMargin(Point pt);
    void LineSelection(int lineCurrent_, int lineAnchor_);
    void DwellEnd(bool mouseMoved);
    virtual void ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt);
    void ButtonMove(Point pt);
    void ButtonUp(Point pt, unsigned int curTime, bool ctrl);

    void Tick();
    virtual void SetTicking(bool on) = 0;
    virtual void SetMouseCapture(bool on) = 0;
    virtual bool HaveMouseCapture() = 0;
    void SetFocusState(bool focusState);

    void CheckForChangeOutsidePaint(Range r);
    int BraceMatch(int position, int maxReStyle);
    void SetBraceHighlight(Position pos0, Position pos1, int matchStyle);

    void SetDocPointer(Document *document);

    void Expand(int &line, bool doExpand);
    void ToggleContraction(int line);
    void EnsureLineVisible(int lineDoc, bool enforcePolicy);
    int ReplaceTarget(bool replacePatterns, const char *text, int length=-1);

    int CodePage() const;

    virtual sptr_t DefWndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) = 0;

public:
    // Public so the COM thunks can access it.
    bool IsUnicodeMode() const;
    // Public so scintilla_send_message can use it.
    virtual sptr_t WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
    // Public so scintilla_set_id can use it.
    int ctrlID;
};

#endif

Ш><...>
Ш>

namespace RSharp.Compiler
{
    /// <summary>
    /// Компилятор/кодогенератор R#. Позволяет открыть проект VS или 
    /// набор фйлов R#/C#, осущесвить трансформацию и сгенерировать
    /// C#-файлы которые в последствии можно откомпилировать стандартным
    /// C#-компилятором.
    /// </summary>
    public class Compiler
    {
        #region Properties & variables.

        /// <summary>
        /// Подкаталог в каталоге определяемом свойством
        /// <see cref="RSharpSubfolder"/> в котором размещаются файлы
        /// содержащие метакод (код именяющий код).
        /// </summary>
        public const string MetaProjectSubfolder = "MetaCode";

        /// <summary>
        /// Подкаталог в каталоге определяемом свойством
        /// <see cref="RSharpSubfolder"/> в котором размещаются файлы
        /// генерируемые R#-ом конечный C#-файлы.
        /// </summary>
        public const string ProjectSubfolder = "Generated";

        private string _rSharpSubfolder = ".RSharp";

        /// <summary>
        /// Подкатало основного каталога проекта в котром размещаются
        /// служебные файлы R#-а.
        /// </summary>
        public string RSharpSubfolder
        {
            get { return _rSharpSubfolder; }
            set { _rSharpSubfolder = value; }
        }

        string _projectRoot;

        /// <summary>
        /// Директория проекта.
        /// </summary>
        public string ProjectRoot
        {
            get { return _projectRoot; }
            set { _projectRoot = value.ToLower(); }
        }


        private RProject _project;

        /// <summary>
        /// Позволяет получить AST проекта.
        /// </summary>
        protected RProject Project
        {
            get { return _project; }
        }

        private RProject _metaProject;

        /// <summary>
        /// Позволяет получить AST мета-проекта.
        /// </summary>
        protected RProject MetaProject
        {
            get { return _metaProject; }
        }

        protected Result _result;
        protected Parser _parser;
        protected MetaCodeBuilder _builder;

        #endregion Properties & variables.

        #region Загрузка AST

        /// <summary>
        /// Считывает файл проекта VS 2003 или 2005, парся 
        /// файлы входящие в прокт.
        /// </summary>
        /// <param name="projectPath">Путь к проекту VS.</param>
        /// <param name="parametrs">Дополнительные параметры.</param>
        public void LoadProjectFile(string projectPath, Parametrs parametrs)
        {
            projectPath = Path.GetFullPath(projectPath);
            string[] fileNames = GetProjectFiles(projectPath);
            this.ProjectRoot = Path.GetDirectoryName(projectPath);
            LoadFiles(fileNames, parametrs);
        }

        /// <summary>
        /// Позволяет загрузить список файлов как единый проект.
        /// </summary>
        /// <param name="fileNames">Список файлов проекта</param>
        /// <param name="parametrs">Параметры комиляции/кодогенерации</param>
        /// <returns></returns>
        public Result LoadFiles(string[] fileNames, Parametrs parametrs)
        {
            _result = new Result();

            // Изменям пути к файлам чтобы в дальнейшем небыло проблем 
            // при контекстной замене.
            MakePathLoverCase(ref fileNames);

            _project = null;
            PerfCounter timer = new PerfCounter(); // Изсеняем время загрузки.
            timer.Start();

            // Создаем прокт в который будут подключаться отпарсенные файлы.
            RProject project = new RProject();
            RProject metaProject = new RProject();
            string rsharpRoot = Path.Combine(this.ProjectRoot, "rsharp");
            project.ProjectRootPath = this.ProjectRoot;
            metaProject.ProjectRootPath = rsharpRoot;

            // Создаем и инициализируем парсер, сканер и объект-обработчик ошибок.

            if (_parser == null)
            {
                _parser = new Parser(new Scanner());

                // Подключаем обработку событий к парсеру.
                _parser.SemanticError += UserDefinedError;
                _parser.UserDefinedError += UserDefinedError;
            }

            _parser.DefineConstants.Clear();

            if (DefineConstants != null)
                _parser.DefineConstants.AddRange(DefineConstants);


            // Бежим по фйлам и прасим их...
            foreach (string fileName in fileNames)
            {
                try
                {
                    _parser.Scanner.InitFromFile(fileName);
                    _parser.Parse();

                    // Добавляем результат парсинга файла в кроект.
                    if (fileName.StartsWith(rsharpRoot))
                        metaProject.Add(_parser.CompileUnit);
                    else
                        project.Add(_parser.CompileUnit);
                }
                catch (Exception ex)
                {
                    _result.Errors.Add(new CompilerError(
                        fileName,
                        _parser.CurrentToken == null ? 0 : _parser.CurrentToken.Location.Line,
                        _parser.CurrentToken == null ? 0 : _parser.CurrentToken.Location.Col,
                        "Exception",
                        "Error during process loading project file: " + ex.Message));
                }
            }

            if (_result.Errors.Count > 0)
                _result.Output.Add("R#: Parsing filed with "
                    + _result.Errors.Count + " errors.");
            else
                _result.Output.Add("R#: Parse successfully by "
                    + timer.Finish() + " sec.");

            _project = project; // Запоминаем прокт для будущего использования.
            _metaProject = metaProject;

            return _result;
        }

        /// <summary>
        /// Позволяет подключить готовое AST.
        /// </summary>
        /// <param name="project">AST проекта.</param>
        /// <param name="metaProject">AST мета-проекта.</param>
        /// <param name="parametrs">
        /// Параметры компиляции/кодогенерации.
        /// </param>
        /// <returns></returns>
        public Result AttachAst(
            RProject project,
            RProject metaProject,
            Parametrs parametrs)
        {
            _project = project;
            _metaProject = metaProject;
            return new Result();
        }

        #endregion

        #region Формирование мета-кода (мета-правил).

        // Позволяет выделить мета-код, поместить его в отдельные файлы,
        // скомпилировать, и получить сборку содержащую мета-правила.
        public Result MakeMetaCode()
        {
            PerfCounter timer = new PerfCounter();
            timer.Start();

            string metaCodePath = Path.Combine(
                Path.Combine(this.ProjectRoot, this.RSharpSubfolder),
                MetaProjectSubfolder);

            if (!Directory.Exists(metaCodePath))
                Directory.CreateDirectory(metaCodePath);

            if (_builder == null)
                _builder = new MetaCodeBuilder();

            _builder.Parser = _parser;

            Result result = _builder.Init(_metaProject, metaCodePath, 
                this.ProjectRoot);

            result.Output.Add("R#: Metacode generetion & metaassembly builded successfully by "
                + timer.Finish() + " sec.");

            return result;
        }

        #endregion

        #region Трансформация кода проекта мета-правилами.

        // Позволяет произвести процесс преобразования.
        public Result Transform()
        {
            PerfCounter timer = new PerfCounter();
            timer.Start();

            string query = "/project/CompileUnits/compile-unit/AssemblyCustomAttributeSections/attribute-section/AttributeDeclarations";
            AstNodeCollection globalAttrs =
                XPathProvider.QueryNodes(_project, query);

            // Вызвать для каждого мета-правила соотвествующий IMetaRule
            IMetaRulesCaller metaRulesCaller = _builder.MetaRulesCaller;
            metaRulesCaller.Parser = _parser;
            metaRulesCaller.Project = _project;
            metaRulesCaller.MetaProject = _metaProject;
            metaRulesCaller.CallMetaRules(
                globalAttrs.ToArray<RAttributeDeclaration>());

            Result result = new Result();

            if (metaRulesCaller.Errors.Count > 0)
            {
                result.Errors.AddRange(metaRulesCaller.Errors);
                result.Output.Add("R#: Transformation execute failed with "
                    + metaRulesCaller.Errors.Count
                    + " errors.");
            }
            else
                result.Output.Add("R#: Transformation execute successfully by "
                    + timer.Finish() + " sec.");

            //TODO: Разобраться с new Result();
            return result;
        }

        #endregion

        #region Генерация C#-кода (по AST).

        // Позволяет сгенерировать C#-код из АСТ.
        public Result MakeCsCode()
        {
            PerfCounter timer = new PerfCounter();
            timer.Start();

            string genPath = Path.Combine(
                Path.Combine(this.ProjectRoot, this.RSharpSubfolder),
                ProjectSubfolder);

            if (!Directory.Exists(genPath))
                Directory.CreateDirectory(genPath);

            foreach (RCompileUnit unit in _project.CompileUnits)
            {
                string fileName = this.ProjectRoot.Length == 0
                    ? Path.Combine(genPath, unit.FileName)
                    : unit.FileName.Replace(this.ProjectRoot,
                    Path.GetFullPath(genPath));

                fileName = fileName.Replace(@"..\", "");

                Utilits.SaveToFile(unit, fileName);
            }

            RSharp.Utils.WriteFile(Path.Combine(genPath, "Info.txt"),
                string.Format(
                "Code generetion successfully at {0}." + Environment.NewLine
                + "{1} files generated." + Environment.NewLine
                + "{2} AST nones processed.",
                DateTime.Now.ToString(),
                _project.CompileUnits.Count,
                IdGenerator.Next() - 1));

            Result result = new Result();
            result.Output.Add("R#: C# code generetion successfully by "
                + timer.Finish() + " sec.");
            return result;
        }

        #endregion

        #region Work function

        public string[] GetProjectFiles(string projectPath)
        {
            // Открываем диалог выбора фйла проекта.

            string dir = Path.GetDirectoryName(projectPath);

            //if (dir.Length == 0)
            //    dir = Directory.GetCurrentDirectory();

            // Файл проекта - это XML-файл содержащий ряд списков. Их проще 
            // всего читать датасетом. По этому читаем файл в датасет и 
            // выскребаем нужную нам информацию.
                    
            DataSet ds = new DataSet();
            try
            {
                ds.ReadXml(projectPath);
            }
            catch (XmlException ex)
            {
                throw new ApplicationException(
                    string.Format("The file '{0}' not conform MS Visual Studio 2003/2005 "
                    + "or MSBuild project format.", projectPath), ex);
            }

            // Список файлов хранится в таблице "File".
            DataTable dt = ds.Tables["File"];

            if (dt == null)
                return ReadVs80Format(projectPath);
            else
                return ReadVs71Format(dt, dir);
        }

        private string _currentConfiguration;
        public const string Configuration = "Configuration";

        /// <summary>
        /// Текущая конфигурация.
        /// Если установить свойство в null, то при считывании
        /// проекта в него бедт считано текущее значение.
        /// </summary>
        /// <value></value>
        public string CurrentConfiguration
        {
            get { return _currentConfiguration; }
            set { _currentConfiguration = value; }
        }

        private string[] _loadItemTypes = { "Compile" };

        /// <summary>
        /// Список типов "Item-ов" которые нужно загружать из проектов
        /// MSBuild (VS 2005).
        /// По умолчанию он состоит только из "Compile".
        /// Более подробно о Item-ах см. документацию на MSBuild MSDN.
        /// </summary>
        public string[] LoadItemTypes
        {
            get { return _loadItemTypes; }
            set { _loadItemTypes = value; }
        }

        private string[] _defineConstants;

        /// <summary>
        /// Список предопределенных define-ов. Напрмер, "DEBUG" и "TRACE".
        /// </summary>
        public string[] DefineConstants
        {
            get { return _defineConstants; }
            set { _defineConstants = value; }
        }

        private static string GetMSBuildPropertyValue(
            MsBuildProjectHelper msbuild,
            string propertyName)
        {
            BuildProperty prop = msbuild.Project.EvaluatedProperties[propertyName];
            if (prop == null)
                return "";

            return prop.Value;
        }

        protected string[] ReadVs80Format(string projectPath)
        {
            string dir = Path.GetDirectoryName(projectPath);
            MsBuildProjectHelper msbuild = new MsBuildProjectHelper(projectPath);
            
            // Если конфигурация принятая по умолчанию не совпадает с 
            // CurrentConfiguration, то устанавливаем конфигурацию.
            // Это приведет к тому, что будет считаны файлы и настройки именно этой
            // конфигурации.
            if (CurrentConfiguration == null)
                CurrentConfiguration =
                    GetMSBuildPropertyValue(msbuild, Configuration);
            else
            {
                // Получаем значение конфигурации принятой по умолчанию.
                string configuration = GetMSBuildPropertyValue(msbuild, Configuration);

                if (configuration != CurrentConfiguration)
                    msbuild.Project.SetProperty(Configuration, "CurrentConfiguration", "");
            }

            if (DefineConstants == null)
            {
                // Считываем предопределенные define-ы.
                string dc = GetMSBuildPropertyValue(msbuild, "DefineConstants");
                DefineConstants = dc.Split(';');
            }

            // Считываем и филтруем список файлов проекта.

            List<string> files = new List<string>(300); // все равно ему помирать :)

            foreach (string filePath in msbuild.GetProjectFiles(LoadItemTypes))
            {
                if (CheckCsFile(filePath))
                    files.Add(Path.Combine(dir, filePath));
            }

            return files.ToArray();
        }

        protected static string[] ReadVs71Format(DataTable dt, string dir)
        {
            // В этот массив будут добавлены файлв входящие в проект.
            List<string> files = new List<string>(dt.Rows.Count);

            // Получаем идентификаторы колонок содержащие нужную нам информацию.
            int relPathIndex = dt.Columns["RelPath"].Ordinal;
            int subTypeIndex = dt.Columns["SubType"].Ordinal;
            int linkIndex = dt.Columns["Link"] == null
                    ? -1 : dt.Columns["Link"].Ordinal;

            // Пробегаемся по таблие и читаем информацию о файлах входящих 
            // в прокт.
            foreach (DataRow row in dt.Rows)
            {
                // Относительный путь.
                string relPath = (string)row[relPathIndex];
                // Подтип файла
                string subType = row[subTypeIndex] == DBNull.Value
                        ? null : (string)row[subTypeIndex];

                // Если это C#-ный файл и это не автогенеренный файл...
                if (subType == "Code" && CheckCsFile(relPath))
                {
                    // ... выясняем является ли файл ссылкой на файл из дугого 
                    // проекта или файлом входящим в прокт.

                    string link = linkIndex < 0 || row[linkIndex] == DBNull.Value
                            ? null : (string)row[linkIndex];

                    // Формируем полный путь к файлу.
                    if (link != null)
                        files.Add(Path.Combine(dir, link));
                    else
                        files.Add(Path.Combine(dir, relPath));
                }
            }

            return files.ToArray();
        }

        protected static bool CheckCsFile(string filePath)
        {
            return string.Compare(Path.GetExtension(filePath), ".cs", true) == 0
                            && !filePath.EndsWith(".gen.cs");
        }
        void MakePathLoverCase(ref string[] paths)
        {
            int len = paths.Length;
            string[] newPaths = new string[len];
            for (int i = 0; i < len; i++)
            {
                string path = paths[i];
                newPaths[i] = Path.Combine(
                        Path.GetDirectoryName(path).ToLower(),
                        Path.GetFileName(path));
            }

            paths = newPaths;
        }

        /// <summary>
        /// Обработчик ошибок. Помещает ошибку компиляции в список ошибок.
        /// </summary>
        protected void UserDefinedError(int line, int col, string error)
        {
            _result.Errors.Add(new CompilerError(
                    _parser.Scanner.FileName,
                    line,
                    col,
                    "err",
                    error));
        }

        #endregion
    }
}