far内置函数源代码，java写的

package com.faros.core.kls;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.*;


import cn.hutool.poi.excel.ExcelReader;
import cn.hutool.poi.excel.ExcelUtil;
import com.cn.fyt.far.common.conf.CommonConf;
import com.faros.core.kls.oop.TypeObject;
import com.faros.core.interf.IFarObject;
import com.faros.core.interf.Iklass;
import com.faros.core.kls.oop.*;
import com.faros.core.vm.FrameObject;
import com.faros.core.vm.Vm;
import com.faros.exceptions.FarVmExcept;
import com.faros.exceptions.FarVmUserExcept;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;


import java.io.*;
import java.net.http.WebSocket;
import java.nio.ByteBuffer;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * @Description: Long类型
 * @Author: Fang.j
 **/
public class EfuncKlass extends KlassBase implements Iklass {


    //创建自己的实例
    public static EfuncKlass createMetaKlass() {


        EfuncKlass klass = new EfuncKlass();
        klass.setKlassName("EfuncKlass");
        klass.addMethod("input", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("input", EfuncKlass::input));
        klass.addMethod("println", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("len", EfuncKlass::println));
        klass.addMethod("newObj", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("newObj", EfuncKlass::newObj));
        klass.addMethod("sscanf", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("sscanf", EfuncKlass::sscanf));
        klass.addMethod("time", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("time", EfuncKlass::time));
        klass.addMethod("getDeepDir", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("getDeepDir", EfuncKlass::getDeepDir));
        klass.addMethod("toJsonStr", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("toJsonStr", EfuncKlass::toJsonStr));
        klass.addMethod("createThread", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("createThread", EfuncKlass::createThread));
        klass.addMethod("addSimEfun", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("addSimEfun", EfuncKlass::addSimEfun));
        klass.addMethod("strlen", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("strlen", EfuncKlass::strlen));
        klass.addMethod("undefinedp", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("undefinedp", EfuncKlass::undefinedp));
        klass.addMethod("subcut", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("subcut", EfuncKlass::subcut));
        klass.addMethod("toStr", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("toStr", EfuncKlass::toStr));
        klass.addMethod("funcExists", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("funcExists", EfuncKlass::funcExists));
        klass.addMethod("random", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("random", EfuncKlass::random));
        klass.addMethod("toJsonStr", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("toJsonStr", EfuncKlass::toJsonStr));
        klass.addMethod("jsonStrToMap", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("jsonStrToMap", EfuncKlass::jsonStrToMap));
        klass.addMethod("keys", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("keys", EfuncKlass::keys));
        klass.addMethod("fmt", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("fmt", EfuncKlass::fmt));
        klass.addMethod("createNet", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("createNet", EfuncKlass::createNet));
        klass.addMethod("baseName", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("baseName", EfuncKlass::baseName));
        klass.addMethod("strsrch", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("strsrch", EfuncKlass::strsrch));
        klass.addMethod("varDump", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("varDump", EfuncKlass::varDump));
        klass.addMethod("values", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("values", EfuncKlass::values));
        klass.addMethod("intp", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("intp", EfuncKlass::intp));
        klass.addMethod("mapp", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("mapp", EfuncKlass::mapp));
        klass.addMethod("stringp", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("stringp", EfuncKlass::stringp));
        klass.addMethod("nonep", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("nonep", EfuncKlass::nonep));
        klass.addMethod("arrayp", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("arrayp", EfuncKlass::arrayp));

        klass.addMethod("range", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("range", EfuncKlass::range));
        klass.addMethod("test_throw", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("test_throw", EfuncKlass::vm_throw));
        klass.addMethod("test_throw", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("test_throw", EfuncKlass::vm_throw));
        klass.addMethod("hashCode", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("hashCode", EfuncKlass::hashCode));
        klass.addMethod("dirName", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("dirName", EfuncKlass::dirName));
        klass.addMethod("fAddr", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("fAddr", EfuncKlass::fAddr));
        klass.addMethod("objectp", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("objectp", EfuncKlass::objectp));
        klass.addMethod("testObj", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("testObj", EfuncKlass::testObj));
        klass.addMethod("mapDelete", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("mapDelete", EfuncKlass::mapDelete));
        klass.addMethod("readExcel", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("readExcel", EfuncKlass::readExcel));
        klass.addMethod("hasKey", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("hasKey", EfuncKlass::hasKey));
        klass.addMethod("toDouble", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("toDouble", EfuncKlass::toDouble));
        klass.addMethod("toInt", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("toInt", EfuncKlass::toInt));
        klass.addMethod("sizeof", NativeMethodKlass.getMetaKlass().getNativeMethodKlass().createObj("sizeof", EfuncKlass::sizeof));

        return klass;
    }


    public static Iklass getMetaKlass() {
        return Vm.iklassMaps.get("EfuncKlass");
    }


