My-basic application 1: introduction to my-basic parser

MY-BASIC is a lightweight BASIC interpreter written in standard C in dual files.
//MY-BASIC It's a lightweight BASIC Interpreter , Using standard C Language is written in two files .
 
It's aimed to be embeddable, extendable and portable.
// Its goal is to be embeddable 、 Scalable and portable .

It is a dynamic typed programming language,reserves structured syntax,
// It's a dynamically typed programming language , Preserve structured syntax
 
supports a style of prototype-based programming (OOP),
// Support a prototype based programming style (OOP)

also implements a functional paradigm by lambda abstraction.
// And through lambda Abstract realization of function paradigm .

The core is written in a C source file and an associated header file.
// The core is in a C Source file and a related header file .

It's easy to either use it as a standalone interpreter or embed it with existing projects in C, C++, Java, Objective-C, Swift, C#, etc.
and totally customizable by adding your own scripting interfaces.
It can be used as an independent interpreter ,
It can also be embedded into existing C、c++、Java、Objective-C、Swift、c# Etc ,
And it can be completely customized by adding its own script interface .

Main features
Main features

MY-BASIC offers a wide range of features including:
MY-BASIC Provide a wide range of functions , as follows ：

    Written in standard C, source code is portable to a dozen of platforms
    // Using standard C The source code can be ported to more than a dozen platforms

    Lightweight (within less than 128KB footprint), fast, and configurable
    // Lightweight ( Less than 128KB Memory footprint )、 Fast and configurable

    With both retro and modern BASIC syntax
    // With retro and modern basic grammar

    Case-insensitive tokenization, and many other indelible BASIC flavour
    // Case insensitive tags , And many others BASIC Indelible elements

    Unicode support
    //Unicode Support

    Prototype-based programming, with reflection support
    // Prototype based programming , Support reflection

    Lambda abstraction enhanced functional programming
    //Lambda Abstraction enhances functional programming

    Customizable referenced/non-referenced usertype
    // Customizable references / Non reference usertype

    Collection construction and manipulation functions for LIST and DICT
    // For lists and DICT Set construction and operation functions of

    Automatic releasing for referenced values (prototype, lambda, referenced usertype, list, dictionary, etc.) benefited from reference counting and garbage collection
    // For reference value ( Prototype 、lambda、 Refer to the usertype、 list 、 Dictionary, etc ) The automatic release of benefits from reference counting and garbage collection

    Common numeric and string functions
    // Common numeric and string functions

    Structured sub routine definition with the DEF/ENDDEF statements
    // Use DEF/ENDDEF Statement defines a structured subroutine

    Structured IF/THEN/ELSEIF/ELSE/ENDIF
    // structure ：IF/THEN/ELSEIF/ELSE/ENDIF

    Structured FOR/TO/STEP/NEXT, FOR/IN/NEXT, WHILE/WEND, DO/UNTIL
    // structure ：FOR/TO/STEP/NEXT, FOR/IN/NEXT, WHILE/WEND, DO/UNTIL

    Reserved retro GOTO, GOSUB/RETURN
    // Preserved retro GOTO, GOSUB/RETURN

    Importing multiple source files with the IMPORT statement
    // Use IMPORT Statement to import multiple source files

    Debug API
    // debugging API

    Customizable memory pool
    // Customizable memory pool

    Easy API, for extending new BASIC functions
    // ordinary API, Used to extend new basic functions

    Easy interacting BASIC facilities at native side, and vice versa
    // Easy to interact with basic facilities on the local side , vice versa

    More features under development
    // More features are under development