Exemplo n.º 1
0
        void device(string dev_type)
        {
            std.vector <string> params_ = new std.vector <string>();

            require_token(m_tok_paren_left);
            string devname = get_identifier();

            m_setup.log().debug.op("Parser: IC: {0}\n", devname);

            var tok = get_token();

            while (tok.is_(m_tok_comma))
            {
                tok = get_token();
                if (/*tok.is_type(token_type::IDENTIFIER) ||*/ tok.is_type(parser_t_token_type.STRING))
                {
                    params_.push_back(tok.str());
                    tok = get_token();
                }
                else
                {
                    var value = stringify_expression(ref tok);
                    params_.push_back(value);
                }
            }

            require_token(tok, m_tok_paren_right);

            std.vector <string> params_temp = new std.vector <string>();
            params_temp.Add(devname);
            params_temp.AddRange(params_);
            m_setup.register_dev(dev_type, params_temp.ToArray());  //m_setup.register_dev(dev_type, devname, params);
        }
Exemplo n.º 2
0
        public static string convert_command_glyph(ref string str)
        {
            // TODO check accuracy
            //throw new emu_unimplemented();

            std.vector <char> buf = new std.vector <char>(2 * (str.length() + 1));
            size_t            j   = 0;

            while (!str.empty())
            {
                // decode UTF-8
                char uchar;                                     //char32_t uchar;
                int  codelen = uchar_from_utf8(out uchar, str); //int const codelen(uchar_from_utf8(&uchar, str));
                if (0 >= codelen)
                {
                    break;
                }
                str = str.Substring(codelen);  //str.remove_prefix(codelen);

                // check for three metacharacters
                fix_command_t [] fixcmd = null;  //fix_command_t const *fixcmd(nullptr);
                int fixcmdOffset        = 0;
                switch (uchar)
                {
                case COMMAND_CONVERT_TEXT:
                    for (int fixtextOffset = 0; convert_text[fixtextOffset].glyph_code != 0; ++fixtextOffset)  //for (fix_strings_t const *fixtext = convert_text; fixtext->glyph_code; ++fixtext)
                    {
                        var fixtext = convert_text[fixtextOffset];
                        if (str.substr(0, fixtext.glyph_str.length()) == fixtext.glyph_str)
                        {
                            uchar = (char)(fixtext.glyph_code + COMMAND_UNICODE);
                            str   = str.Substring((int)fixtext.glyph_str.length()); //str.remove_prefix(fixtext->glyph_str.length());
                            break;
                        }
                    }
                    break;

                case COMMAND_DEFAULT_TEXT:
                    fixcmd = default_text;
                    break;

                case COMMAND_EXPAND_TEXT:
                    fixcmd = expand_text;
                    break;
                }

                // this substitutes a single character
                if (fixcmd != null && !str.empty())
                {
                    if (str[0] == uchar)
                    {
                        str = str.Substring(1);  //str.remove_prefix(1);
                    }
                    else
                    {
                        while (fixcmd[fixcmdOffset].glyph_code != 0 && !str.empty() && fixcmd[fixcmdOffset].glyph_char != str[0])
                        {
                            ++fixcmdOffset;
                        }

                        if (fixcmd[fixcmdOffset].glyph_code != 0 && !str.empty())
                        {
                            uchar = (char)(COMMAND_UNICODE + fixcmd[fixcmdOffset].glyph_code);
                            str   = str.Substring(1); //str.remove_prefix(1);
                        }
                    }
                }

                // copy character to output
                string temp;
                int    outlen = utf8_from_uchar(out temp, /*buf.Length - j,*/ uchar); //int const outlen(utf8_from_uchar(&buf[j], buf.size() - j, uchar));
                if (0 >= outlen)
                {
                    break;
                }

                for (int tempi = 0; tempi < temp.Length; tempi++)
                {
                    buf[(int)j + tempi] = temp[tempi];
                }

                j += (size_t)outlen;
            }

            return(new string(buf.ToArray()).Substring(0, (int)j));  //return std::string(&buf[0], j);
        }