精华内容
下载资源
问答
  • 脚本解释器

    千次阅读 2014-02-14 08:53:23
    Ch:Ch是一个跨平台的C/C++脚本解释器,它支持ISO的C语言标准(C90/C99),C++,附带了8000多个函数库并支持众多的工业标准,支持POSIX, socket/Winsock, X11/Motif, OpenGL, ODBC, C LAPACK, GTK+, Win32, XML, 和...

    Javascript:V8

    C/C++:

        1. Ch:Ch是一个跨平台的C/C++脚本解释器,它支持ISO的C语言标准(C90/C99),C++,附带了8000多个函数库并支持众多的工业标准,支持POSIX, socket/Winsock, X11/Motif, OpenGL, ODBC, C LAPACK, GTK+, Win32, XML, 和CGI等等。Ch具有MATLAB的高级数值计算和绘图的功能,且具有良好的交互性,在C/C++语言编程学习方面尤为好用。Ch也是一个可嵌入的脚本引擎,可以无缝地嵌入到自己的程序中。网站:http://www.softintegration.com

        2. CInt:http://root.cern.ch/drupal/content/cint

    Python:

    Lua:

    展开全文
  • 易语言IIS脚本解释器源码,IIS脚本解释器,GetExtensionVersion,HttpExtensionProc
  • IIS脚本解释器.rar

    2020-04-05 02:40:32
    IIS脚本解释器.rar
  • 易语言 IIS脚本解释器

    2018-04-23 20:02:56
    易语言 IIS脚本解释器
  • ActivePerl脚本解释器

    2019-01-11 15:40:07
    ActivePerl一个perl脚本解释器。其包含了包括有 Perl for Win32、Perl for ISAPI、PerlScript、Perl Package Manager四套开发工具程序,可以让用户编写出适用于unix,windows,linux系统的CGI程序来。
  • 类C语法脚本解释器

    2013-09-28 17:02:34
    类C语法脚本解释器。类C语法脚本解释器。类C语法脚本解释器
  • lua脚本解释器ANSI C

    2017-06-29 17:55:06
    lua脚本解释器ANSI C
  • 易语言源码易语言IIS脚本解释器源码.rar
  • 易语言IIS脚本解释器源码
  • 指定脚本解释器

    千次阅读 2017-07-29 10:32:41
    以下是我常用的 指定 脚本解释器 的方式 command official annotations personal annotations #!/bin/bash 执行时,调用 /bin 下的 bash 解释器 #!/usr/bin/python 执行时,调用 /usr/bin 下的 python 解释...

      以下是我常用的 指定 脚本解释器 的方式:

    commandofficial annotationspersonal annotations
    #!/bin/bash执行时,调用 /bin 下的 bash 解释器
    #!/usr/bin/python执行时,调用 /usr/bin 下的 python 解释器写死了 python 路径
    #!/usr/bin/env python执行时,到 env(环境设置)里查找 python 的安装路径,再调用该路径(如 Anaconda2)下的解释器来解释这是我常用的


    展开全文
  • 最好的脚本解释器源代码,功能非常强大,C++语言开发!
  • 该项目是官方维护的协变脚本解释器。 切换语言 特征 跨平台,支持大多数主流操作系统 与旧版编译器兼容-用C ++ 14编写 Linux和Unix:x86,ARM,MIPS,Loongson ISA Microsoft Windows:x86 强大且无膨胀的扩展...
  • 脚本解释器框架.rar

    2020-06-04 23:15:15
    这是一个用C++写的脚本语言的解释器框架,有变量定义,标准函数,关键字,运算符等,唯一就是无法自定义数据和函数,本人会努力持续更新(我也是个菜鸟) 注:DEV-C++全部编译通过
  • CalM包括一个基于数学解析器的脚本解释器。 CalM脚本语言使您可以定义自己的函数和变量。 这些可以导出并在其他脚本中使用。 脚本框架支持称为MComp(数学组件)的组件类型。 MComp被实现为Java类,并允许进一步...
  • Basic脚本解释器移植到STM32

    热门讨论 2014-05-23 17:51:36
    上次讲了LUA移植到STM32,这次讲讲Basic脚本解释器移植到STM32。在STM32上跑Basic脚本,同样可以跟穿戴设备结合,也可以作为初学者学习MCU的入门工具,当然前提是有人做好Basic的STM32交互实现。这里使用的是uBasic...
  • bash 是一个为GNU计划编写的Unix shell。它的名字是一系列缩写:Bourne-Again Shell — 这是关于Bourne shell(sh)的一个双关语(Bourne again / born again)。 bash是大多数Linux系统...检测脚本是否正确,并不执行
  • 更新脚本解释器 使用yacc和lex的更新程序脚本解释器的简单C语言
  • Pascal 脚本解释器

    2006-02-23 15:31:04
    多达57个内置单元,内置非常多函数/类的Pascal脚本解释器
  • MKScript(鼠标键盘自动化脚本解释器)是一款功能强大的鼠标键盘自动化脚本解释器,MKScript通过编写脚本,可以让MKScript代替双手,自动执行一系列鼠标键盘操作,非常给力,需要的朋友快来下载使用吧! 使用帮助: ...
  • 编写简单脚本解释器

    万次阅读 2010-11-11 13:37:00
    编写简单的脚本解释器 收藏 首先声明一下以下文章是跟据我用C#写的脚本解释器的经验之谈,如不认可也请不要找本人。 一般写个脚本解释器需要以下的步骤: 源程序-词法分析-语法分析-生成...

    编写简单的脚本解释器 收藏

    首先声明一下以下文章是跟据我用C#写的脚本解释器的经验之谈,如不认可也请不要找本人。

    一般写个脚本解释器需要以下的步骤:

    源程序-词法分析-语法分析-生成中间代码-解释中间代码

    一、我写的脚本解释器就是跟据上面的过程写的,下面说明一下本脚本解释器的语法。

    1、语法规则:

    (1)script_begin代表语句开始

    (2)script_end代表语句结束

    (3)条件语句:if 表达式 语句 endif

    (4)循环语句:while 表达式 语句 endwhile

    (5)赋值语句:变量=表达式

    (6)表达式:

    (为方便我们这里使用产生式来说明)

    expr->expr+term|expr-term|term|term>=term|term<=term|term==term|term!=term|term>term|term<term|term

    term->term*factor|term/factor|factor

    factor->(expr)|数字|变量|字符串|!变量

    (注意:产生式中的->代表前面的值可以是后面中的任何一个值,|代表着或的意思)

    (7)变量:本脚本只有全局变量,我们使用一个结构符号表(另外这个表还保存着关键字等)来保存变量名、类型(说明是变量、关键字等)和值。以下是此符号表的定义:

    public struct Symtable

    {

    public string value;

    public string valuestr;

    public int toketype;

    }

    Symtable[] m_table=new Symtable[max_size];

    max_size的大小说明了本脚本可以定义的变量数有多少。

    2、词法分析:

    在这个阶段解释器把读取的字符分为以下类型:

    1)、变量

    2)、数字

    3)、字符串

    4)、+、-、*/等符号

    5)、ifwhile等关键字

    以下是此过程的代码:

           private int lexan(StreamReader sr)

            {

                m_tmpvalue = "";

                char t;

                while (true)

                {

                    t = (char)sr.Read();

                    if (sr.EndOfStream)

                    {

                        return -1;

                    }

                    if (t == ' ')

                    {

                    }

                    else if (t == '/r')

                    {

                        t = (char)sr.Read();

                        if (t == '/n')

                        {

                            error_line_num++;

                        }

                    }

                    else if (Char.IsDigit(t))

                    {

                        while (Char.IsDigit(t))

                        {

                            m_tmpvalue += t;

                            t = (char)sr.Peek();

                            if (Char.IsDigit(t))

                            {

                                sr.Read();

                            }

                        }

                        return m_numtype;

                    }

                    else if (isStrword(t))

                    {

                        while (isStrword(t))

                        {

                            m_tmpvalue += t;

                            t = (char)sr.Peek();

                            if (isStrword(t))

                            {

                                sr.Read();

                            }

                        }

                        int p = LookUp(m_tmpvalue);

                        if (p == -1)

                        {

                            p = InertTable(m_tmpvalue, m_idtype);

                        }

                        return m_symtable[p].toketype;

                    }

                    else if (isSingleword(t))

                    {

                        return (int)t;

                    }

                    else if (isDoubleword(t))

                    {

                        char tmpc = (char)sr.Peek();

                        if (tmpc == '=')

                        {

                            sr.Read();

                            if (t == '>')

                            {

                                return m_largede;

                            }

                            else if (t == '<')

                            {

                                return m_smallde;

                            }

                            else if (t == '!')

                            {

                                return m_bude;

                            }

                            else if (t == '=')

                            {

                                return m_dede;

                            }

                            else

                            {

                                CException.ScriptError("格式错误!");

                            }

                        }

                        return (int)t;

                    }

                    else if (t == '/"')

                    {

                        t=(char)sr.Read();

                        while (t != '/"')

                        {

                            m_tmpvalue += t;

                            t = (char)sr.Read();

                        }

                        return m_strtype;

                    }

                    else

                    {

                        CException.ScriptError("错误格式");

                        return -1;

                    }

                }

          }

    2、语法分析:

    在这个过程中对读取的字符按产生式的进行分阶段处理;表达式从中缀变成后缀,中缀就像3+4+5的后缀就是34+5+并面在后缀中是不需要括号的。这个阶段还要生成中间代码。

    代码如下:

            private void match(int t, StreamReader sr)
            {
                if (t == m_headtype)
                {
                    m_headtype = lexan(sr);
                }
                else
                {
                    CException.ScriptError("错误格式");
                }
            }
            private void WriteToMemory(string s)
            {
                m_zhongJingdaima += s;
            }
            public int stmtExplain(StreamReader sr)
            {
                if (m_headtype == m_begintype)
                {
                    match(m_headtype, sr);
                    int ret = stmtExplain(sr);
                    while (ret != 0)
                    {
                        ret = stmtExplain(sr);
                    }
                }
                else if (m_headtype == m_endtype)
                {
                    match(m_headtype, sr);
                    return 0;
                }
                else if (m_headtype == m_iftype)
                {
                    WriteToMemory("label:" + label_line + "/n");
                    label_line++;
                    match(m_headtype, sr);
                    expr(sr);
                    WriteToMemory("gofalse label:" + label_line + " /n");

                    stmtExplain(sr);
                    match(m_endif, sr);
                    WriteToMemory("label:" + label_line + "/n");
                    label_line++;
                }
                else if (m_headtype == m_whiletype)
                {
                    int tmplabel=label_line;
                    WriteToMemory("label:" + label_line + "/n");
                    label_line++;
                    match(m_headtype, sr);
                    expr(sr);
                    WriteToMemory("gofalse label:" + label_line + " /n");

                    stmtExplain(sr);
                    match(m_endwhile, sr);
                    WriteToMemory("goto label:" + tmplabel + " /n");
                    WriteToMemory("label:" + label_line + "/n");
                    label_line++;
                }
                else if (m_headtype == m_funtiontype)
                {
                    WriteToMemory("function ");
                    WriteToMemory(m_tmpvalue);

                    WriteToMemory("/n");
                    match(m_headtype, sr);
                }
                else if (m_headtype == m_idtype)
                {

                    int index = LookUp(m_tmpvalue);
                    WriteToMemory("lvalue " + m_tmpvalue + "/n");
                    match(m_headtype, sr);
                    match('=', sr);
                    expr(sr);
                    WriteToMemory(":=/n");
                }
                return 1;
            }
            private void expr(StreamReader sr)
            {
                term(sr);
                while (true)
                {
                    switch (m_headtype)
                    {
                        case '+':
                            {
                                match(m_headtype, sr);
                                term(sr);
                                WriteToMemory("+/n");
                                continue;
                            }
                        case '-':
                            {
                                match(m_headtype, sr);
                                term(sr);
                                WriteToMemory("-/n");
                                continue;
                            }
                        case m_largede:
                            {
                                match(m_headtype, sr);
                                term(sr);
                                WriteToMemory(">=/n");
                                continue;
                            }

                        case m_smallde:
                            {
                                match(m_headtype, sr);
                                term(sr);
                                WriteToMemory("<=/n");
                                continue;
                            }
                        case m_bude:
                            {
                                match(m_headtype, sr);
                                term(sr);
                                WriteToMemory("!=/n");
                                continue;
                            }
                        case m_dede:
                            {
                                match(m_headtype, sr);
                                term(sr);
                                WriteToMemory("==/n");
                                continue;
                            }
                        case '>':
                            {
                                match(m_headtype, sr);
                                term(sr);
                                WriteToMemory(">/n");
                                continue;
                            }
                        case '<':
                            {
                                match(m_headtype, sr);
                                term(sr);
                                WriteToMemory("</n");
                                continue;
                            }
                        default:
                            return;
                    }
                }
            }
            private void term(StreamReader sr)
            {
                factor(sr);
                while (true)
                {
                    switch (m_headtype)
                    {
                        case '*':
                            {
                                match(m_headtype, sr);
                                factor(sr);
                                WriteToMemory("*/n");
                                continue;
                            }
                        case '/':
                            {
                                match(m_headtype, sr);
                                factor(sr);
                                WriteToMemory("//n");
                                continue;
                            }
                        default:
                            return;
                    }
                }
            }
            private void factor(StreamReader sr)
            {
               
                switch (m_headtype)
                {
                    case '(':
                        {
                            match('(', sr);
                            expr(sr);
                            match(')', sr);
                            break;
                        }
                    case m_numtype:
                        {
                            WriteToMemory("push " + m_tmpvalue + "/n");
                            match(m_numtype, sr);
                            break;
                        }
                    case m_idtype:
                        {
                            WriteToMemory("rvalue "+m_tmpvalue+"/n");
                            match(m_idtype, sr);
                            break;
                        }
                    case m_strtype:
                        {
                            WriteToMemory("push " + m_tmpvalue + "/n");
                            match(m_headtype, sr);
                            break;
                        }
                    case '!':
                        {   
                            match(m_headtype, sr);
                            match(m_headtype, sr);
                            WriteToMemory("oppvalue "+m_tmpvalue+"/n");
                            break;
                        }
                    case m_funtiontype:
                        {
                            WriteToMemory("function ");
                            WriteToMemory(m_tmpvalue);

                            WriteToMemory("/n");
                            match(m_headtype, sr);
                            break;
                        }
                    default:
                        CException.ScriptError("错误格式!");
                        break;
                }
            }
            private string ReadStrLine(string s)
            {
                int tmpindex = s.IndexOf("/n",m_excuteline_index);
                string tmpstr;
                if (tmpindex != -1)
                {
                    int readlength=tmpindex-m_excuteline_index;
                    tmpstr = s.Substring(m_excuteline_index,readlength);
                    m_excuteline_index = tmpindex+1;
                }
                else
                {
                    return null;
                }
                return tmpstr;
            }

     

     

    二、现在我们的已把你的难以解释的脚本语言生成容易解释的中间代码,现在开始解释中间代码,为完成这个目标我们先看下中间语言的语法规则:

     

    中间语法:

    Push / /压栈

    Lvalue /取值压栈

    + 弹出栈顶两个值相加后压栈

    function 函数

    等等

     

          private void ExectStr()
            {
                string retstr;
                retstr = ReadStrLine(m_zhongJingdaima);
                while (retstr != null)
                {
                    if (retstr.StartsWith("lvalue"))
                    {
                        string[] split = retstr.Split(new char[] { ' ' });
                        int index=LookUp(split[1]);
                        m_stack.push(Convert.ToString(index));
                    }
                    else if (retstr.StartsWith("function"))
                    {
                        string tmpvalue = retstr.Substring(9);
                        string pushvalue = null;
                        int paramstart = tmpvalue.IndexOf('(') + 1;
                        int paramend = tmpvalue.LastIndexOf(')');
                        int paramlength = paramend - paramstart;
                        string subparam = tmpvalue.Substring(paramstart, paramlength);
                        ArrayList split=new ArrayList();

                        while (true)
                        {
                            string paramstr="";
                            int startindex=0;
                            if (subparam.StartsWith("/""))
                            {
                                startindex = subparam.IndexOf("/"", 1);
                                if (startindex == -1)
                                {
                                    break;
                                }
                                paramstr = subparam.Substring(1, startindex - 1);
                                startindex = subparam.IndexOf(",", startindex);

                            }
                            else
                            {
                               
                                startindex = subparam.IndexOf(",", startindex);
                                if (startindex == -1)
                                {
                                    paramstr = subparam;
                                }
                                else
                                {
                                    paramstr = subparam.Substring(0, startindex);
                                }
                                int tmplookindex = LookUp(paramstr);
                                if (tmplookindex != -1)
                                {
                                    paramstr = m_symtable[tmplookindex].value;
                                }
                            }
                            split.Add(paramstr);                     
                            if (startindex == -1)
                            {
                                break;
                            }
                            startindex++;
                            subparam = subparam.Substring(startindex);      
                        }

                        

                        if (tmpvalue.StartsWith("Strcat"))
                        {
                            pushvalue = m_globalFunction.Strcat(split[0].ToString(), split[1].ToString());
                        }
                        else if (tmpvalue.StartsWith("StartSplit"))
                        {
                            pushvalue = m_globalFunction.StartSplit(split[0].ToString(), split[1].ToString());
                        }
                        else if (tmpvalue.StartsWith("NextSplit"))
                        {
                            pushvalue = m_globalFunction.NextSplit(split[0].ToString(), split[1].ToString());
                        }
                        else if (tmpvalue.StartsWith("GetSplit"))
                        {
                            pushvalue = m_globalFunction.GetSplit(split[0].ToString(), split[1].ToString(), Convert.ToInt32(split[2]));
                        }
                        else
                        {
                            CException.ScriptError("错误格式!");
                        }
                        if (pushvalue != null)
                        {
                            m_stack.push(pushvalue);
                        }
                    }
                    else if (retstr.StartsWith("push"))
                    {
                        //int index=retstr.IndexOf(' ', 0);
                        string tmpstr = retstr.Substring(5);
                        m_stack.push(tmpstr);
                    }
                    else if (retstr.StartsWith("oppvalue"))
                    {
                        string[] split = retstr.Split(new char[] { ' ' });
                        int index = LookUp(split[1]);
                        bool tmpbool = !Convert.ToBoolean(m_symtable[index].value);
                        m_stack.push(Convert.ToString(tmpbool));
                    }
                    else if (retstr.StartsWith("rvalue"))
                    {
                        string[] split = retstr.Split(new char[] { ' ' });
                        int index = LookUp(split[1]);
                        m_stack.push(m_symtable[index].value);
                    }
                    else if (retstr.StartsWith(":="))
                    {
                        string rtmpvalue = m_stack.pop();
                        string ltmpvalue = m_stack.pop();
                        m_symtable[Convert.ToInt32(ltmpvalue)].value = rtmpvalue;
                    }
                    else if (retstr.StartsWith("+"))
                    {
                        string ltmpvalue = m_stack.pop();
                        string rtmpvalue = m_stack.pop();
                        string totalvalue = Convert.ToString(Convert.ToInt32(ltmpvalue) + Convert.ToInt32(rtmpvalue));
                        m_stack.push(totalvalue);
                    }
                    else if (retstr.StartsWith("*"))
                    {
                        string rtmpvalue = m_stack.pop();
                        string ltmpvalue = m_stack.pop();
                        string totalvalue = Convert.ToString(Convert.ToInt32(ltmpvalue) * Convert.ToInt32(rtmpvalue));
                        m_stack.push(totalvalue);
                    }
                    else if (retstr.StartsWith("/"))
                    {
                        string rtmpvalue = m_stack.pop();
                        string ltmpvalue = m_stack.pop();
                        string totalvalue = Convert.ToString(Convert.ToInt32(ltmpvalue) / Convert.ToInt32(rtmpvalue));
                        m_stack.push(totalvalue);
                    }
                    else if (retstr.StartsWith("-"))
                    {
                        string rtmpvalue = m_stack.pop();
                        string ltmpvalue = m_stack.pop();
                        string totalvalue = Convert.ToString(Convert.ToInt32(ltmpvalue) - Convert.ToInt32(rtmpvalue));
                        m_stack.push(totalvalue);
                    }
                    else if (retstr.StartsWith(">="))
                    {
                        string rtmpvalue = m_stack.pop();
                        string ltmpvalue = m_stack.pop();
                        if (Convert.ToInt32(ltmpvalue) >= Convert.ToInt32(rtmpvalue))
                        {
                            m_stack.push("true");
                        }
                        else
                        {
                            m_stack.push("false");
                        }
                    }
                    else if (retstr.StartsWith("!="))
                    {
                        string rtmpvalue = m_stack.pop();
                        string ltmpvalue = m_stack.pop();
                        if (Convert.ToInt32(ltmpvalue) != Convert.ToInt32(rtmpvalue))
                        {
                            m_stack.push("true");
                        }
                        else
                        {
                            m_stack.push("false");
                        }
                    }
                    else if (retstr.StartsWith("<="))
                    {
                        string rtmpvalue = m_stack.pop();
                        string ltmpvalue = m_stack.pop();
                        if (Convert.ToInt32(ltmpvalue) <= Convert.ToInt32(rtmpvalue))
                        {
                            m_stack.push("true");
                        }
                        else
                        {
                            m_stack.push("false");
                        }
                    }
                    else if (retstr.StartsWith(">"))
                    {
                        string rtmpvalue = m_stack.pop();
                        string ltmpvalue = m_stack.pop();
                        if (Convert.ToInt32(ltmpvalue) > Convert.ToInt32(rtmpvalue))
                        {
                            m_stack.push("true");
                        }
                        else
                        {
                            m_stack.push("false");
                        }
                    }
                    else if (retstr.StartsWith("<"))
                    {
                        string rtmpvalue = m_stack.pop();
                        string ltmpvalue = m_stack.pop();
                        if (Convert.ToInt32(ltmpvalue) < Convert.ToInt32(rtmpvalue))
                        {
                            m_stack.push("true");
                        }
                        else
                        {
                            m_stack.push("false");
                        }
                    }
                    else if (retstr.StartsWith("=="))
                    {
                        string rtmpvalue = m_stack.pop();
                        string ltmpvalue = m_stack.pop();
                        if (ltmpvalue == rtmpvalue)
                        {
                            m_stack.push("true");
                        }
                        else
                        {
                            m_stack.push("false");
                        }
                    }
                    else if (retstr.StartsWith("gofalse"))
                    {
                        string rtmpvalue = m_stack.pop();
                        if (!Convert.ToBoolean(rtmpvalue))
                        {
                            string[] split = retstr.Split(new char[] { ' ' });
                            string strtofind = split[1] + "/n";
                            int tmppos = m_zhongJingdaima.IndexOf(strtofind);
                            m_excuteline_index = tmppos;
                        }
                    }
                    else if (retstr.StartsWith("gotrue"))
                    {
                        string rtmpvalue = m_stack.pop();
                        if (Convert.ToBoolean(rtmpvalue))
                        {
                            string[] split = retstr.Split(new char[] { ' ' });
                            string strtofind = split[1] + "/n";
                            int tmppos = m_zhongJingdaima.IndexOf(strtofind);
                            m_excuteline_index = tmppos;
                        }
                    }
                    else if (retstr.StartsWith("goto"))
                    {
                        string[] split = retstr.Split(new char[] { ' ' });
                        string strtofind = split[1] + "/n";
                        int tmppos = m_zhongJingdaima.IndexOf(strtofind);
                        m_excuteline_index = tmppos;
                    }
                    retstr = ReadStrLine(m_zhongJingdaima);
                }
            }

    展开全文
  • python学习之指定脚本解释器

    千次阅读 2017-05-31 23:05:49
    python脚本解释器 在脚本中经常看到开头有#!/usr/bin/xxx这样一行,这个就是脚本解释器的指定语法,意思是使用/usr/bin/xxx来执行下边的脚本代码 详解 在python中,可以用命令:python xxx.py来执行python脚本文件...

    python脚本解释器

    在脚本中经常看到开头有#!/usr/bin/xxx这样一行,这个就是脚本解释器的指定语法,意思是使用/usr/bin/xxx来执行下边的脚本代码

    详解

    • 在python中,可以用命令:python xxx.py来执行python脚本文件,在这种情况下无需在脚本的第一行写#!/usr/bin/python,因为这个命令已经指定了使用python来执行xxx.py脚本
    • 在另外一个情况下,比如想直接调用xxx.py来执行python脚本,那就需要指定python解释器作为当前的脚本解释器

    测试

    • 在xxx.py脚本中直接输入print "hello world",然后执行python xxx.py,这个时候正常输出hello world;在xxx.py文件目录下运行:./xxx.py,会提示语法有问题;
    • 再在第一行加上#!/usr/bin/python,这个时候,执行python xxx.py./xxx.py,都正常打印出hello world
    展开全文
  • Ad hoc网络脚本解释器的研究与仿真,钱苏苗,,由于Ad hoc网络的拓扑动态变化,传统的网络测量方式已很难满足测量需求。为了通过有效的网络测量手段获取Ad hoc网络的各项性能指标,
  • c++写的一个脚本解释器,可以嵌入到程序里由用户动态配置自己的程序
  • 无人机或其它嵌入式系统上用的类C语言脚本解释器-picoc
  • Linux中各个命令的脚本解释器祥解 1.#!/bin/bash是什么? 我们通常在写脚本时使用#!/bin/sh 来让sh执行文件, 这表示支持任何POSIX shell命令语言的sh程序, 加上我们的bash扩展语法功能 2.#!/bin/bash在写...
  • 大概13年上半年做页游时候,ActionScript3不方便弄脚本,突发奇想自己写个脚本来跑,按照简单的C语言语法,看了下编译原理,手写递归下降,实现了一个很简单的解释器,懒了运行时没做栈执行,后来由于各种原因,也没用上,前几...
  • 脚本解释器构架(三)

    千次阅读 2009-06-01 22:25:00
    运行时环境脚本的运行时环境(Run-Time Environment, RTE)是解释器的核心。... 基于伪指令的解释由于我的脚本解释器不是采用这种解释方式,因此先介绍这种方式,然后详细介绍我的脚本解释器的基于语法树的解释方式

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 253,496
精华内容 101,398
关键字:

脚本解释器