static int __draw_poly ( lua_State *_l ) {
int nargs = lua_gettop(_l);
int i, num;
ex_vec2f_t *verts;
const ex_color4f_t *c;
bool close;
// check if the first arguments is table
luaL_checktype(_l, 1, LUA_TTABLE);
num = luaL_getn(_l,1);
verts = (ex_vec2f_t *)ex_malloc( sizeof(ex_vec2f_t) * num );
for ( i = 0; i < num; ++i ) {
lua_rawgeti(_l, 1, i+1);
verts[i] = *ex_lua_tovec2f(_l,-1);
lua_remove(_l, -1);
}
//
c = &ex_color4f_white;
close = true;
if ( nargs == 2 ) {
c = ex_lua_checkcolor4f(_l,2);
}
else if ( nargs == 3 ) {
c = ex_lua_checkcolor4f(_l,2);
close = lua_toboolean(_l,3);
}
//
ex_draw_poly ( verts, num, c, close );
ex_free( verts );
return 0;
}
int main (void) {
int i = 0;
void *buffer[BUF_SIZE];
ex_sdk_init ();
i = 0;
while ( i < BUF_SIZE ) {
buffer[i] = ex_malloc( EX_MB(1) );
++i;
}
i = 0;
while ( i < BUF_SIZE ) {
buffer[i] = ex_realloc( buffer[i], EX_KB(1) * rand() % 2048 );
++i;
}
i = 0;
while ( i < BUF_SIZE ) {
ex_free(buffer[i]);
++i;
}
ex_sdk_deinit ();
return 0;
}
static void normal () {
// strcpy
{
char to[128];
const char *text = "hello world";
// right
memset ( to, 1, 128 );
strcpy( to, text );
printf("for break");
}
// strncpy
{
char to[128];
const char *text = "hello world";
int len = strlen(text);
// wrong
memset ( to, 1, 128 );
strncpy( to, text, len );
// right
memset ( to, 1, 128 );
strncpy( to, text, len );
to[len] = 0;
printf("for break");
}
// strlen
{
char *to;
const char *text = "hello world";
int len = strlen(text);
// wrong
to = ex_malloc( len );
strcpy( to, text );
ex_free(to);
// right
to = ex_malloc( len+1 );
strcpy( to, text );
ex_free(to);
printf("for break");
}
}
ex_list_t *ex_list_alloc ( size_t _element_bytes ) {
ex_list_t *list = ex_malloc( sizeof(ex_list_t) );
ex_list_init ( list,
_element_bytes,
ex_func_alloc,
ex_func_realloc,
ex_func_dealloc );
return list;
}
static bt_node_t *__bt_node_alloc ()
{
bt_node_t *node = ex_malloc( sizeof(bt_node_t) );
node->children = ex_array_notype ( sizeof(bt_node_t *), 8 );
node->user_data = NULL;
node->exec = NULL;
node->free = NULL;
return node;
}
ex_mempool_t *ex_mempool_alloc ( size_t _element_bytes, size_t _count ) {
ex_mempool_t *pool = ex_malloc ( sizeof(ex_mempool_t) );
ex_mempool_init( pool, _element_bytes, _count,
ex_func_alloc,
ex_func_realloc,
ex_func_dealloc
);
return pool;
}
TEST( MemMng, leak, off )
{
const int MAX_COUNT = 2;
char* pTestBuffer = NULL;
for ( int i = 0; i < MAX_COUNT; ++i )
{
pTestBuffer = (char*)ex_malloc( sizeof(char) );
}
}
ex_bitarray_t *ex_bitarray_alloc ( size_t _bitcount )
{
ex_bitarray_t *bitArray = ex_malloc ( sizeof(ex_bitarray_t) );
ex_bitarray_init ( bitArray, _bitcount,
__ex_bitarray_alloc,
__ex_bitarray_realloc,
__ex_bitarray_dealloc );
return bitArray;
}
TEST( MemMng, alloc, off )
{
const int BUFFER_SIZE = 5;
const int MAX_COUNT = 256;
ClassProbe* pBuffer = ex_new_array( ClassProbe, BUFFER_SIZE );
for ( int i = 0; i < MAX_COUNT; ++i )
{
char* pTestBuffer = (char*)ex_malloc( sizeof(char)*BUFFER_SIZE );
ex_free(pTestBuffer);
}
ex_delete_array(pBuffer);
}
int amt_close(amt_sock_t **pSock)
{
int res;
ex_sock_t *pExSock = (ex_sock_t *) ex_malloc(sizeof(ex_sock_t));
AMT_ERR_CHECK(pExSock!=NULL, AMT_ERR, "No Memory");
*pExSock = **(ex_sock_t **)pSock;
free(*pSock);
*pSock=NULL;
res = ex_close(&pExSock);
if (res) { return res;}
return 0;
}
/* Löscht das erste Item vom Typ type aus dem Inventar von Spawn
* Returnt 1, wenn was gelöscht wurde, 0 sonst.
*/
int delete_item_by_type(unsigned int type, Spawn *spawn){
/* wenn noch mehr im Inventar ist */
if(spawn->inventory_size > 1) {
unsigned int new_size = spawn->inventory_size - 1, i, j;
bool update_selected=false, deleted=false;
Item** new_inventory = (Item**)ex_malloc(new_size * sizeof(Item*));
for(i = 0, j = 0; i < spawn->inventory_size; ++i) {
if(spawn->inventory[i]->type != type || deleted) {
new_inventory[j] = spawn->inventory[i];
++j;
} else {
free_item(spawn->inventory[i]);
deleted=true;
if(i<=spawn->selected_item)
update_selected=true;
}
}
free(spawn->inventory);
spawn->inventory = new_inventory;
if(deleted){
--spawn->inventory_size;
if(!spawn->npc && update_selected) {
/* ausgewähltes Item anpassen */
spawn->selected_item = (spawn->selected_item > 1) ? spawn->selected_item - 1 : 0;
}
return 1;
}
else
return 0;
}
/* nur letztes Element wird gelöscht */
else if(spawn->inventory_size == 1 && spawn->inventory[0]->type==type) {
free_item(spawn->inventory[0]);
free(spawn->inventory);
spawn->inventory = NULL;
--spawn->inventory_size;
if(!spawn->npc) {
spawn->selected_item = 0;
}
return 1;
}
else
return 0;
}
result_t BinarySerializeNode::loadFromBuffer ( void* _pData, uint _bufferSize )
{
// read raw data
m_Capacity = uint(_bufferSize);
m_CurPos = 0;
if ( m_Capacity > 0 )
{
m_pData = ex_malloc( m_Capacity );
ex::mem::cpy( m_pData, _pData, m_Capacity );
}
//
setLoading ();
return EResult::ok;
}
void XmlParser::OnCharacterData ( const tchar* _pData, int _len )
{
// get white space
const tchar* white_space_list;
uint list_count = 0;
ex::str::getWSList( white_space_list, list_count );
// skip empty content
bool validContent = false;
for ( int i = 0; i < _len; ++i )
{
if ( !str::isInTheList( _pData[i], white_space_list, list_count ) )
{
validContent = true;
break;
}
}
// retrun if invalid content ( empty content )
if ( !validContent )
return;
// TODO: implement temp string allocator
//
char* pMallocBuffer = NULL;
char* pStrBuffer = NULL;
char str[EX_INT16_MAX+1];
if ( _len < EX_INT16_MAX+1 )
{
pStrBuffer = str;
}
else
{
pStrBuffer = pMallocBuffer = (char*)ex_malloc( _len + 1 );
}
memcpy( pStrBuffer, _pData, _len );
pStrBuffer[_len] = 0;
// set contents
ex_assert( !m_NodeStack.empty(), "Invalid Node Stack" );
if ( !m_NodeStack.empty() )
{
m_NodeStack.top()->SetContent( pStrBuffer );
}
ex_free(pMallocBuffer);
}
// managed
ex_hashmap_t *ex_hashmap_alloc ( strid_t _key_typeid, size_t _key_bytes,
strid_t _value_typeid, size_t _value_bytes,
size_t _count,
hashkey_t _hashkey, keycmp_t _keycmp )
{
ex_hashmap_t *hashmap = ex_malloc( sizeof(ex_hashmap_t) );
ex_hashmap_init ( hashmap,
_key_typeid, _key_bytes,
_value_typeid, _value_bytes,
_count,
_hashkey, _keycmp,
__ex_hashmap_alloc,
__ex_hashmap_realloc,
__ex_hashmap_dealloc
);
return hashmap;
}
int ex_lua_dofile ( lua_State *_l, const char *_filepath, const char *_modname ) {
int status;
ex_file_t *file;
size_t buf_size;
void *buffer;
// open the file
file = ex_fopen_r(_filepath);
if ( file == NULL ) {
ex_error ( "can't find the file %s", _filepath );
return -1;
}
// get the file to the buffer we allocated.
buf_size = ex_fsize (file);
buffer = ex_malloc (buf_size);
ex_fread (file, buffer, buf_size );
ex_fclose(file);
// parse the buffer by lua interpreter
status = luaL_loadbuffer( _l, (const char *)buffer, buf_size, _filepath );
if ( status ) {
ex_lua_alert(_l);
goto PARSE_FAILED;
}
// call the script
if ( _modname ) {
lua_pushstring(_l,_modname);
status = lua_pcall(_l, 1, LUA_MULTRET, 0);
}
else {
status = lua_pcall(_l, 0, LUA_MULTRET, 0);
}
if ( status ) {
ex_lua_alert(_l);
goto PARSE_FAILED;
}
PARSE_FAILED:
ex_free(buffer);
return -1;
}
BinarySerializeNode::BinarySerializeNode ( uint _bytesToReserve, bool _isSaving )
: ISerializeNode ()
, m_pData (NULL)
, m_Capacity (0)
, m_CurPos (0)
{
//
if ( _isSaving )
setSaving ();
else
setLoading ();
//
if ( _bytesToReserve >= 0 )
{
m_pData = ex_malloc ( _bytesToReserve );
m_Capacity = _bytesToReserve;
m_CurPos = 0;
}
}
void wiz_create_window ( lua_State *_l, int _refID, int _w, int _h ) {
SDL_Window *sdl_window;
SDL_Renderer *sdl_renderer;
__window_info_t *win_info;
// create SDL window
sdl_window = SDL_CreateWindow( "Window",
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
_w, _h,
SDL_WINDOW_RESIZABLE | SDL_WINDOW_SHOWN /*| SDL_WINDOW_BORDERLESS*/
);
if ( !sdl_window ) {
ex_log ( "[SDL] Error: Could not create window: %s", SDL_GetError() );
return;
}
// create SDL renderer
sdl_renderer = SDL_CreateRenderer( sdl_window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC );
if ( !sdl_renderer ) {
ex_log ( "[SDL] Error: Could not create renderer: %s", SDL_GetError() );
return;
}
// add window info
win_info = ex_malloc( sizeof(__window_info_t) );
win_info->sdl_window = sdl_window;
win_info->sdl_renderer = sdl_renderer;
win_info->refID = _refID;
win_info->dirty = true;
ex_color3u_set ( &win_info->bg_color, 255, 255, 255 );
// if this is the first window, create queue
if ( ex_array_count(__window_list) == 0 ) {
primary_win_info = win_info;
ex_set_main_sdl_renderer(sdl_renderer);
}
ex_array_add ( __window_list, &win_info );
}
/*---------------------------------------------------------------------------*/
void delete_item(Item *item, Spawn *spawn) {
/* wenn noch mehr im Inventar ist */
if(spawn->inventory_size > 1) {
unsigned int new_size = spawn->inventory_size - 1, i, j;
Item** new_inventory = (Item**)ex_malloc(new_size * sizeof(Item*));
for(i = 0, j = 0; i < spawn->inventory_size; ++i) {
if(spawn->inventory[i] != item) {
new_inventory[j] = spawn->inventory[i];
++j;
} else {
free_item(spawn->inventory[i]);
}
}
--spawn->inventory_size;
free(spawn->inventory);
spawn->inventory = new_inventory;
if(!spawn->npc) {
/* ausgewähltes Item anpassen */
spawn->selected_item = (spawn->selected_item > 1) ? spawn->selected_item - 1 : 0;
}
}
/* nur letztes Element wird gelöscht */
else if(spawn->inventory_size == 1) {
free_item(spawn->inventory[0]);
free(spawn->inventory);
spawn->inventory = NULL;
--spawn->inventory_size;
if(!spawn->npc) {
spawn->selected_item = 0;
}
}
}
int main(int argc, char *argv[]){
Spawn *player;
InterfaceData idata = {0, NULL, -1, NULL, 1};
SDL_Event event;
int num_tiles = OUTPUT_IN_GLYPHS_X * OUTPUT_IN_GLYPHS_Y, i;
/*SDL anmachen*/
if(SDL_Init(SDL_INIT_VIDEO))
return EXIT_FAILURE;
SDL_EnableKeyRepeat(200, 50);
/*Karte laden*/
if(argc==2)
map=load_map(argv[1]);
else{
fprintf(stderr,"Kartennamen angeben\n");
return EXIT_FAILURE;
}
if(map == NULL) {
fprintf(stderr,"Fehler beim Laden der Karte\n");
return EXIT_FAILURE;
}
player = get_player_spawn(map);
if(player==NULL){
fprintf(stderr, "Kein Spieler auf der Karte\n");
return EXIT_FAILURE;
}
/*Map zeichnen*/
/* Ausgabepuffer initialisieren */
buf = (BufferTile*)ex_malloc(sizeof(BufferTile) * num_tiles);
for(i = 0; i < num_tiles; ++i) {
BufferTile bt = {' ', 0x00000000};
buf[i] = bt;
}
output_init(OUTPUT_IN_GLYPHS_X, OUTPUT_IN_GLYPHS_Y, map->name);
explore_area(player, map);
create_output_buffer(map, buf, num_tiles);
get_interface_data(map, &idata);
output_draw(buf, num_tiles, &idata);
/*Eingabeloop*/
int quit=0;
KeyAction current_action = INVALID;
while(SDL_WaitEvent(&event)){
if(event.type == SDL_KEYDOWN) {
current_action = get_action(event.key.keysym.sym);
/*bei Escape beenden*/
if(event.key.keysym.sym == SDLK_ESCAPE){
quit=1;
break;
}
if(current_action != INVALID) {
process_event(current_action, map);
}
create_output_buffer(map, buf, num_tiles);
get_interface_data(map, &idata);
output_draw(buf, num_tiles, &idata);
} else if(event.type == SDL_QUIT) {
quit=1;
break;
}
SDL_Delay(1);
/*Affe tot => Klappe zu*/
if(player->hp<=0){
game_over(0);
break;
}
/* Ende erreicht */
if(map->finished) {
game_over(1);
break;
}
}
if(!quit){
while(SDL_WaitEvent(&event)){
/*bei Escape beenden*/
if(event.type == SDL_QUIT || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE)) {
break;
}
SDL_Delay(1);
}
}
free(buf);
flush_map(map);
free(idata.message); free(idata.item_name);
output_close();
SDL_Quit();
return EXIT_SUCCESS;
}
static int __lua_font_wrap_text ( lua_State *_l ) {
ex_font_t *font;
const char *text, *whitespace;
int maxWidth;
const char *str, *nextstr, *word_start;
char *newtext, *newtext_p, *last_newtext;
int ch, next_ch, len, newlen, cpylen;
uint ft_index, prev_ft_index;
int cur_x, word_start_x;
ex_glyph_t *glyph;
bool linebreak, beginningOfLine, trimWhitespace, skipcpy;
bool wrapword, collapseSpace, collapseLinebreak;
// get lua arguments
ex_lua_check_nargs(_l,5);
text = luaL_checkstring(_l,1);
luaL_checktype( _l, 2, LUA_TLIGHTUSERDATA );
font = lua_touserdata(_l,2);
whitespace = luaL_checkstring(_l,3);
maxWidth = luaL_checkint(_l,4);
trimWhitespace = beginningOfLine = (luaL_checkint(_l,5) == 1);
//
len = strlen(text);
str = nextstr = word_start = text;
newtext_p = newtext = last_newtext = ex_malloc( len * sizeof(char) );
prev_ft_index = -1;
// get wrapMode
wrapword = false;
collapseSpace = collapseLinebreak = false;
if ( !strncmp( whitespace, "pre-wrap", 8 ) ) {
wrapword = true;
collapseSpace = false;
collapseLinebreak = false;
}
else if ( !strncmp( whitespace, "pre-line", 8 ) ) {
wrapword = true;
collapseSpace = true;
collapseLinebreak = false;
}
else if ( !strncmp( whitespace, "normal", 6 ) ) {
wrapword = true;
collapseSpace = true;
collapseLinebreak = true;
}
else if ( !strncmp( whitespace, "nowrap", 6 ) ) {
wrapword = false;
collapseSpace = true;
collapseLinebreak = true;
}
else if ( !strncmp( whitespace, "pre", 3 ) ) {
wrapword = false;
collapseSpace = false;
collapseLinebreak = false;
}
// process text
cur_x = word_start_x = 0;
linebreak = false;
while ( *str ) {
skipcpy = false;
nextstr += utf8proc_iterate ((const uint8_t *)str, -1, &ch);
// if this is line-break
if ( ch == '\n' || ch == '\r' ) {
if ( collapseLinebreak ) {
ch = ' '; // turn it to space
}
else {
linebreak = true;
}
}
// if this is space
if ( ch == ' ' || ch == '\t' || ch == '\f' ) {
if ( collapseSpace ) {
const char * nextnextstr = nextstr;
while ( *nextnextstr ) {
nextstr = nextnextstr;
nextnextstr += utf8proc_iterate ((const uint8_t *)nextnextstr, -1, &next_ch);
// if next_ch is white-space, then collapse this char
if ( next_ch == ' ' || next_ch == '\t' || next_ch == '\f' ) {
str = nextstr;
continue;
}
// if next_ch is line-break and collapseLinebreak is true, then collapse this char
if ( next_ch == '\n' || next_ch == '\r' ) {
if ( collapseLinebreak ) {
str = nextstr;
continue;
}
}
//
break;
}
// skip first-time collapse
if ( trimWhitespace ) {
trimWhitespace = false;
str = nextstr;
continue;
}
// yes, must turn it to space to make sure only one space
ch = ' ';
}
}
//
trimWhitespace = false;
// process word-break, word-wrap
if ( wrapword ) {
word_start = str;
word_start_x = cur_x;
// if this character can break
if ( nextstr == NULL || __can_word_break (ch) ) {
// advanced character
ft_index = ex_font_get_index ( font, ch );
glyph = ex_font_get_glyph ( font, ft_index );
cur_x += ex_font_get_kerning( font, prev_ft_index, ft_index );
cur_x += glyph->advance_x;
prev_ft_index = ft_index;
// check if the word exceed content width
if ( cur_x > maxWidth ) {
if ( !beginningOfLine ) {
linebreak = true;
// skip copy the white-space if it is at the end of the wrap
if ( ch == ' ' || ch == '\t' || ch == '\f' ) {
skipcpy = true;
}
else {
nextstr = word_start;
cur_x = word_start_x;
}
}
}
beginningOfLine = false;
}
else {
// advanced current character
ft_index = ex_font_get_index ( font, ch );
glyph = ex_font_get_glyph ( font, ft_index );
cur_x += ex_font_get_kerning( font, prev_ft_index, ft_index );
cur_x += glyph->advance_x;
prev_ft_index = ft_index;
const char * nextnextstr = nextstr;
while ( *nextnextstr ) {
nextstr = nextnextstr;
nextnextstr += utf8proc_iterate ((const uint8_t *)nextnextstr, -1, &next_ch);
// if this character can break
if ( __can_word_break (next_ch) ) {
break;
}
// advanced character
ft_index = ex_font_get_index ( font, next_ch );
glyph = ex_font_get_glyph ( font, ft_index );
cur_x += ex_font_get_kerning( font, prev_ft_index, ft_index );
cur_x += glyph->advance_x;
prev_ft_index = ft_index;
// TODO: process word-break
// check if the word exceed content width
if ( cur_x > maxWidth ) {
if ( !beginningOfLine ) {
linebreak = true;
nextstr = word_start;
cur_x = word_start_x;
skipcpy = true;
break;
}
}
}
}
}
else {
// advanced character
ft_index = ex_font_get_index ( font, ch );
glyph = ex_font_get_glyph ( font, ft_index );
cur_x += ex_font_get_kerning( font, prev_ft_index, ft_index );
cur_x += glyph->advance_x;
prev_ft_index = ft_index;
}
// copy character to newtext_p
if ( !skipcpy ) {
cpylen = nextstr - str;
if ( cpylen > 0 ) {
strncpy( newtext_p, str, cpylen);
newtext_p += cpylen;
}
}
// step
str = nextstr;
if ( linebreak ) {
break;
}
}
// text1
newlen = newtext_p-newtext;
if ( newlen > 0 ) {
lua_pushlstring(_l, newtext, newlen);
}
else {
lua_pushnil(_l);
}
// text2
if ( linebreak && *str ) {
lua_pushstring(_l, str );
}
else {
lua_pushnil(_l);
}
lua_pushinteger(_l,cur_x); // width
lua_pushboolean(_l,linebreak); // line-break
//
ex_free(newtext);
return 4; // text1(can be nil), text2(can be nil), width of text1, linebreak
}
