//一个方便测试 socket 程序的小文件,省得老是找 lib a 文件

//目前是 gcc 专用,如果 vc 要用另外弄一个好了,不要在这上面弄条件编译 

#ifndef _SOCKET_PLUS_C_

#define    _SOCKET_PLUS_C_

#include <stdio.h>

#include <windows.h>

#include <time.h>

#include <winsock.h>

//#include <>

#include "lstring.c"

//#pragma comment (lib,"*.lib")

//#pragma comment (lib,"libwsock32.a")

//#pragma comment (lib,"libwsock32.a")

// 系统错误信息提示

void PrintError(DWORD last_err);

//--------------------------------------------------

//直接引入的 dll 函数 

//SOCKET PASCAL socket(int,int,int);

//char * (*fun1)(char * p1,char * p2);

#ifndef _MSC_VER

//很多同学不会写函数指针声明//函数指针的写法是,先写正常的函数声明,然后将函数名加上括号,然后在函数名前再加上*号即可!!!

SOCKET PASCAL (*_socket)(int,int,int);

//SOCKET (PASCAL *_socket)(int,int,int); //vc 要这样写,vc6,vc2010 都是如此 //就是将 PASCAL 或者 stdcall 放到函数名的括号中

int PASCAL (*_WSAStartup)(WORD,LPWSADATA);

unsigned long PASCAL (*_inet_addr)(const char*);

u_short PASCAL (*_htons)(u_short);

int PASCAL (*_connect)(SOCKET,const struct sockaddr*,int);

int PASCAL (*_WSAGetLastError)(void);

int PASCAL (*_send)(SOCKET,const char*,int,int);

int PASCAL (*_recv)(SOCKET,char*,int,int);

int PASCAL (*_select)(int nfds,fd_set*,fd_set*,fd_set*,const struct timeval*);

struct hostent * PASCAL (*_gethostbyname)(const char*);

#endif

#ifdef _MSC_VER

SOCKET (PASCAL *_socket)(int,int,int); //vc 要这样写,vc6,vc2010 都是如此//就是将 PASCAL 或者 stdcall 放到函数名的括号中

int  (PASCAL *_WSAStartup)(WORD,LPWSADATA);

unsigned long  (PASCAL*_inet_addr)(const char*);

u_short  (PASCAL*_htons)(u_short);

int  (PASCAL *_connect)(SOCKET,const struct sockaddr*,int);

int  (PASCAL *_WSAGetLastError)(void);

int  (PASCAL *_send)(SOCKET,const char*,int,int);

int  (PASCAL *_recv)(SOCKET,char*,int,int);

int  (PASCAL *_select)(int nfds,fd_set*,fd_set*,fd_set*,const struct timeval*);

struct hostent *  (PASCAL *_gethostbyname)(const char*);

#endif

//-------------------------------------------------- 

int CreateTcpClient()

{

    //LoadLibrary("wsock32.dll");

    return _socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

}

int InitWinSocket()

{

  WSADATA wData;

  //Result := WSAStartup(MakeWord(2, 2), wData) = 0;

  return _WSAStartup(MAKEWORD(, ), &wData);

}

int ConnectIP(SOCKET so, char * ip, int port)

{

  //sock: TSocket;

  //SockAddr: TSockAddr;

  //struct sockaddr SockAddr;

  struct sockaddr_in SockAddr;

  int err;

  int Result = ;

  memset(&SockAddr, , sizeof(SockAddr));

  SockAddr.sin_family = AF_INET;

  SockAddr.sin_port = _htons(port);

  SockAddr.sin_addr.s_addr = _inet_addr(ip);

  //if (_connect(so, (struct sockaddr *)(&SockAddr), sizeof(SOCKADDR_IN)) == SOCKET_ERROR)

  if (_connect(so, &SockAddr, sizeof(SOCKADDR_IN)) == SOCKET_ERROR) //其实是不用转换的

  {

      PrintError();

    err = _WSAGetLastError(); //其实这个和 GetLastError 是一样的

    //ShowMessageFmt('connect socket error，[%d]', [WSAGetLastError]);

    MessageBox(, "connect socket error", "", );

    Result = ;

    //int err = _WSAGetLastError();//如果前面调用了别的 api 这里是取到 0 的,而不是错误信息码 

    PrintError(err);

    if (INVALID_SOCKET == so) printf("connect error:INVALID_SOCKET\r\n");

    return ;

  }

  return ;

}//

//clq 这是我新加的函数，目的是可以根据域名来访问，并且原来的代码只能访问局域网

int ConnectHost(SOCKET so, char * host, int port)