    public IFarObject createObj(String val) {
        IFarObject typeObject = new TypeObject();
        EfuncKlass klass = new EfuncKlass();
        klass.setKlassName(this.getKlassName());
        typeObject.setIklass(klass);
        return typeObject;
    }


    public Iklass createKlassObj() {
        Iklass klass = EfuncKlass.getMetaKlass();

        return klass;
    }

    /**
     * 创建网络 支持http https websocket
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject createNet(FrameObject callFrame, List<IFarObject> args) {
        IFarObject type = args.get(1);
        //端口号
        IFarObject port = args.get(0);
        FWebSocket fWebSocket = new FWebSocket();
        fWebSocket.getIklass().getWebSocketKlass().setPort(port.fString().val());
        callFrame.getStack().push(fWebSocket);
        return null;
    }


    public static IFarObject vm_throw(FrameObject callFrame, List<IFarObject> args) {

        throw new FarVmUserExcept("什么奥!");
    }


    /**
     * 检查对象的字段、数组的下标、Map的属性是否存在
     * hasKey( var src,string prop )
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject hasKey(FrameObject callFrame, List<IFarObject> args) {

        IFarObject key = args.get(0);
        IFarObject src = args.get(1);
        if( src.klsType()==KlassBase.ARRAY ){
            //key只能是int

            if( key.fInt().val() > -1 && key.fInt().val() < src.getIklass().getArrayKlass().getDatas().size() ){

                callFrame.getStack().push(new FBool(1));
            }else{
                //越界
                callFrame.getStack().push(new FBool(0));
            }

        }

        return null;
    }

    /**
     * 获取Map或者数组的key
     *
     * string *keys(map m|object ob);
     * 返回 m 的keys列表 或 对象的所有字段
     *
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject keys(FrameObject callFrame, List<IFarObject> args) {

        IFarObject e = args.get(0);
        FArray fArray = new FArray();
        if(e==null){
            throw new FarVmUserExcept("expect map, got 'null'");
        }
        if( e.klsType()!=KlassBase.MAP  ){
            throw new FarVmUserExcept("expect map, got "+e);
        }
         e.getIklass().getMapKlass().getDatas().keySet().forEach(e2e->{
             fArray.add(callFrame,e2e);
         });

        callFrame.getStack().push(fArray);
        return null;
    }


    /**
     * 多个OBJ进行对比，主要是解决咩有调试器时，多个对象的属性，字段等查看
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject testObj(FrameObject callFrame, List<IFarObject> args) {
        //默认是获取调用funcAddress("")的对象

// 第一种，Map

        return null;
    }


    /**
     *
     * arg1 excel地址
     * arg2 从第几行开始读
     * arg3 读到第几行 0 表示读所有
     * arg3 map<string,var> string 列明 var 值类型
     *
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject readExcel(FrameObject callFrame, List<IFarObject> args){
        IFarObject endIdx = args.get(0);
        IFarObject startIDx = args.get(1);
        //读第几页
        IFarObject pageIdx = args.get(2);
        IFarObject xlsFile = args.get(3);

//        ExcelReader reader = ExcelUtil.getReader("E:\\AAAA_CODE\\new-eclipse-workspace\\farcs\\ngame\\test\\doc\\J技能.xls");

        var wkdir = System.getProperty("user.dir");
        ExcelReader reader = ExcelUtil.getReader(wkdir+"/doc/J技能.xls");
        //读那个表 0是第一个页
        reader.setSheet(pageIdx.fString().val());

        List<List<Object>> rows = null;
        if( endIdx.fInt().val()<=0 ){
           rows = reader.read(startIDx.fInt().val());
        }else{
            rows = reader.read(startIDx.fInt().val(),endIdx.fInt().val());
        }

        FArray fArray = new FArray();
        for (int i = 0; i < rows.size() ; i++) {
            FArray fArray1 = new FArray();
            for (int j = 0; j < rows.get(i).size(); j++) {
                IFarObject e = new FNone();
                if( rows.get(i).get(j) instanceof String ){
                    e = new FString((String) rows.get(i).get(j));
                }else if(rows.get(i).get(j) instanceof Integer ){
                    e = new FInt((Integer) rows.get(i).get(j));
                }else if(rows.get(i).get(j) instanceof Double){
                    e = new FDouble((Double) rows.get(i).get(j));
                }else if(rows.get(i).get(j) instanceof Long){
                    e = new FInt(((Long) rows.get(i).get(j)).intValue());
                }
                else{
                    int x=1;
                }
                fArray1.add(callFrame,e);
            }
            fArray.add(fArray1);
        }
        callFrame.getStack().push(fArray);


        return null;
    }


    public static IFarObject sizeof(FrameObject callFrame, List<IFarObject> args) {
        //默认是获取调用funcAddress("")的对象
        IFarObject e = args.get(0);
        if( e.klsType()==KlassBase.ARRAY ){
            callFrame.getStack().push(new FInt(e.getIklass().getArrayKlass().getDatas().size()));
            return null;
        }
        return null;

    }


    /**
     * 获取方法的地址
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject fAddr(FrameObject callFrame, List<IFarObject> args) {
        //默认是获取调用funcAddress("")的对象
        IFarObject e = args.get(0);
        IFarObject owner = callFrame.getOwner();
        String fName = e.fString().val();
        IFarObject method  = owner.getIklass().findMethod(fName);
        callFrame.getStack().push(method);
        return null;
    }

    /**
     *
     * 名称
     *    map_delete() - 通过 key 从一个映射移除一组值(key:value)
     * 语法
     *    void map_delete( mapping m, mixed element| mixed *element );
     * 描述
     *    map_delete 从映射 `m` 中移除 key 为 `element` 的键值对(key:value)。
     *
     *    示例，给定：
     *
     *    mapping names;
     *
     *    names = ([]);
     *    names["truilkan"] = "john";
     *    names["wayfarer"] = "erik";
     *    names["jacques"] = "dwayne";
     *
     *    那么：
     *
     *    map_delete(names,"truilkan");
     *
     *    导致映射 `names` 的结果为：
     *
     *    (["wayfarer" : "erik", "jacques" : "dwayne"])
     *
     *    在 map_delete(names, "truilkan") 后映射 `names` 中不再包括 `truilkan`，除非再被加回去。
     *
     *
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject mapDelete(FrameObject callFrame, List<IFarObject> args) {

        IFarObject e    = args.get(0);
        IFarObject src  = args.get(1);
        src.fMap().remove(callFrame,e);
        return null;
    }


    public static IFarObject hashCode(FrameObject callFrame, List<IFarObject> args) {
        IFarObject e = args.get(0);
        callFrame.getStack().push( new FString( String.valueOf(e.hashCode())));
        return null;
    }

    /**
     * 获取调用这个方法的对象的相对路径
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject dirName(FrameObject callFrame, List<IFarObject> args) {
        String klassName = callFrame.getOwner().getIklass().getKlassName();
        String s[]  = klassName.split("/");
        List<String> list = Arrays.asList(s);
        list = CollectionUtil.sub(list,0,s.length-1);
        String ss = list.stream().collect(Collectors.joining("/"));
        callFrame.getStack().push(new FString(ss));
        return null;
    }



    /**
     *   values() 返回一个映射 `m` 所有 value 组成的数组
     *
     *    示例，如:
     *
     *    mapping m;
     *
     *    m = (["hp" : 35, "sp" : 42, "mass" : 100]);
     *
     *    那么
     *
     *    values(m) == ({35, 42, 100})
     *
     *    注意：返回的 value 的顺序和 keys() 外部函数返回的所有 key 的顺序一致。
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject values(FrameObject callFrame, List<IFarObject> args) {

        IFarObject e = args.get(0);
        FArray fArray = new FArray();

        e.fMap().getDatas().values().forEach(v->{
            fArray.add(callFrame,v);
        });
        callFrame.getStack().push(fArray);
        return null;
    }

    /**
     * 特殊用途的内置函数，主要用于生成int 数组
     * 该函数，编译器会调用，勿删
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject range(FrameObject callFrame, List<IFarObject> args) {

        IFarObject e = args.get(0);
        IFarObject s = args.get(1);

        int ss = s.fInt().val();
        int ee = e.fInt().val();
        FArray fArray = new FArray();
        for (int i = ss; i <=ee ; i++) {
            fArray.add(new FInt(i));
        }
        callFrame.getStack().push(fArray);

        return null;
    }

    public static IFarObject intp(FrameObject callFrame, List<IFarObject> args) {

        IFarObject e = args.get(0);
        if( e.klsType()==KlassBase.INT) {
            callFrame.getStack().push(new FBool(1));
        }else{
            callFrame.getStack().push(new FBool(0));
        }
        return null;
    }
    public static IFarObject stringp(FrameObject callFrame, List<IFarObject> args) {

        IFarObject e = args.get(0);
        if( e.klsType()==KlassBase.STR) {
            callFrame.getStack().push(new FBool(1));
        }else{
            callFrame.getStack().push(new FBool(0));
        }
        return null;
    }



    public static IFarObject ftpClient(FrameObject callFrame, List<IFarObject> args){



            FTPClient client = new FTPClient();
            try {
                client.connect("192.168.31.10", 21);
                client.login("plm", "plm369");
                System.out.println(client.getControlEncoding());
                int reply = client.getReplyCode();
                if (!FTPReply.isPositiveCompletion(reply)) {
                    client.disconnect();
                    System.out.println("Login error");
                    return new FNone();
                }
                client.setControlEncoding("GBK");


                System.out.println(client.getCharsetName());

                client.enterLocalPassiveMode();
                client.changeWorkingDirectory("\\preview\\1735111079512\\");



                client.setBufferSize(1024);
                client.setFileType(FTP.BINARY_FILE_TYPE);
                client.enterLocalPassiveMode();


                FTPFile[] fs = client.listFiles();
                FileOutputStream out = null;
                InputStream in = null;

                String fileName = "24CI98-A1-04加两个中文.pdf";
//            System.out.println("Default Charset=" + java.nio.charset.Charset.defaultCharset());
                for (int i = 0; i < fs.length; i++) {
                    FTPFile ff = fs[i];
                    String outFileName = ff.getName();
                    System.out.println(outFileName);

                    //本地目录文件不需要编码
                    File localFile = new File("D:\\ftp\\" + fileName);
                    OutputStream fos = new FileOutputStream(localFile);
                    // ftp需使用ISO-8859-1编码格式

                    String path11= CharsetUtil.convert(fileName,CharsetUtil.GBK,CharsetUtil.ISO_8859_1);
                    client.retrieveFile(path11, fos);
                    fos.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally{
                try {
                    client.disconnect();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }


        return new FNone();


    }
    public static IFarObject nonep(FrameObject callFrame, List<IFarObject> args) {

        IFarObject e = args.get(0);
        if( e.klsType()!=KlassBase.NONE) {
            callFrame.getStack().push(new FBool(0));
        }else{
            callFrame.getStack().push(new FBool(1));
        }
        return null;
    }

    public static IFarObject arrayp(FrameObject callFrame, List<IFarObject> args) {

        IFarObject e = args.get(0);
        if( e.klsType()!=KlassBase.ARRAY) {
            callFrame.getStack().push(new FBool(0));
        }else{
            callFrame.getStack().push(new FBool(1));
        }
        return null;
    }


    public static IFarObject objectp(FrameObject callFrame, List<IFarObject> args) {

        IFarObject e = args.get(0);

        if( e==null ){
            callFrame.getStack().push(new FBool(0));
            return null;
        }

        if( e.klsType()!=KlassBase.UOBJ) {
            callFrame.getStack().push(new FBool(0));
            return null;
        }
        callFrame.getStack().push(new FBool(1));

        return null;
    }


    public static IFarObject mapp(FrameObject callFrame, List<IFarObject> args) {

        IFarObject e = args.get(0);
        if( e==null ){//肯定不应该有这种情况存在!
            callFrame.getStack().push(new FBool(0));
            return null;
        }
        if( e.klsType()==KlassBase.MAP) {
            callFrame.getStack().push(new FBool(1));
        }else{
            callFrame.getStack().push(new FBool(0));
        }
        return null;
    }

    /**
     * object newObj( string str);
     * 根据str创建对象,不支持fileName的文件地址
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject newObj(FrameObject callFrame, List<IFarObject> args) {
        try{
            String clsName = args.get(0).getIklass().getStringKlass().getVal();
            callFrame.getStack().push(new FObject(callFrame,clsName));
            return null;
        }catch (Exception e){
            throw new FarVmUserExcept(e.getMessage());
        }
    }

    /**
     * int strsrch( string str, string substr | int char, int flag | void);
     *   strsrch() 在字符串 `str` 中寻找第一个子字符串 `substr` 出现的的位置，如果第三个参数（可选参数，默认值为0） `flag` 是 -1 代表最后一次出现的位置。
     *   如果第二个参数是整数，会寻找 ascii 字符（类似C语言中的 strchr() 和 strrchr()）。
     *   无法从空字符串或 null 值中寻找。
     *
     * @param callFrame
     * @param args
     * @return 返回第一个（或最后一个）匹配的字符串的位置，起始位置从 0 开始，如果返回 -1 代表没有匹配。
     */
    public static IFarObject strsrch(FrameObject callFrame, List<IFarObject> args) {

        IFarObject e1,e2,e3;
        if(  args.size()==2 ){
            //子串
            e1 = args.get(0);
            //源字符串
            e2 =args.get(1);
            int idx = StrUtil.indexOf(e2.fString().val(),e1.fString().val(),0,false);
            callFrame.getStack().push(new FInt(idx));

        }
        //


        return null;
    }

