Example #1
0
        public void Parse(string filename)
        {
            StreamReader sr = new StreamReader(filename);

            _prev = "";
            _sb   = new StringBuilder();
            string line = "";

            while (!sr.EndOfStream)
            {
                _prev   = line;
                line    = sr.ReadLine();
                _setter = false;
                _getter = false;
                line    = line.Trim();

                switch (_state)
                {
                case State.START:
                    break;

                case State.ARRAY_INITALIZER:
                    if (line.Contains("];"))
                    {
                        _state = State.START;
                    }
                    line = line.Replace("[", "{");
                    line = line.Replace("]", "}");
                    break;

                case State.FUNCTION_ARGLIST:
                    OnFunction(line);
                    break;

                case State.COMMENT:
                    _meta.Source = line;
                    if (line.StartsWith("*/"))
                    {
                        _state     = State.START;
                        _inComment = false;
                    }
                    continue;

                default:
                    break;
                }

                if (line.Contains(" function "))
                {
                    _inFunction  = true;
                    line         = OnFunction(line);
                    _meta.Source = line;
                }
                else if (line.StartsWith("}"))
                {
                    line = OnBrace(line);

                    if (line.Contains(" is "))
                    {
                        // typeid(x) == typeid(y)
                        string keyword = KeywordMapping.Convert("is");
                        line = line.Replace("is", keyword);
                    }

                    _meta.Source = line;
                    if (_addDTOR)
                    {
                        _meta.Source = "\n~" + _className + "::" + _fname + "\n{\n}\n";
                        _addDTOR     = false;
                    }
                }
                else if (line.Contains("var "))
                {
                    switch (_state)
                    {
                    case State.COMMENT:
                        continue;
                    }
                    line         = OnVarKeyword(line);
                    _meta.Source = line;
                }
                else if (line.Contains(" new "))
                {
                    OnNew(line);
                }
                else if (!_inComment && (_inFunction || _inClass))
                {
                    if (line.Contains("}"))
                    {
                        _brace -= 1;
                    }
                    if (line.Contains("{"))
                    {
                        _brace += 1;
                    }
                    if (line.StartsWith("/*"))
                    {
                        _inComment = true;
                        _state     = State.COMMENT;
                    }
                    if (line.StartsWith("*/"))
                    {
                        _inComment = false;
                        _state     = State.START;
                    }

                    foreach (Symbol s in _symtab)
                    {
                        if (s.Allocator == Symbol.ALLOCATED)
                        {
                            string key = s.Name + ".";
                            if (line.Contains(key))
                            {
                                line = line.Replace(key, s.Name + "->");
                                break;
                            }
                        }
                    }

                    // need a better way to convert keywords
                    if (line.Contains(" is "))
                    {
                        line = line.Replace("is", "instanceof");
                    }

                    _meta.Source = line;
                }
                else if (line.StartsWith("import"))
                {
                    line = OnImport(line);
                }
                else if (line.StartsWith("[Event"))
                {
                    _meta.Source = "// (Not supported) " + line;
                }
                else if (line.StartsWith("package"))
                {
                    line = OnPackage(line);
                }
                else if (line.Contains("class "))
                {
                    line = OnClass(line);
                }
                else if (line.StartsWith("/*"))
                {
                    _inComment   = true;
                    _state       = State.COMMENT;
                    _meta.Source = line;
                }
                else if (line.StartsWith("*/"))
                {
                    _inComment   = false;
                    _state       = State.START;
                    _meta.Source = line;
                }
                else if (line.Contains(" static "))
                {
                    line = OnStatic(line);
                }
                else
                {
                    if (line.StartsWith("/*"))
                    {
                        _inComment = true;
                        _state     = State.COMMENT;
                    }
                    if (line.StartsWith("*/"))
                    {
                        _inComment = false;
                        _state     = State.START;
                    }

                    foreach (Symbol s in _symtab)
                    {
                        if (s.Allocator == Symbol.ALLOCATED)
                        {
                            string key = s.Name + ".";
                            if (line.Contains(key))
                            {
                                if (s.EnclosingType == _fname)
                                {
                                    line = line.Replace(key, s.Name + "->");
                                    break;
                                }
                            }
                        }
                    }

                    _meta.Source = line;
                }
            }

            sr.Close();

            GenerateCode();
        }