{

    const char * address = host;

    int is_connect = ;

    int err = ; 

    // Create an address structure and clear it

    struct sockaddr_in addr;

    memset(&addr, , sizeof(addr));

    // Fill in the address if possible//先尝试当做IP来解析

    addr.sin_family = AF_INET;

    addr.sin_addr.s_addr = _inet_addr(address);

    // Was the string a valid IP address?//如果不是IP就当做域名来解析

    if (addr.sin_addr.s_addr == -)

    {

        // No, so get the actual IP address of the host name specified

        struct hostent *pHost;

        pHost = _gethostbyname(address);

        if (pHost != NULL)

        {

            if (pHost->h_addr == NULL)

                return ;//false;

            addr.sin_addr.s_addr = ((struct in_addr *)pHost->h_addr)->s_addr;

        }

        else

            return ;//false;

    }    

    addr.sin_port = _htons(port);

    //返回：-1 连接失败；0 连接成功

    if (_connect(so, (struct sockaddr *)&addr, sizeof(addr)) == )

    {

        is_connect = ;//true;

    }

    else

    {

        is_connect = ;//false;

        //连接失败

        //printfd3("WSAGetLastError:%d, WSAEWOULDBLOCK:%d\r\n", WSAGetLastError()-WSABASEERR, WSAEWOULDBLOCK-WSABASEERR);

          PrintError();

        err = _WSAGetLastError(); //其实这个和 GetLastError 是一样的

        //ShowMessageFmt('connect socket error，[%d]', [WSAGetLastError]);

        MessageBox(, "connect socket error", "", );

        is_connect = ;

        //int err = _WSAGetLastError();//如果前面调用了别的 api 这里是取到 0 的,而不是错误信息码 

        PrintError(err);

        if (INVALID_SOCKET == so) printf("connect error:INVALID_SOCKET\r\n");

    }

    return is_connect;

}//

#ifndef faveLoadFunction

#define faveLoadFunction

FARPROC WINAPI LoadFunction(HINSTANCE h, LPCSTR fun_name)

{

    FARPROC WINAPI r = ;

    r = GetProcAddress(h, fun_name);

    if (r == ) printf("load function %s error\r\n", fun_name);

    else printf("load function %s ok\r\n", fun_name);    

    return r;

}//

#endif

void LoadFunctions_Socket()

{

    //HINSTANCE hs = LoadLibrary("wsock32.dll"); //根据不同的编译环境,有可能要从 LoadLibrary 改成 LoadLibraryA

    HINSTANCE hs = LoadLibraryA("wsock32.dll"); //根据不同的编译环境,有可能要从 LoadLibrary 改成 LoadLibraryA

    if (hs == ) printf("load wsock32.dll error\r\n", hs);

    else printf("load wsock32.dll ok\r\n", hs);

    _socket = GetProcAddress(hs, "socket");

    printf("_socket:%d\r\n", _socket);

    if (_socket == ) printf("load _socket error\r\n", hs);

    //--------------------------------------------------

    //直接装载各个 dll 函数

    _socket = LoadFunction(hs, "socket");

    _WSAStartup = LoadFunction(hs, "WSAStartup");

    _inet_addr = LoadFunction(hs, "inet_addr");

    _htons = LoadFunction(hs, "htons");

    _connect = LoadFunction(hs, "connect");

    _WSAGetLastError = LoadFunction(hs, "WSAGetLastError");

    _send = LoadFunction(hs, "send");

    _recv = LoadFunction(hs, "recv");

    _select = LoadFunction(hs, "select");

    _gethostbyname = LoadFunction(hs, "gethostbyname");

}

// 系统错误信息提示

void PrintError(DWORD last_err)

{

    //进行出错。

    //if (!CreateDirectory(_T("c:\\"),0))

    {

        char buf[];//char buf[128];

        LPVOID lpMsgBuf;

        DWORD dw;

        memset(&buf, , sizeof(buf));

        dw = last_err;//GetLastError();

        if (dw == ) dw = GetLastError(); //实际上是可以代替 WSAGetLastError 的 

        //dw = 5;//10035;//6000054;

        if (dw == ) return;

        FormatMessage (

            FORMAT_MESSAGE_FROM_SYSTEM,//FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, //FORMAT_MESSAGE_ALLOCATE_BUFFER 是指要分配内存

            NULL,

            dw,

            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

            (LPTSTR) &buf,//(LPTSTR) &lpMsgBuf,

            ,//0, //因为是自己分配的内存,所以要指出分配了多大

            NULL );

        printf("PrintError(出错码=%d):%s\r\n", dw, buf); //奇怪,这里就是不对//是倒数第 2 个 参数的问题 

        FormatMessage (

            FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, //FORMAT_MESSAGE_ALLOCATE_BUFFER 是指要分配内存

            NULL,

            dw,

            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

            (LPTSTR) &lpMsgBuf,

            , NULL );

         wsprintf(buf,

                    "出错信息 (出错码＝%d): %s",

                    dw, lpMsgBuf);             

        printf("PrintError(出错码=%d):%s\r\n", dw, lpMsgBuf);

        //printf("PrintError(出错码=%d):%s\r\n", dw, &buf); //奇怪,这个是不对的

        printf("PrintError(出错码=%d):%s\r\n", dw, buf);

        LocalFree(lpMsgBuf);

        //输出提示

        //OutputDebugString(szBuf);

    }

}//