    /**
     * 在对象中查找方法是否存在
     * 可以查找父类，但不能查找efunc
     *
     * int funcExists( object ob, string func);
     * 查找ob是否有func方法
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject funcExists(FrameObject callFrame, List<IFarObject> args) {
        IFarObject funName = args.get(0);
        IFarObject obj = args.get(1);
        IFarObject callable = obj.getIklass().findMethod( funName.fString().val() );

        if(callable==null || callable.klsType()==KlassBase.NONE ){
            callFrame.getStack().push(new FBool(0));
        }else {
            callFrame.getStack().push(new FBool(1));
        }
        return null;
    }
    //创建随机数
    public static IFarObject random(FrameObject callFrame, List<IFarObject> args) {

        if (args.size() <= 0) {
            callFrame.getStack().push(new FInt(RandomUtil.randomInt()));
        } else if (args.size() == 2) {
            IFarObject s = args.get(1);
            IFarObject e = args.get(0);
            int ss = s.fInt().val();//.val().intValue();
            int ee = e.fInt().val();
            callFrame.getStack().push( new FInt(RandomUtil.randomInt(ss, ee))   );
        }


        return null;
    }


    /**
     * 创建线程对象
     *
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject createThread(FrameObject callFrame, List<IFarObject> args) {

        if( args.get(0).klsType()==KlassBase.METHOD ){//匿名函数
            String mtName = args.get(0).getIklass().getMethodKlass().getMethodName();
            FThread fThread = new FThread(mtName);
            fThread.getIklass().getThreadKlass().setTaskerIsMethod(true);
            fThread.getIklass().getThreadKlass().setTasker(args.get(0));
            fThread.getIklass().getThreadKlass().setMethodName(mtName);
            fThread.getIklass().getThreadKlass().setThread(Thread.ofVirtual().name("Far-thread-" + mtName));
            callFrame.getStack().push(fThread);
        }else{
            String mtName = args.get(0).getIklass().getStringKlass().getVal();
            IFarObject tasker = args.get(1);
            FThread fThread = new FThread(mtName);
            fThread.getIklass().getThreadKlass().setTasker(tasker);
            fThread.getIklass().getThreadKlass().setMethodName(mtName);
            fThread.getIklass().getThreadKlass().setThread(Thread.ofVirtual().name("Far-thread-" + mtName));
            callFrame.getStack().push(fThread);

        }
        return null;

    }


    public static List<String> sscanfHelper(String input, String format) {
        List<String> results = new ArrayList<>();

        // Replace all "%s" in the format string with a regex pattern that matches non-whitespace sequences
        String regex = format.replaceAll("%s", "([^\\s]+)");

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regex);

        // Match the input string against the pattern
        Matcher matcher = pattern.matcher(input);

        // Check if there is a match (we don't need a full match here, just check for groups)
        if (matcher.find()) {
            // Find all capture groups and add them to the results list
            for (int i = 1; i <= matcher.groupCount(); i++) {
                results.add(matcher.group(i));
            }
        }

        // If there were fewer matches than groups in the format string, the results list will have fewer elements
        // than expected. This is acceptable because it indicates that the input did not provide enough values.
        // Optionally, you can pad the results list with empty strings to match the number of %s in the format.

        // Return the results list
        return results;
    }

    /**
     * 添加用户仿真内置函数
     * 让用户代码中可以全局使用的函数
     * @param callFrame
     * @param args
     * @return
     */
    @Deprecated
    public static IFarObject addSimEfun(FrameObject callFrame, List<IFarObject> args) {

        IFarObject obj = args.get(0);
        EfuncKlass.getMetaKlass().getEfuncKlass().userSimulationFuns.add(obj);
        return null;
    }