Example #2
0
        public void Parse(string filename)
        {
            StreamReader sr = new StreamReader(filename);

            _prev = "";
            _sb   = new StringBuilder();
            string line = "";
            string name = "";

            while (!sr.EndOfStream)
            {
                _prev   = line;
                line    = sr.ReadLine();
                _setter = false;
                _getter = false;
                line    = line.Trim();

                _sb.Clear();

                // start exp
                string[] tokens = line.Split(new char[] { ' ', '\t', }, StringSplitOptions.RemoveEmptyEntries);
                foreach (string token in tokens)
                {
                    switch (_state)
                    {
                    case State.IGNORE:
                        _sb.Append(token);
                        continue;

                    case State.ASSIGNMENT:
                        break;

                    case State.NEWDEF:
                        line = OnNew(line);
                        _sb.Append(line);
                        _state = State.CONSUME;
                        continue;

                    case State.PACKAGEDEF:
                        name = token.Replace(".", "::");
                        name = name.Trim();
                        _sb.AppendFormat("namespace {0}", name);
                        _state = State.LBRACE;
                        continue;

                    case State.STATICDEF:
                        line = OnStatic(line);
                        _sb.Append(line);
                        _state = State.CONSUME;
                        continue;

                    case State.CLASSDEF:
                        line = OnClass(line);
                        _sb.Append(line);
                        _state = State.CONSUME;
                        continue;

                    case State.STMTDEF:
                        line = OnStatement(line);
                        _sb.Append(line);
                        _state = State.CONSUME;
                        continue;

                    case State.CONSUME:
                        continue;

                    case State.VARDEF:
                        line = OnVarKeyword(line);
                        _sb.Append(line);
                        _state = State.CONSUME;
                        continue;

                    case State.LBRACE:
                        _sb.Append(" {");
                        _state = State.START;
                        continue;

                    case State.RBRACE:
                        line = OnBrace(line);
                        _sb.Append(line);
                        _state = State.CONSUME;
                        continue;

                    case State.FUNCDEF:
                        line = OnFunction(line);
                        _sb.Append(line);
                        _state = State.CONSUME;
                        continue;

                    case State.IMPORTDEF:
                        name = token.Replace(".", "\\");
                        name = name.Replace(";", ".h\"");
                        _sb.AppendFormat("#include \"{0}\"", name);
                        _state = State.START;
                        continue;

                    case State.IFDEF:
                        line = OnIf(line);
                        _sb.Append(line);
                        _state = State.CONSUME;
                        continue;

                    case State.ELSEDEF:
                        line = OnElse(line);
                        _sb.Append(line);
                        _state = State.CONSUME;
                        continue;

                    case State.RETURNDEF:
                        line = OnReturn(line);
                        _sb.Append(line);
                        _state = State.CONSUME;
                        continue;

                    case State.BEGINCOMMENT:
                        if (token == "*/")
                        {
                            _state = State.ENDCOMMENT;
                        }
                        _sb.Append(token);
                        continue;

                    default:
                        break;
                    }

                    if (token == "function")
                    {
                        _state = State.FUNCDEF;
                    }
                    else if (token == "}")
                    {
                        _state = State.RBRACE;
                    }
                    else if (token == "const")
                    {
                        _state = State.START;
                    }
                    else if (token == "{")
                    {
                        _state = State.LBRACE;
                    }
                    else if (token == "is")
                    {
                        _state = State.START;
                    }
                    else if (token == "var")
                    {
                        _state = State.VARDEF;
                    }
                    else if (token == "new")
                    {
                        _state = State.NEWDEF;
                    }
                    else if (token == "import")
                    {
                        _state = State.IMPORTDEF;
                        //line = OnImport(line);
                    }
                    else if (token.StartsWith("[Event"))
                    {
                        _sb.AppendFormat("// (Not supported) {0}", token);
                        _state = State.IGNORE;
                    }
                    else if (token == "package")
                    {
                        _state = State.PACKAGEDEF;
                    }
                    else if (token == "class")
                    {
                        _state = State.CLASSDEF;
                    }
                    else if (token == "public")
                    {
                        _state = State.START;
                    }
                    else if (token == "protected")
                    {
                        _state = State.START;
                    }
                    else if (token == "private")
                    {
                        _state = State.START;
                    }
                    else if (token.StartsWith("if"))
                    {
                        _state = State.IFDEF;
                    }
                    else if (token == "return")
                    {
                        _state = State.RETURNDEF;
                    }
                    else if (token.StartsWith("else"))
                    {
                        _state = State.ELSEDEF;
                    }
                    else if (token == "/*" || token == "/**")
                    {
                        _inComment = true;
                        _sb.Append(token);
                        _state = State.BEGINCOMMENT;
                    }
                    else if (token == "*/")
                    {
                        _inComment = false;
                        _sb.Append(token);
                        _state = State.ENDCOMMENT;
                    }
                    else if (token == "static")
                    {
                        _state = State.STATICDEF;
                    }
                    else if (token == "=")
                    {
                        _state = State.ASSIGNMENT;
                    }
                    else
                    {
                        _state = State.STMTDEF;

                        // lookup in Symbol table
                        Symbol sym = _symtab.Lookup(token);
                        if (null != sym)
                        {
                            //continue;
                        }
                        //string[] stmttokens = line.Split(new Char[] { ' ', '\t', '.' }, StringSplitOptions.RemoveEmptyEntries);

                        if (line.Contains("}"))
                        {
                            _brace -= 1;
                        }
                        if (line.Contains("{"))
                        {
                            _brace += 1;
                        }

                        continue;
                    }
                }

                switch (_state)
                {
                case State.ENDCOMMENT:
                    _state = State.START;
                    break;

                case State.IGNORE:
                case State.CONSUME:
                    _state = State.START;
                    break;

                case State.RBRACE:
                    _sb.Append(line);
                    _state = State.START;
                    break;

                case State.STMTDEF:
                    _sb.Append(line);
                    _state = State.START;
                    break;
                }

                _meta.Source = _sb.ToString();
                // end exp

#if REV3
                switch (_state)
                {
                case State.START:
                    break;

                case State.ARRAY_INITALIZER:
                    if (line.Contains("];"))
                    {
                        _state = State.START;
                    }
                    line = line.Replace("[", "{");
                    line = line.Replace("]", "}");
                    break;

                case State.FUNCTION_ARGLIST:
                    OnFunction(line);
                    break;

                case State.COMMENT:
                    _meta.Source = line;
                    if (line.StartsWith("*/"))
                    {
                        _state     = State.START;
                        _inComment = false;
                    }
                    continue;

                default:
                    break;
                }

                if (line.Contains(" function "))
                {
                    _inFunction  = true;
                    line         = OnFunction(line);
                    _meta.Source = line;
                }
                else if (line.StartsWith("}"))
                {
                    line = OnBrace(line);

                    if (line.Contains(" is "))
                    {
                        // typeid(x) == typeid(y)
                        string keyword = KeywordMapping.Convert("is");
                        line = line.Replace("is", keyword);
                    }

                    _meta.Source = line;
                    if (_addDTOR)
                    {
                        _meta.Source = "\n~" + _className + "::" + _fname + "\n{\n}\n";
                        _addDTOR     = false;
                    }
                }
                else if (line.Contains("var "))
                {
                    switch (_state)
                    {
                    case State.COMMENT:
                        continue;
                    }
                    line         = OnVarKeyword(line);
                    _meta.Source = line;
                }
                else if (line.Contains(" new "))
                {
                    OnNew(line);
                }
                else if (!_inComment && (_inFunction || _inClass))
                {
                    string[] tokens2 = line.Split(new Char[] { ' ', '\t', '.' }, StringSplitOptions.RemoveEmptyEntries);

                    foreach (string tok in tokens2)
                    {
                        // lookup in Symbol table
                        Symbol sym = _symtab.Lookup(tok);
                        if (sym.Allocator == 1)
                        {
                        }
                    }

                    if (line.Contains("}"))
                    {
                        _brace -= 1;
                    }
                    if (line.Contains("{"))
                    {
                        _brace += 1;
                    }
                    if (line.StartsWith("/*"))
                    {
                        _inComment = true;
                        _state     = State.COMMENT;
                    }
                    if (line.StartsWith("*/"))
                    {
                        _inComment = false;
                        _state     = State.START;
                    }

                    foreach (Symbol s in _symtab)
                    {
                        if (s.Allocator == Symbol.ALLOCATED)
                        {
                            string key = s.Name + ".";
                            if (line.Contains(key))
                            {
                                line = line.Replace(key, s.Name + "->");
                                break;
                            }
                        }
                    }

                    // need a better way to convert keywords
                    if (line.Contains(" is "))
                    {
                        line = line.Replace("is", "instanceof");
                    }

                    _meta.Source = line;
                }
                else if (line.StartsWith("import"))
                {
                    line = OnImport(line);
                }
                else if (line.StartsWith("[Event"))
                {
                    _meta.Source = "// (Not supported) " + line;
                }
                else if (line.StartsWith("package"))
                {
                    line = OnPackage(line);
                }
                else if (line.Contains("class "))
                {
                    line = OnClass(line);
                }
                else if (line.StartsWith("/*"))
                {
                    _inComment   = true;
                    _state       = State.COMMENT;
                    _meta.Source = line;
                }
                else if (line.StartsWith("*/"))
                {
                    _inComment   = false;
                    _state       = State.START;
                    _meta.Source = line;
                }
                else if (line.Contains(" static "))
                {
                    line = OnStatic(line);
                }
                else
                {
                    string[] tokens2 = line.Split(new Char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);

                    foreach (string s in tokens2)
                    {
                    }
                    if (line.StartsWith("/*"))
                    {
                        _inComment = true;
                        _state     = State.COMMENT;
                    }
                    if (line.StartsWith("*/"))
                    {
                        _inComment = false;
                        _state     = State.START;
                    }

                    foreach (Symbol s in _symtab)
                    {
                        if (s.Allocator == Symbol.ALLOCATED)
                        {
                            string key = s.Name + ".";
                            if (line.Contains(key))
                            {
                                if (s.EnclosingType == _fname)
                                {
                                    line = line.Replace(key, s.Name + "->");
                                    break;
                                }
                            }
                        }
                    }

                    _meta.Source = line;
                }
#endif
            }

            sr.Close();

            GenerateCode();
        }