//尚未精测试,可能有误

int SendBuf(SOCKET so, char * s, int len)

{

  int r = ;

  int count = ;

  char * p = s;

  //r := 0;

  int Result = ;

  //count := 0;

  //p := @s[1];

  while (Result<len)

  {

    r = _send(so, p, len - Result, );

    if  (r > )

    {

      Result = Result + r;

      p = p + r;

    };

    count++;

    if (count>) //超过多少次就不发送了

    {

      MessageBox(, "send error", "", );

      return Result;

    }

  }

  return Result;

}//

//注意,返回的字符串要自己释放

//lstring RecvBuf(SOCKET so)

//算了,还是传可自动释放的字符串进去方便点

//void RecvBuf(SOCKET so, lstring * buf)//用这个格式也可以,不过与其他语言不通用

lstring * RecvBuf(SOCKET so, struct MemPool * pool)

{

  char buf[+];

  int r = ;

  //lstring s = String("");

  //lstring * s = NewString("", _buf->pool);

  //CheckPString(_buf);

  lstring * s = NewString("", pool);

  memset(&buf, , sizeof(buf));

  r = _recv(so, buf, sizeof(buf)-, ); //留下一个 #0 结尾

  if (r > )

  {

    //SetLength(s, r);

    //Move(buf, s[1], r);

    //s.Append(&s, StringConst(buf, r));

    LString_AppendCString(s, buf, r);

  }

  if (r == ) //一般都是断开了

  {

    MessageBox(, "recv error.[socket close]", "", );

    //return String(""); //不应该再生成一个新的

    return s;

  }

  return s;

}//

//是否可读取

int SelectRead(SOCKET so)

{

  fd_set fd_read; //fd_read:TFDSet;

  struct timeval timeout; // : TTimeVal;

  int Result = ;

  FD_ZERO( &fd_read );

  FD_SET(so, &fd_read ); //个数受限于 FD_SETSIZE 

  timeout.tv_sec = ; //秒

  timeout.tv_usec = ;  //毫秒

  timeout.tv_usec = ;  //毫秒

      //linux 第一个参数一定要赋值

    ////int r = ::select(socket_handle+1, &fd_read, NULL, NULL, &l_timeout);

  //if select( 0, &fd_read, nil, nil, &timeout ) > 0 then //至少有1个等待Accept的connection

  if (_select( so+, &fd_read, NULL, NULL, &timeout ) > ) //至少有1个等待Accept的connection

    Result = ;

  return Result;    

}//

#endif

    gSo = CreateTcpClient();

    r = ConnectHost(gSo, "newbt.net", );

    if (r == ) printf("连接成功!\r\n");

    s = NewString("EHLO\r\n", m);

    SendBuf(gSo, s->str, s->len);

    printf(s->str);

    s->Append(s, s);

    printf(s->str);

    s->AppendConst(s, "中文\r\n");

    printf(s->str);

    rs = RecvBuf(gSo, m); //注意这个并不只是收取一行 

    printf("\r\nRecvBuf:\r\n");

    printf(rs->str);

    rs = RecvBuf(gSo, m); //注意这个并不只是收取一行

    printf("\r\nRecvBuf:\r\n");

    printf(rs->str);

#include <stdio.h>

#include <windows.h>

#include <time.h>

#include <winsock.h>

#include "lstring.c"

#include "socketplus.c"

#include "lstring_functions.c"

//vc 下要有可能要加 lib

//#pragma comment (lib,"*.lib")

//#pragma comment (lib,"libwsock32.a")

//#pragma comment (lib,"libwsock32.a")

//SOCKET gSo = 0;

SOCKET gSo = -;

void main()

{

    int r;

    mempool mem, * m;

    lstring * s;

    lstring * rs;

    //--------------------------------------------------

    mem = makemem(); m = &mem; //内存池,重要 

    //--------------------------------------------------

    //直接装载各个 dll 函数

    LoadFunctions_Socket();

    InitWinSocket(); //初始化 socket, windows 下一定要有 

    gSo = CreateTcpClient();

    r = ConnectHost(gSo, "newbt.net", );

    if (r == ) printf("连接成功!\r\n");

    s = NewString("EHLO\r\n", m);

    SendBuf(gSo, s->str, s->len);

    printf(s->str);

    s->Append(s, s);

    printf(s->str);

    s->AppendConst(s, "中文\r\n");

    printf(s->str);

    rs = RecvBuf(gSo, m); //注意这个并不只是收取一行 

    printf("\r\nRecvBuf:\r\n");

    printf(rs->str);

    rs = RecvBuf(gSo, m); //注意这个并不只是收取一行

    printf("\r\nRecvBuf:\r\n");

    printf(rs->str);

    //--------------------------------------------------

    Pool_Free(&mem); //释放内存池 

    printf("gMallocCount:%d \r\n", gMallocCount); //看看有没有内存泄漏//简单的检测而已  

    //-------------------------------------------------- 

    getch(); //getch().不过在VC中好象要用getch()，必须在头文件中加上<conio.h> 

}