    //特殊用
    public static IFarObject addSimEfun(  IFarObject obj ) {
        EfuncKlass.getMetaKlass().getEfuncKlass().userSimulationFuns.add(obj);
        return null;
    }


    public static void println(FrameObject callFrame, String s) {
        List<IFarObject> args = Arrays.asList(new FString(s));
        println(callFrame, args);
    }

    public static IFarObject input(FrameObject callFrame, List<IFarObject> args) {
        String outStr = args.get(0).getIklass().getStringKlass().getVal();
        println(callFrame, outStr);
        Scanner scanner = new Scanner(System.in);
        String inputString = scanner.nextLine(); // 读取一整行输入

        callFrame.getStack().push(new FString(inputString));
        return null;
    }


    /***
     * 字符串格式化
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject fmt(FrameObject callFrame, List<IFarObject> args) {
        IFarObject str = args.get(0);//数据包
        Object[] vars = new Object[args.size()-1];

        for (int i = 0,j=args.size()-2; i < vars.length; i++,j--) {

            if( args.get(j).klsType()==KlassBase.STR ){
                vars[i] = args.get(j).getIklass().getStringKlass().getVal();
            } else if (args.get(j).klsType()==KlassBase.INT ) {
                vars[i] = args.get(j).getIklass().getIntKlass().getVal();
            } else if (args.get(j).klsType()==KlassBase.LONG) {
                vars[i] = args.get(j).getIklass().getLongKlass().getVal();
            }else if (args.get(j).klsType()==KlassBase.DOUBLE) {
                vars[i] = args.get(j).getIklass().getDoubleKlass().getVal();
            }
        }
        String fmtStr = args.get(args.size()-1).getIklass().getStringKlass().getVal();

        String s = String.format( fmtStr,vars  );
        callFrame.getStack().push(new FString(s));
        return null;
    }

    /**
     * int strlen(string str)
     * 获取str的长度
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject strlen(FrameObject callFrame, List<IFarObject> args) {
        IFarObject str = args.get(0);
        int len =   str.fString().val().length();
        callFrame.getStack().push(new FInt(len));
        return null;
    }


    /**
     *
     * 数组转字符串，数组内部能转的只能是数字和字符串
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject toStr(FrameObject callFrame, List<IFarObject> args) {
        IFarObject vals = args.get(0);//取几个

        if( vals.klsType()==KlassBase.ARRAY ){
            StringBuilder stringBuilder = new StringBuilder();
            vals.getIklass().getArrayKlass().getDatas().forEach(e->{
                stringBuilder.append(      e.fString().val() );
            });
            callFrame.getStack().push( new FString(stringBuilder.toString()) );
        }else if(vals.klsType()==KlassBase.DOUBLE){
            callFrame.getStack().push(  new FString(vals.fDouble().val().toString())  );
        }else if(vals.klsType()==KlassBase.INT){
            callFrame.getStack().push(  new FString(String.valueOf(vals.fInt().val()))  );
        }


        return null;
    }

    public static IFarObject toDouble(FrameObject callFrame, List<IFarObject> args) {
        IFarObject val = args.get(0);//取几个

        Double nv=0d;
        if(val.klsType()==KlassBase.INT ) {
            nv = Double.valueOf(val.fInt().val());
        }

        callFrame.getStack().push( new FDouble(nv));
        return null;
    }

    public static IFarObject toInt(FrameObject callFrame, List<IFarObject> args) {
        IFarObject val = args.get(0);//取几个
        int nv=0;
        if(val.klsType()==KlassBase.DOUBLE ) {
            nv = val.fDouble().val().intValue();
        } else if (val.klsType()==KlassBase.INT) {
            nv = val.fInt().val();
        }
        callFrame.getStack().push( new FInt(nv));
        return null;
    }



    //截取，支持数组和字符串
    //跳过第几位 取到第几位
    public static IFarObject subcut(FrameObject callFrame, List<IFarObject> args) {
        IFarObject start = args.get(0);//第几个开始取
        IFarObject end = args.get(1);//取几个
        IFarObject src = args.get(2);//原数据
        int s = start.fInt().val();
        int e = end.fInt().val();
        if(src.klsType()==KlassBase.ARRAY){
            FArray fArray = new FArray();
           List<IFarObject> result =  src.getIklass().getArrayKlass().getDatas().subList(e,s);
           result.forEach(e1->{
                fArray.add(callFrame, e1);
           });
           callFrame.getStack().push(fArray);
        }
        return null;
    }


    public static IFarObject undefinedp(FrameObject callFrame, List<IFarObject> args) {
        IFarObject checkVal = args.get(0);
        if( checkVal.klsType()==KlassBase.NONE ){
            callFrame.getStack().push(new FBool(1));
        }else{
            callFrame.getStack().push(new FBool(0));
        }


        return null;
    }

    public static List<IFarObject> ssca11nf1(String str, String format) {
        List<IFarObject> resultList = new ArrayList<>();
        Scanner scanner = new Scanner(str);

        // 将格式字符串拆分成多个部分
        String[] formatParts = format.split("(?=%)|(?<=%)", -1);
        for (String part : formatParts) {
            if (part.startsWith("%") && part.length() > 1) {
                // 处理格式化指令
                char specifier = part.charAt(1);
                switch (specifier) {
                    case 'd': // 整数
                        if (scanner.hasNextInt()) {
                         //   resultList.add(scanner.nextInt() + "");
                        } else {
                            throw new IllegalArgumentException("Expected an integer but found none");
                        }
                        break;
                    case 'f': // 浮点数
                        if (scanner.hasNextFloat()) {
                        //    resultList.add(scanner.nextFloat() + "");
                        } else {
                            throw new IllegalArgumentException("Expected a float but found none");
                        }
                        break;
                    case 's': // 字符串
                        if (scanner.hasNext()) {
                            resultList.add(new FString(scanner.next()));
                        } else {
                            throw new IllegalArgumentException("Expected a string but found none");
                        }
                        break;
                    default:
                        throw new IllegalArgumentException("Unsupported format: " + part);
                }
            } else {
                // 处理非格式化部分
                if (part.length() > 0) {
                    String nextToken = scanner.findWithinHorizon(Pattern.quote(part), 0);
                    if (nextToken == null || !nextToken.equals(part)) {
                        throw new IllegalArgumentException("Expected '" + part + "' but found none");
                    }
                }
            }
        }

        scanner.close();
        return resultList;
    }

    public static List<IFarObject> sscanf1(String str, String format) {
        List<IFarObject> resultList = new ArrayList<>();
        Scanner scanner = new Scanner(str);
        scanner.useDelimiter("\\s+"); // 使用一个或多个空白字符作为分隔符

        // 创建一个匹配给定格式的模式
        Scanner formatScanner = new Scanner(format);
        while (formatScanner.hasNext()) {
            String token = formatScanner.next();
            if (token.startsWith("%")) {
                // 处理格式化指令
                switch (token.charAt(1)) {
                    case 'd': // 整数
                        if (scanner.hasNextInt()) {
                            resultList.add(new FString(Integer.toString(scanner.nextInt())));
                        } else {
                            throw new IllegalArgumentException("Expected an integer but found none");
                        }
                        break;
                    case 'f': // 浮点数
                        if (scanner.hasNextFloat()) {
                            resultList.add(new FString(Float.toString(scanner.nextFloat())));
                        } else {
                            throw new IllegalArgumentException("Expected a float but found none");
                        }
                        break;
                    case 's': // 字符串
                        if (scanner.hasNext()) {
                            resultList.add(new FString(scanner.next()));
                        } else {
                            throw new IllegalArgumentException("Expected a string but found none");
                        }
                        break;
                    default:
                        throw new IllegalArgumentException("Unsupported format: " + token);
                }
            } else {
                // 如果不是格式化指令，则检查是否与下一个输入匹配
                if (!scanner.hasNext(token)) {
                    throw new IllegalArgumentException("Expected '" + token + "' but found none");
                }
                scanner.next(token); // 消耗掉匹配的部分
            }
        }

        scanner.close();
        formatScanner.close();

        return resultList;
    }


    public static IFarObject sscanf(FrameObject callFrame, List<IFarObject> args) {

        if( args.size()<2 ){
            throw new FarVmExcept(callFrame,"'sscanf' expect 2 parameters, got "+args.size());
        }

        String oldStr = args.get(1).getIklass().getStringKlass().getVal();
        String fmtStr = args.get(0).getIklass().getStringKlass().getVal();

       List<IFarObject> result = sscanf1(oldStr,fmtStr );
        FArray fArray = new FArray();
        for (int i = 0; i < result.size(); i++) {
            fArray.add(callFrame, result.get(i));
        }
        callFrame.getStack().push(fArray);
        return null;
    }


    public static IFarObject time(FrameObject callFrame, List<IFarObject> args) {
        FLong time = new FLong(System.currentTimeMillis());
        callFrame.getStack().push(time);
        return null;
    }

    /**
     * 深度读取指定文件夹下的所有文件
     *
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject getDeepDir(FrameObject callFrame, List<IFarObject> args) {
        String path = args.get(0).getIklass().getStringKlass().getVal();
        FArray fArray = new FArray();
        if (!FileUtil.isAbsolutePath(path)) {
            path = CommonConf.farProjDir + File.separator + path;
        }
        List<File> files = FileUtil.loopFiles(path);
        files.forEach(e -> {

            String fileName = e.getName();
            FMap fMap = new FMap();
            fMap.put(callFrame, new FString("name"), new FString(fileName));
            //是否是文件
            fMap.put(callFrame, new FString("isFile"), e.isFile() ? new FBool(1) : new FBool(0));
            //文件大小 单位 字节
            fMap.put(callFrame, new FString("size"), new FLong(e.length()));
            //绝对路径
            fMap.put(callFrame, new FString("absPath"), new FString(e.getAbsolutePath()));

            String s = StrUtil.replace(e.getAbsolutePath(),CommonConf.farProjDir+File.separator,"");
            s = StrUtil.replace(s,"\\","/");
            fMap.put(callFrame, new FString("path"), new FString(s));


            //是否隐藏
            fMap.put(callFrame, new FString("isHidden"), e.isHidden() ? new FBool(1) : new FBool(0));
            //最后修改时间
            fMap.put(callFrame, new FString("lastModified"), new FLong(e.lastModified()));
            fArray.add(callFrame, fMap);
        });
        callFrame.getStack().push(fArray);
        return null;
    }



    public static IFarObject toJsonStr(FrameObject callFrame, List<IFarObject> args) {
        Stack<IFarObject> refObjStack = new Stack<>();
        callFrame.getStack().push(new FString(args.get(0).getIklass().toJsonValue(callFrame,refObjStack).toString()));
        return null;
    }


    public static IFarObject toType(Object e){
        if(e instanceof String){
            return new FString(e.toString());
        } else if (e instanceof Integer) {
            return new FInt(String.valueOf(e));
        } else if (e instanceof JSONObject val) {
           return toMapVal(val);
        }else if (e instanceof JSONArray arrayVal) {
            FArray fArray= new FArray();
            arrayVal.forEach(e2e->{
                fArray.add(toType(e2e));
            });
            return fArray;
        }
        return null;
    }

    public static IFarObject toMapVal(JSONObject e){
        FMap fMap = new FMap();
        e.forEach((k,v)->{
            fMap.put(new FString(k),toType(v));
        });
        return fMap;
    }

    public static void toMap(FrameObject callFrame,FMap fMap,JSONObject jObj){
        jObj.forEach((k,v)->{
            fMap.put(callFrame,new FString(k),toType(v));
        });
    }

    public static IFarObject jsonStrToMap(FrameObject callFrame, List<IFarObject> args) {
        String jstr = args.get(0).fString().val();
        JSONObject jObj =  JSONUtil.parseObj( jstr );
        FMap fMap = new FMap();
        jObj.forEach((k,v)->{
            fMap.put(callFrame,new FString(k),toType(v));
        });

        callFrame.getStack().push(fMap);
        return null;
    }

    /**
     * 获取类名
     * @param callFrame
     * @param args
     * @return
     */
    public static IFarObject baseName(FrameObject callFrame, List<IFarObject> args) {
        IFarObject obj = args.get(0);
        callFrame.getStack().push(new FString(obj.getIklass().getKlassName()));
        return null;
    }


    public static IFarObject varDump(FrameObject frameObject, List<IFarObject> args){
        String retVal = "";
        String hashCode = String.valueOf(args.get(0).hashCode());
        if (args.get(0).getIklass().klsType() == KlassBase.LONG) {
            retVal = String.format("long(%s)#%d",hashCode,args.get(0).getIklass().getLongKlass().getVal());

        } else if (args.get(0).getIklass().klsType() == KlassBase.STR) {
            retVal = String.format("string(%s)#%s",hashCode,args.get(0).getIklass().getStringKlass().getVal());

        } else if (args.get(0).getIklass().klsType() == KlassBase.DOUBLE) {

        } else if (args.get(0).getIklass().klsType() == KlassBase.ARRAY) {

        }
        else if (args.get(0).getIklass().klsType() == KlassBase.MAP) {
            retVal = String.format("map(%s)#%s",hashCode,args.get(0).toString());
        }
        else if (args.get(0).getIklass().klsType() == KlassBase.INT) {
            retVal = String.format("int(%s)#%d",hashCode,args.get(0).fInt().val());
        }
        else if (args.get(0).getIklass().klsType() == KlassBase.BOOL) {
            String s = args.get(0).getIklass().getBoolKlass().getVal()==1?"true":"false";
            retVal = String.format("bool(%s)#%s",hashCode,s);

           
        }
        else if (args.get(0).getIklass().klsType() == KlassBase.UOBJ) {
            retVal = String.format("object(%s)#%s",args.get(0).hashCode(),   args.get(0).getIklass().getKlassName());
        }
        else {
            retVal = String.format("not processing(%s)#%s",hashCode,args.get(0).getIklass().getKlassName());
           
        }
        
        frameObject.getStack().push(new FString(retVal));

        return null;

    }