//没办法还是得另定义一个字符串 

#ifndef _L_STRING_C_

#define    _L_STRING_C_

#include <stdio.h>

#include <malloc.h> //有些编译,如果 malloc.h 在后面的话会报 malloc 函数冲突,解决办法很简单,把含有 malloc 的头文件放前面,好让我们的 malloc 定义能覆盖它就可以了

#include <string.h>

//#include <time.h>

//#include <winsock.h>

#include <windows.h>

#include <time.h>

//#include <crt/eh.h> //据说 MinGW终于支持使用seh实现c++ eh了

//https://sourceforge.net/p/mingw-w64/mingw-w64/ci/18a7e88bcbe8bc0de4e07dac934ebf0653c4da7c/tree/mingw-w64-headers/crt/eh.h

int gMallocCount = ;

//简单的内存泄漏检测

void * malloc_v2(size_t size)

{

    gMallocCount++;

    return malloc(size);

}

void * free_v2(void * p)

{

    gMallocCount--;

    free(p);

}

#define malloc malloc_v2

#define free free_v2

typedef struct LString _LString; //相互引用的提前声明好象必须用 typedef

//内存池中的一项//算了, string 的自动释放就很复杂了,还是专注于 string 的吧

struct MemPool_Item{

    //void * data; //要释放的数据,可以是不同类型的

    _LString * data; //要释放的数据,可以是不同类型的

    //void (*FreeFunc)(struct MemPool_Item * item); //对应节点的释放函数//太复杂,就当做原始的 free 函数释放就行了 

    struct MemPool_Item * next;

};

//内存池,用于释放一次函数过程中分配的内存

struct MemPool{

    struct MemPool_Item * Items;

    int Count;

    char * str;

    byte _const; //是否是只读的,如果是只读的就是从数组中构造的,不要释放它

    int id; //只是为调试释放而已 

};

struct LString{

    char * _init; //只是用来判断是否进行了初始化,不可靠的简单判断,为 0 就是初始化了

    int len;

    char * str;

    byte _const;  //是否是只读的,如果是只读的就是从数组中构造的,不要释放它

    byte _malloc; //这个结构是不是 malloc 生成的,如果是还要 free 掉结构体本身

    struct MemPool * pool; //字符串所在的函数体自动释放内存池,如果是 NULL 就是要手工释放的

    //在操作字符串的临时函数中可以使用它

    void (*Append)(struct LString * s, struct LString * add);

    void (*AppendConst)(struct LString * s, char * add);

};

#define mempool struct MemPool 

//函数体临时使用字符串时

//#define USEPOOL struct MemPool _function_mem_ = makemem();

//#define ENDUSEPOOL Pool_Free(&_function_mem_);

//输出打印的级别 

//最普通的错误信息

#define printf_err printf

//最低级别的打印

#define printf_err1

//#define printf_err1 printf

mempool makemem()

{

    mempool mem;

    memset(&mem, , sizeof(mem));

    srand((unsigned) time(NULL)); //用时间做种，每次产生随机数不一样

    mem.id = rand(); //number = rand() % 101; //产生0-100的随机数

    return mem;

}

mempool * newmempool()

{

    mempool * pmem;

    pmem = malloc(sizeof(struct MemPool));

    memset(pmem, , sizeof(struct MemPool));

    srand((unsigned) time(NULL)); //用时间做种，每次产生随机数不一样

    pmem->id = rand(); //number = rand() % 101; //产生0-100的随机数

    return pmem;

}

//太复杂,就当做一个字符串池,用在一个函数体结束时自动释放这个过程中产生的所有临时字符串,类似于 php 的自动释放原理

//加入一个节点, pool 并不分配内存,只是把大家加到一个链表中统一释放而已 //函数参数的定义的函数指针是一样的

void Pool_AddItem(struct MemPool * pool, void * p)

{

    struct MemPool_Item * item = NULL;

    _LString * s = NULL;

    if (pool == NULL) return;

    //--------------------------------------------------

    //简单的验证 

    s = p;//item->data; 

    if (s->_init != NULL) //简单的初始化检测

    {

        printf("Pool_AddItem: error 未初始化的字符串指针!!!\r\n");

    }     

    //-------------------------------------------------- 

    item = malloc(sizeof(struct MemPool_Item));

    memset(item, , sizeof(struct MemPool_Item));

    //item->FreeFunc = FreeFunc;

    item->data = p;

    //下面两步是替换掉头节点

    item->next = pool->Items;

    pool->Items = item;

    pool->Count++;

}//

//释放一大片,可以做些简单的检测

void Pool_Free(struct MemPool * pool)

{

    struct MemPool_Item * item = NULL;

    int i = ;

    _LString * s = NULL;

    for(i=; i<pool->Count; i++)

    {

        printf_err1("Pool_Free:%d, %d\r\n", pool->Count, i);

        item = pool->Items;

        //item->FreeFunc(item->data);

        //item->FreeFunc(item); //这样更清晰一点

        s = item->data; 

        if (s->_init != NULL) //简单的初始化检测

        {

            printf("Pool_Free: error 未初始化的字符串指针!!!\r\n");

        } 

        //free(item->data);

        free(s->str);

        if (s->_malloc == ) //结构体本身也要释放的话

        free(s);

        pool->Items = pool->Items->next; //向下移动一个指针位置

        free(item); //节点自己的内存也要释放

    }

    pool->Count = ;

}

//自动释放

//void autofree(struct MemPool * pool, void * p)

//{

//    Pool_AddItem(pool, p);

//}

void freemempool(mempool * pool)

{

    Pool_Free(pool);

    free(pool);

}

#define freemem Pool_Free

struct LStringRef{

    //const struct LBuf * buf; //这个是保存内存内容的地方,不应该变 //本意是让这个指针值固定,但这样导致里面的值也变不了

    struct LString * buf; //这个是保存内存内容的地方,不应该变 //C 语言的特点,为了在传递参数时不使用指针,只能是把指针放到成员中 

    void (*Append)(struct LString * s, struct LString * add);

    //int (*AppendConst)(struct LString * s, const char * add);

};

#define lstring struct LString 

#define PLString struct LString *

#define stringref struct LStringRef 

//#define GetStr  s.str 

//下面这几个宏可是可以用,不过太容易冲突了,最好是逻辑清晰度要求很高的地方才用

#define GetStr  buf->str

#define GetLen  buf->len 

//#define str()  buf->str

//#define len()  buf->len 

#define str__  buf->str

#define len__  buf->len 

//为了能自动释放,只能是指针,结构体在参数传递时会丢失字段值,所以完全的模仿 C++ 是不可能的 

//绑定各个成员函数

void BindStringFunctions(lstring * s);

//lstring String(char * str);

//自动释放//只释放字符串

void autofree_s(struct MemPool * pool, struct LString * s)

{

    if (s == NULL) return;

    s->pool = pool; //加上这个标志,这样根据这个 s 操作出来的 string 都可以通过它自动释放了 

    //Pool_AddItem(pool, p);

    //Pool_AddItem(pool, s->str);

    Pool_AddItem(pool, s);

}

//自动释放//不只释放字符串,连指针一起释放

void autofree_pstring(struct MemPool * pool, struct LString * s)

{

    if (s == NULL) return;

    s->pool = pool; //加上这个标志,这样根据这个 s 操作出来的 string 都可以通过它自动释放了 

    Pool_AddItem(pool, s);

    //Pool_AddItem(pool, s->str);

}

//

////分配并返回一个字符串

//stringref MakeString(char * str)

//{

//    stringref s;

//

//    s.buf = malloc(sizeof(struct LString));

//    memset(s.buf, 0, sizeof(struct LString));

//

//    s.buf->_const = 0;

//    s.buf->len = strlen(str);

//    s.buf->str = NULL;

//

//    if (str != NULL)

//    {

//        s.buf->str = malloc(s.buf->len + 1); //还要留最后 \0 的位置

//        memset(s.buf->str, 0, s.buf->len + 1);

//

//        strcpy(s.buf->str, str);

//    }

//

//    //绑定各个成员函数

//    //BindStringFunctions(&s);

//

//    return s;

//

//}//

//

////分配并返回一个字符串指针

//lstring * PString(lstring s)

//{

//    //lstring s = String(str);

//

//    lstring * p = malloc(sizeof(struct LString));

//

//    *p = s;

//    p->_malloc = 1; //要释放结构体本身

//

//    autofree_pstring(s->pool, p);

//

//    return p;

//

//}//

//

////释放 //pfree 是否释放指针本身

//void FreeStringRef(stringref * s, int pfree)

//{

//    if (s->buf == NULL || s->buf->str == NULL)

//    {

//        printf("FreeString() error: string is NULL");

//

//        return;

//    }

//

//    if (s->buf->_const != 0)

//    {

//        printf("FreeString() error: string is readonly");

//

//        //return;

//    }

//    else

//    {

//        free(s->buf->str);

//        s->buf->str = NULL;

//    }

//

//    free(s->buf);

//

//    if (pfree)

//        free(s);

//

//}//

void _FreeString(lstring * s, int pfree)

{

    if (s == NULL)

    {

        printf("FreeString() error: lstring * s is NULL");

        return;

    }

    if (s->str == NULL)

    {

        printf("FreeString() error: s->str is NULL");

        return;

    }

    if (s->_const != )

    {

        printf("FreeString() error: string is readonly");

        //return;

    }

    else

    {

        free(s->str);

        s->str = NULL;

    }

    if (pfree)  //是否释放指针本身

        free(s);

}//