    public static IFarObject println(FrameObject callFrame, List<IFarObject> args) {

        if (args.get(0).getIklass().klsType() == KlassBase.LONG) {
            System.out.println(args.get(0).getIklass().getLongKlass().getVal());
        } else if (args.get(0).getIklass().klsType() == KlassBase.STR) {
            System.out.println(args.get(0).getIklass().getStringKlass().getVal());
        } else if (args.get(0).getIklass().klsType() == KlassBase.DOUBLE) {
            System.out.println(args.get(0).getIklass().getDoubleKlass().getVal());
        } else if (args.get(0).getIklass().klsType() == KlassBase.ARRAY) {
            String hasCode = String.valueOf(args.get(0).getClass().hashCode());
            String s = "array#"+hasCode+" size "+args.get(0).getIklass().getArrayKlass().getDatas().size();
            System.out.println(s);
        }

        else if (args.get(0).getIklass().klsType() == KlassBase.MAP) {
            System.out.println(args.get(0).getIklass().toString());
        }
        else if (args.get(0).getIklass().klsType() == KlassBase.INT) {

            System.out.println(args.get(0).getIklass().toString());

        }
        else if (args.get(0).getIklass().klsType() == KlassBase.BOOL) {
            String s = args.get(0).getIklass().getBoolKlass().getVal()==1?"true":"false";
            s= "bool#"+args.get(0).hashCode()+" ("+s+")";
            System.out.println( s  );
        }

        else {
            ;
            System.out.println(JSONUtil.toJsonStr(args.get(0).getIklass().getKlassName()));
        }
        callFrame.getStack().push( new FInt(0) );

        return null;
    }

    public Long getVal() {
        return val;
    }

    public void setVal(Long val) {
        this.val = val;
    }


    @Override
    public EfuncKlass getEfuncKlass() {
        return this;
    }

    @Override
    public int klsType() {
        return KlassBase.EFUNC;
    }



    private Long val;

    //用户模拟的内置函数列表,可在用户代码中添加

    private List<IFarObject> userSimulationFuns = new ArrayList<>();


    public List<IFarObject> getUserSimulationFuns() {
        return userSimulationFuns;
    }

    public void setUserSimulationFuns(List<IFarObject> userSimulationFuns) {
        this.userSimulationFuns = userSimulationFuns;
    }
}