void FreeString(lstring s)

{

    _FreeString(&s, ); //只释放数据

}

void FreePString(lstring * s)

{

    _FreeString(s, ); //释放数据和指针

}

////释放//给内存池调用的

//void FreeString_ForPool(struct MemPool_Item * poolitem)

//{

//    //void * p = poolitem->data;

//    lstring * p = poolitem->data;

//

//    if (p == NULL) return;

//

//    printf("准备释放:%s\r\n", p->str);

//

//

//    FreePString(p);

//

//

//}//

//

//分配一个内存池释放的

//lstring * StringPool(struct MemPool * pool, char * str)

//{

//

//    lstring * s = PString(str);

//    Pool_AddItem(pool, s, FreeString_ForPool);

//

//    return s;

//}

//分配一个内存池释放的

//stringref StringRef(struct MemPool * pool, char * str)

//{

//

//    lstring * s = PString(str);

//    Pool_AddItem(pool, s, FreeString_ForPool);

//

//    return *s;

//}

//用结构体就做不了自动释放,所以还是用指针吧,毕竟不是 C++

//lstring String(char * str, struct MemPool * pool)

//{

//

//    lstring s;

//

//    memset(&s, 0, sizeof(struct LString));

//

//    s.len = strlen(str);

//    s.str = malloc(s.len+1);

//    memset(s.str, 0, s.len+1);

//

//    memcpy(s.str, str, s.len);

//

//    //绑定各个成员函数

//    BindStringFunctions(&s);

//

//    autofree_s(pool, s);

//

//    return s;

//}

//各个常用函数中尽量使用这个函数分配新字符串,因为它生成的可自动释放,避免 autofree 满天飞

//这个应该是基础函数,不要使用其他函数实现

lstring * NewString(char * str, struct MemPool * pool)

{

    //lstring s = String(str);

    lstring * p = malloc(sizeof(struct LString));

    memset(p, , sizeof(struct LString)); 

    p->_malloc = ;

    p->len = strlen(str);

    p->str = malloc(p->len+);

    memset(p->str, , p->len+);

    memcpy(p->str, str, p->len);

    //绑定各个成员函数

    BindStringFunctions(p);    

    autofree_pstring(pool, p);

    return p;

}

//一般用于参数传递

lstring StringCopy(lstring str)

{

    lstring s;

    memset(&s, , sizeof(struct LString));

    s.len = str.len;

    s.str = malloc(s.len+);

    memset(s.str, , s.len+);

    memcpy(s.str, str.str, str.len);

    //绑定各个成员函数

    BindStringFunctions(&s);    

    return s;

}

//复制一个字符串给另外一个内存池,如果对方为 NULL 那么就变成*的字符串了,不过最好是不要这样做,应当从设计上要求每个字符串生成时都有medh池

lstring * PStringCopyToPool(lstring * s, struct MemPool * pool)

{

    lstring * p = malloc(sizeof(struct LString));

    memset(p, , sizeof(struct LString));

    p->_malloc = ; //结构体本身是分配的内存,也要释放 

    p->len = s->len;

    p->str = malloc(s->len+);

    memset(p->str, , s->len+);

    memcpy(p->str, s->str, s->len);

    //绑定各个成员函数

    BindStringFunctions(p);    

    //if (autofree == 1) autofree_pstring(s->pool, p);

    autofree_pstring(pool, p);

    return p;

}//

//复制一个字符串

//lstring * PStringCopy(lstring * s, int autofree)

lstring * PStringCopy(lstring * s)

{

    return PStringCopyToPool(s, s->pool);

//    lstring * p = malloc(sizeof(struct LString));

//

//    memset(p, 0, sizeof(struct LString));

//

//    p->_malloc = 1; //结构体本身是分配的内存,也要释放

//

//    p->len = s->len;

//

//    p->str = malloc(s->len+1);

//    memset(p->str, 0, s->len+1);

//

//    memcpy(p->str, s->str, s->len);

//

//    //绑定各个成员函数

//    BindStringFunctions(p);

//

//    //if (autofree == 1)

//    autofree_pstring(s->pool, p);

//

//    return p;

}//

//不分配内存,只是将一个缓冲区按 string 方式操作而已,类似 golang 的 bytes ,所以不要释放它

//这个也是基础函数 ,虽然它的内存不用释放,但也还是要传 pool ,以便给生成的子字符串自动释放的机会

lstring StringConst(char * str, int len, struct MemPool * pool)

{

    lstring s;

    //s._const = 0;

    s._const = ;

    s.len = len; //strlen(str);

    s.str = str; //malloc(s.len);

    s.pool = pool;

    //绑定各个成员函数

    BindStringFunctions(&s);

    return s;

}//

void LString_Append(lstring * _s, lstring * _add)

{

    lstring s = (*_s); //牺牲一点点性能来换语法//golang 就没有 ->

    lstring add = (*_add);//牺牲一点点性能来换语法//golang 就没有 -> 

    char * tmp = malloc(s.len + add.len + ); //还要留最后 \0 的位置

    memset(tmp, , s.len + add.len + );

    memcpy(tmp, s.str, s.len);

    memcpy(tmp + s.len, add.str, add.len); //这里要注意//加上后半段 

    free(s.str);

    s.str = tmp;

    s.len = s.len + add.len;

//    char * tmp = malloc(s->len + add->len + 1); //还要留最后 \0 的位置

//    memset(tmp, 0, s->len + add->len + 1);

//

//    memcpy(tmp, s->str, s->len);

//    memcpy(tmp + s->len, add->str, add->len); //这里要注意//加上后半段

//

//    free(s->str);

//

//    s->str = tmp;

//    s->len = s->len + add->len;    

    *_s = s;

}//

//加入传统 C 字符串

void LString_AppendCString(lstring * s, char * str, int len)

{

    lstring add = StringConst(str, len, s->pool);

    printf("add len:%d", add.len);

    LString_Append(s, &add);

}//

void LString_AppendConst(lstring * s, char * add)

{

    //printf("add len:%d", add->len);

    LString_AppendCString(s, add, strlen(add));

}//

//int LString_AppendConst(lstring * _s, const char * _add)

//{

//    printf("ok4 \r\n");

//    lstring add = StringConst((char *)_add, strlen(_add));

//

//    printf("ok1");

//    LString_Append(_s, &add);

//    printf("ok");

//}//

//检查字符串指针是否合法,只是简单的方法,不可靠,但有一定作用

int CheckPString(lstring * s)

{

    if (s == NULL)

    {

        printf("CheckPString: error, string is NULL!!!\r\n"); //就目前的要自动释放的需求来说,是不能为 NULL 的,因为那样 pool 就没有传入了

        return ;

    }

    printf_err1("CheckPString: s->_init != NULL\r\n");

    if (s->_init != NULL) //其实对于现代的编译器和操作系统来说,如果 s 没有初始化,在这里就很可能崩溃,所以实际上是检测不出来的,所以首尾都打印一下看看这个过程没结束就是这里出错了,对性能要求高的地方,去掉 printf 宏就可以不打印了

    {

        printf("CheckPString: error, string is not init!!!\r\n"); //就目前的要自动释放的需求来说,是不能为 NULL 的,因为那样 pool 就没有传入了

        return ;

    }

    printf_err1("CheckPString: s->_init != NULL ok.\r\n");

    return ;

}//

//绑定各个成员函数

void BindStringFunctions(lstring * s)

{

    printf_err1("BindStringFunctions \r\n");

    s->Append = LString_Append;

    s->AppendConst = LString_AppendConst;

}//

#endif

//操作 lstring * 的各种底层函数

//因为 lstring 包含了传统 C 的 0 结尾,所以大部分可以直接代用 C 的函数,当然最好参照 golang 重写

#ifndef _L_STRING_FUNCTIONS_C_

#define    _L_STRING_FUNCTIONS_C_

#include <stdio.h>

#include <string.h>

#include "lstring.c"

//delphi 转换方便函数//但 C 语言索引是从 0 开始,不是 d7 的从 1 开始,一定要注意

//查找子串位置

//php 的 strpos 基本上也是这样

int pos(lstring * substr, lstring * s)

{

    char * p = strstr(s->str, substr->str);

    if (p == NULL) return -;

    return p - (s->str);

}

//substr(字符串,截取开始位置,截取长度)//从 0 开始

//lstring * substr(lstring * s, int start, int len)

lstring * substring(lstring * s, int start, int len)

{

    lstring r;

    lstring * sub;

    char * p = NULL;

    //if (start + len > s->len) return NULL;//如果太多

    if (start + len > s->len) len = (s->len) - start;//如果太多返回后面的 

    p = s->str + start;

    r = StringConst(p, len, s->pool);

    //r = StringCopy(r); //StringConst 不分配内存的,所以要复制一个新的出来 

    //sub = PString(r);

    //autofree_pstring(s->pool, sub);//返回字符串跟着 s 一起释放 

    sub = PStringCopy(&r);

    return sub;

}

//字符串是否相等 //类似 java 的 equals

int str_equals(lstring * s1, lstring * s2)

{

    if (s1 == NULL && s2 == NULL) return ;

    if (s1 == NULL || s2 == NULL) return ; //两者不可能都为空的情况下有一个为空,那就是不相等了 

    if (s1->len != s2->len) return ; //长度不等肯定也不是 

    if (  == strncmp(s1->str, s2->str, s1->len) ) return ;

    return ;

}

int streq(lstring * s1, lstring * s2)

{

    return str_equals(s1, s2);

}

int str_equals_c(lstring * s1, char * s2)

{

    if (  == strcmp(s1->str, s2) ) return ;

    return ;

}

//3) 前加#，将标记转换为字符串．

//#define C(x) #x

//则C(1+1) 即 ”1+1”．

//#define C(x) #x

#define C(x)

#define C1(a1, x, a2) strcmp(a1, a2)

//int ee_-()

int t()

{

    C(==);

    C1("",==,""); //可以这样模拟一个 == 号出来 

}

//常用简写而已

int seq(lstring * s1, char * s2)

{

    return str_equals_c(s1, s2);

}

//替换单个字符,在需要高效时使用,因为替换一长串比较慢

//str_replace

lstring * str_replace_ch(lstring * s, char ch, char newch)

{

    lstring * r = PStringCopy(s);

    int i;

    for (i=; i<r->len; i++)

    {

        if (r->str[i] == ch)

            r->str[i] = newch;

    }

    return r;

}//

//主要用于判断空字符串//delphi 风格

int length(lstring * s)

{

    if (s == NULL) return ;

    return s->len;

}

//delphi 风格

int Length(lstring * s)

{

    return length(s);

}

//主要用于判断空字符串//golang 风格

int len(lstring * s)

{

    if (s == NULL) return ;

    return s->len;

}

//转换为小写,注意这个在中文下会有问题//为了兼容字符串自动释放,当参数为空时只好返回空,要不找不到父节点

lstring * lowercase(lstring * s)

{

    lstring * r = NULL;

    int i;

    if (s == NULL)

    {

        printf("lowercase: error, string is NULL!!!"); //就目前的要自动释放的需求来说,是不能为 NULL 的,因为那样 pool 就没有传入了

        return NULL;

    }

    //检查字符串指针是否合法,只是简单的方法,不可靠,但有一定作用

    CheckPString(s);

    r = PStringCopy(s);

    //r->pool = s->pool; //让原字符串释放它

    //autofree_pstring(s->pool, r); //让原字符串释放它

    for (i = ; i < r->len; i++)

    {

        r->str[i] = tolower(r->str[i]);

    }

    //没有返回值,确实有问题 

    return r;

}

//转换为大写,注意这个在中文下会有问题//为了兼容字符串自动释放,当参数为空时只好返回空,要不找不到父节点

lstring * uppercase(lstring * s)

{

    lstring * r = NULL;

    int i;

    if (s == NULL)

    {

        printf("lowercase: error, string is NULL!!!"); //就目前的要自动释放的需求来说,是不能为 NULL 的,因为那样 pool 就没有传入了

        return NULL;

    }

    //检查字符串指针是否合法,只是简单的方法,不可靠,但有一定作用

    CheckPString(s);

    r = PStringCopy(s);

    //r->pool = s->pool; //让原字符串释放它

    //autofree_pstring(s->pool, r); //让原字符串释放它

    for (i = ; i < r->len; i++)

    {

        r->str[i] = toupper(r->str[i]);

    }

    //没有返回值,确实有问题 

    return r;

}

//与传统 get_value 不同,这个的匹配结尾字符串为查找互的第一个而不是最后一个

//应该不区分大小写

//要注意 C 语言的字符串是从 0 起始,而原来 delphi 的是从 1 起始的,所以 d7 转换过来的算法不能全部照搬的

lstring * get_value_first(lstring *s, lstring * b_sp, lstring * e_sp)

{

    //开始复制的位置

    int b_pos = ;

    //复制结束的位置

    int e_pos = ;

    lstring * ls;

    lstring * r = NULL;

    if (len(e_sp) == ) e_pos = length(s);

    ls = lowercase(s);

    b_sp = lowercase(b_sp);

    e_sp = lowercase(e_sp);

    //检查字符串指针是否合法,只是简单的方法,不可靠,但有一定作用

    CheckPString(ls);

    CheckPString(b_sp);

    CheckPString(e_sp);

    //--------------------------------------------------

    b_pos = pos(b_sp, ls);

    //if (length(b_sp) == 0) b_pos = 1;

    if (length(b_sp) == ) b_pos = ;

    //if (b_pos == 0)

    if (b_pos == -) //没找到

    {

        r = NewString("", s->pool);

        //autofree_pstring(s->pool, r); //返回的字符串跟着 s 一起释放

        return r;

    };

    b_pos = b_pos + length(b_sp);

    r = substring(s, b_pos, length(s));

    //result = copy(s, b_pos, length(s));

    //--------------------------------------------------

    //e_pos = pos(e_sp, lowercase(r)) - 1;

    e_pos = pos(e_sp, lowercase(r));

    if (e_pos == -) e_pos = length(r);

    //r = substring(r, 1, e_pos);

    r = substring(r, , e_pos);

    return r;

}

//c 语言的参数

lstring * getValueFirst_c(lstring *s, char * b_sp, char * e_sp)

{

    return get_value_first(s, NewString(b_sp, s->pool), NewString(e_sp, s->pool));

}

//c 语言的参数

lstring * get_value_first_c(lstring *s, char * b_sp, char * e_sp)

{

    return get_value_first(s, NewString(b_sp, s->pool), NewString(e_sp, s->pool));

}

#endif