Example #1
0
s_string String_insert(char* word)
{
    s_string s_temp;
    s_temp.input = mem_alloc(sizeof(char)*String_length(word),id_string);
    memcpy(s_temp.input,word,sizeof(char)*String_length(word));
    s_temp.length = String_length(s_temp.input);
    s_temp.size = s_temp.length;
    return s_temp;
}
Example #2
0
String File_appendFileNameBuffer(String fileName, const char *buffer, ulong bufferLength)
{
  assert(fileName != NULL);

  if (String_length(fileName) > 0)
  {
    if (String_index(fileName,String_length(fileName)-1) != FILES_PATHNAME_SEPARATOR_CHAR)
    {
      String_appendChar(fileName,FILES_PATHNAME_SEPARATOR_CHAR);
    }
  }
  String_appendBuffer(fileName,buffer,bufferLength);

  return fileName;
}
Example #3
0
String File_appendFileNameChar(String fileName, char ch)
{
  assert(fileName != NULL);

  if (String_length(fileName) > 0)
  {
    if (String_index(fileName,String_length(fileName)-1) != FILES_PATHNAME_SEPARATOR_CHAR)
    {
      String_appendChar(fileName,FILES_PATHNAME_SEPARATOR_CHAR);
    }
  }
  String_appendChar(fileName,ch);

  return fileName;
}
Example #4
0
s_string Input()
{
    s_string s_input;
    int32_t c;
    char* i_temp_ptr;
    int32_t i_buffer = 64;
    int32_t i = 0;
    i_temp_ptr = mem_alloc(sizeof(char)*i_buffer,id_string);
    printf("input fce! ---------------- \n");
    while((c = getchar()) != '\n')
    {
        if( i == i_buffer - 2)
        {
            i_buffer*=2;
            i_temp_ptr = mem_realloc(i_temp_ptr,sizeof(char)*i_buffer);
        }
        i_temp_ptr[i] = (char)c;
        i++;
		i_temp_ptr[i] = '\0';
    }

    s_input.input = i_temp_ptr;

    s_input.length = String_length(s_input.input);
    s_input.size = i_buffer;

    return s_input;
}
Example #5
0
ulong chunks_getSize(const void *data, int definition[])
{
  int   z;
  ulong size;

  assert(data != NULL);
  assert(definition != NULL);

  size = 0;
  for (z = 0; definition[z] != 0; z++)
  {
    switch (definition[z])
    {
      case CHUNK_DATATYPE_UINT8:
      case CHUNK_DATATYPE_INT8:
        size += 1;
        data = ((char*)data) + 4;
        break;
      case CHUNK_DATATYPE_UINT16:
      case CHUNK_DATATYPE_INT16:
        size += 2;
        data = ((char*)data) + 4;
        break;
      case CHUNK_DATATYPE_UINT32:
      case CHUNK_DATATYPE_INT32:
        size += 4;
        data = ((char*)data) + 4;
        break;
      case CHUNK_DATATYPE_UINT64:
      case CHUNK_DATATYPE_INT64:
        size += 8;
        data = ((char*)data) + 8;
        break;
      case CHUNK_DATATYPE_NAME:
        {
          String s;

          s = (*((String*)data));
          assert(s != NULL);
          size += 2 + String_length(s);
//pointer size???
          data = ((char*)data) + 4;
        }
        break;
      case CHUNK_DATATYPE_DATA:
        break;
      default:
        HALT_INTERAL_ERROR_UNHANDLED_SWITCH_CASE();
        break;
    }
  }

  return size;
}
Example #6
0
int main() {
	String s1 = String_new("abcd");
	String s2 = String_new("xyz");
	String s3 = String_concat(s1, s2);
	String_free(s1);
	String s4 = String_copy(s2);
	String_free(s2);
	char *c1 = String_toCharArray(s3);
	char *c2 = String_toCharArray(s4);
	if (String_length(s3) > String_length(s4))
		printf("%s is longer than %s\n", c1, c2);
	else
		printf("%s is longer than %s\n", c2, c1);

	if (String_compare(s3, s4) > 0)
		printf("%s is greater than %s\n", c1, c2);
	else if (String_compare(s3, s4) < 0)
		printf("%s is greater than %s\n", c2, c1);
	else
		printf("%s and %s are the same\n", c2, c1);
}
Example #7
0
static void Lua_Init()
{
    log_info("Loading IO streams");
	char *Path = malloc(sizeof(char) * (String_length(Executable_Path) - String_length(Project_Name) + String_length("Input.txt")));
	memcpy(Path, Executable_Path, sizeof(char) * (String_length(Executable_Path) - String_length(Project_Name)));
	Path[String_length(Executable_Path) - String_length(Project_Name)] = '\0';

	String_Add(Path, "Log.txt");
	Log = fopen(Path, "w+");

	String_Remove(Path, "Log.txt");
	String_Add(Path, "Input.txt");

	Input = fopen(Path, "rb");
	if(!Input)
	{
		Input = fopen(Path, "w");
		fclose(Input);
		Input = fopen(Path, "rb");
	}

    log_info("Loading Lua");
    Lua_State = luaL_newstate(Log, Input);   /* opens Lua */

    luaL_openlibs(Lua_State);

    log_info("Loading Andrua's libs");
    LuaLibrary_Load(Log);
    log_info("Finished Loading in Lua");

    Lua_requestClose = false;
}
Example #8
0
LOCAL bool readProcessIO(int fd, String line)
{
  #if   defined(PLATFORM_LINUX)
    int    n;
  #elif defined(PLATFORM_WINDOWS)
    u_long n;
  #endif /* PLATFORM_... */
  char ch;

  do
  {
    // check if data available
    #if   defined(PLATFORM_LINUX)
      ioctl(fd,FIONREAD,&n);
    #elif defined(PLATFORM_WINDOWS)
// NYI ???
#warning not implemented
    #endif /* PLATFORM_... */


    // read data until EOL found
    while (n > 0)
    {
      if (read(fd,&ch,1) == 1)
      {
        switch (ch)
        {
          case '\n':
          case '\r':
          case '\b':
            if (String_length(line) > 0L) return TRUE;
            break;
          default:
            String_appendChar(line,ch);
            break;
        }
        n--;
      }
      else
      {
        n = 0;
      }
    }
  }
  while (n > 0);

  return FALSE;
}
Example #9
0
Errors File_printLine(FileHandle *fileHandle,
                      const char *format,
                      ...
                     )
{
  String  line;
  va_list arguments;
  Errors  error;

  assert(fileHandle != NULL);
  assert(fileHandle->file != NULL);
  assert(format != NULL);

  /* initialise variables */
  line = String_new();

  /* format line */
  va_start(arguments,format);
  String_vformat(line,format,arguments);
  va_end(arguments);

  /* write line */
  error = File_write(fileHandle,String_cString(line),String_length(line));
  if (error != ERROR_NONE)
  {
    String_delete(line);
    return error;
  }
  error = File_write(fileHandle,"\n",1);
  if (error != ERROR_NONE)
  {
    String_delete(line);
    return error;
  }

  /* free resources */
  String_delete(line);

  return ERROR_NONE;
}
Example #10
0
void Password_setString(Password *password, const String string)
{
  uint length;
  #ifdef HAVE_GCRYPT
  #else /* not HAVE_GCRYPT */
    uint z;
  #endif /* HAVE_GCRYPT */

  assert(password != NULL);

  length = MIN(String_length(string),MAX_PASSWORD_LENGTH);
  #ifdef HAVE_GCRYPT
    memcpy(password->data,String_cString(string),length);
  #else /* not HAVE_GCRYPT */
    for (z = 0; z < length; z++)
    {
      password->data[z] = String_index(string,z)^obfuscator[z];
    }
  #endif /* HAVE_GCRYPT */
  password->data[length] = '\0';
  password->length = length;
}
Example #11
0
LOCAL bool readProcessIO(int fd, String line)
{
  int  n;
  char ch;

  do
  {
    // check if data available
    ioctl(fd,FIONREAD,&n);

    // read data until EOL found
    while (n > 0)
    {
      if (read(fd,&ch,1) == 1)
      {
        switch (ch)
        {
          case '\n':
          case '\r':
          case '\b':
            if (String_length(line) > 0L) return TRUE;
            break;
          default:
            String_appendChar(line,ch);
            break;
        }
        n--;
      }
      else
      {
        n = 0;
      }
    }
  }
  while (n > 0);

  return FALSE;
}
Example #12
0
Errors File_writeLine(FileHandle   *fileHandle,
                      const String line
                     )
{
  Errors error;

  assert(fileHandle != NULL);
  assert(fileHandle->file != NULL);
  assert(line != NULL);

  error = File_write(fileHandle,String_cString(line),String_length(line));
  if (error != ERROR_NONE)
  {
    return error;
  }
  error = File_write(fileHandle,"\n",1);
  if (error != ERROR_NONE)
  {
    return error;
  }

  return ERROR_NONE;
}
Example #13
0
void Terminal_printString(const String s)
{
    for (u32 i = 0; i < String_length(s); i++)
        Terminal_printChar(s[i]);
}
Example #14
0
int main(int argc, const char *argv[])
 {
  Definition  definition;
  Definition  definitions[MAX_DEFINITIONS];
  uint        definitionCount;
  int         z;
  struct stat statBuffer;
  uint64      size;
  const char  *inputFileName;
  FILE        *inputHandle;
  uint        deleteCount;
  byte        data;
  uint64      n;

  /* parse command line */
  CmdOption_init(COMMAND_LINE_OPTIONS,SIZE_OF_ARRAY(COMMAND_LINE_OPTIONS));
  if (!CmdOption_parse(argv,&argc,
                       COMMAND_LINE_OPTIONS,SIZE_OF_ARRAY(COMMAND_LINE_OPTIONS),
                       CMD_PRIORITY_ANY,
                       stderr,NULL
                      )
     )
  {
    return 1;
  }
  if (versionFlag)
  {
    printf("Destroyer version %s\n",VERSION);
    return 0;
  }
  if (helpFlag)
  {
    printUsage(argv[0]);
    return 0;
  }
  if (argc <= 1)
  {
    fprintf(stderr,"ERROR: No input file given!\n");
    exit(1);
  }
  inputFileName = argv[1];

  /* get file size */
  if (stat(inputFileName,&statBuffer) != 0)
  {
    fprintf(stderr,"ERROR: Cannot detect size of file '%s' (error: %s)\n",
            inputFileName,
            strerror(errno)
           );
    exit(1);
  }
  size = statBuffer.st_size;

  /* parse definitions */
  initRandom(size);
  definitionCount = 0;
  for (z = 2; z < argc; z++)
  {
    if (!parseDefinition(argv[z],&definition,size))
    {
      exit(1);
    }
    if (definitionCount >= MAX_DEFINITIONS)
    {
      fprintf(stderr,"ERROR: to many definitions! Max. %d possible.\n",MAX_DEFINITIONS);
    }
    definitions[definitionCount] = definition;
    definitionCount++;
  }

  /* open input file */
  inputHandle = fopen(inputFileName,"r");
  if (inputHandle == NULL)
  {
    fprintf(stderr,"ERROR: Cannot open file '%s' (error: %s)\n",
            inputFileName,
            strerror(errno)
           );
    exit(1);
  }

  /* destroy and write to stdout */
  deleteCount = 0;
  for (n = 0; n < size; n++)
  {
    /* read byte */
    data = fgetc(inputHandle);

    if (deleteCount == 0)
    {
      /* find matching definition */
      z = 0;
      while ((z < definitionCount) && (n != definitions[z].position))
      {
        z++;
      }

      /* output byte */
      if (z < definitionCount)
      {
        switch (definitions[z].type)
        {
          case DEFINITION_TYPE_MODIFY:
          case DEFINITION_TYPE_RANDOMIZE:
            fwrite(String_cString(definitions[z].value),1,String_length(definitions[z].value),stdout);
            deleteCount = String_length(definitions[z].value)-1;
            break;
          case DEFINITION_TYPE_INSERT:
            fwrite(String_cString(definitions[z].value),1,String_length(definitions[z].value),stdout);
            fputc(data,stdout);
            break;
          case DEFINITION_TYPE_DELETE:
            deleteCount = definitions[z].length-1;
            break;
        }
      }
      else
      {
        fputc(data,stdout);
      }
    }
    else
    {
      deleteCount--;
    }
  }

  /* close files */
  fclose(inputHandle);

  /* free resources */
  CmdOption_done(COMMAND_LINE_OPTIONS,SIZE_OF_ARRAY(COMMAND_LINE_OPTIONS));

  return 0;
 }
Example #15
0
void Util_Init(struct Window *Window,
		void (*error_cb)(int error, const char* description),
		void (*keyboard_cb)(GLFWwindow *window, int key, int scancode,
				int action, int mods),
		void (*character_cb)(GLFWwindow* window, unsigned int codepoint),
		void (*mouse_pos_cb)(GLFWwindow *window, double x, double y),
		void (*mouse_button_cb)(GLFWwindow *Window, int button, int action,
				int mods),
		void (*mouse_scroll_cb)(GLFWwindow *Window, double x, double y))
{
	log_info("Initializing Util library");
	Mouse.x = 0;
	Mouse.y = 0;
	Mouse.justReleased = Mouse.isPressed = Mouse.justPressed =
			Mouse.isLongedPressed = false;
	Mouse.isSuper_longPress = Mouse.justSuper_longReleased = false;
	Mouse.justQuickPressed = false;
	Mouse.pressedCooldown = 0;
	Mouse.Faked_Input = false;
	Game_FPS = 0;
	Frame_Time_Passed = 0;

	Keyboard.justPressed = Keyboard.justReleased = Keyboard.justTyped = false;

	glfwSetErrorCallback(error_cb);
	glfwSetKeyCallback(Window->Window, keyboard_cb);
	glfwSetCharCallback(Window->Window, character_cb);
	glfwSetCursorPosCallback(Window->Window, mouse_pos_cb);
	glfwSetMouseButtonCallback(Window->Window, mouse_button_cb);
	glfwSetScrollCallback(Window->Window, mouse_scroll_cb);

	log_info("Done setting up GLFW");

#ifdef _WIN32
	char Path[101];
	int PathLength = 100;
	GetModuleFileName(NULL, &Path[0], PathLength);
	Path[100] = '\0';

	int Length = String_length(&Path[0]) - EXECUTABLE_NAME - 4;

#ifndef DEBUG
	Executable_Path = malloc(sizeof(char) * (Length + 1));
	for(int Index = 0; Index < Length; Index++)
	Executable_Path[Index] = Path[Index];
	Executable_Path[Length] = '\0';
#else // DEBUG
#ifndef CODE_BLOCKS
	Length -= 6;
	Executable_Path = malloc(sizeof(char) * (Length + 1));
	for (int Index = 0; Index < Length; Index++)
	Executable_Path[Index] = Path[Index];
	Executable_Path[Length] = '\0';
#else
	Length -= 10;
	Executable_Path = malloc(sizeof(char) * (Length + 1));
	for (int Index = 0; Index < Length; Index++)
	Executable_Path[Index] = Path[Index];
	Executable_Path[Length] = '\0';
    printf("%s\n", Executable_Path);
#endif
#endif
#else
	char Path[101] =
	{ ' ' };
	int PathLength = 100;
	readlink("/proc/self/exe", &Path[0], PathLength * sizeof(char));
	Path[PathLength] = '\0';
	int Length = String_length(&Path[0]) - EXECUTABLE_NAME;
#ifndef DEBUG
	Executable_Path = malloc(sizeof(char) * (Length + 1));
	for(int Index = 0; Index < Length; Index++)
	Executable_Path[Index] = Path[Index];
	Executable_Path[Length] = '\0';
#else
	Length -= 6;
	Executable_Path = malloc(sizeof(char) * (Length + 1));
	for (int Index = 0; Index < Length; Index++)
		Executable_Path[Index] = Path[Index];
	Executable_Path[Length] = '\0';
#endif
#endif

	Asset_Path = malloc(sizeof(char) * (String_length(Executable_Path) + String_length("Assets/") + 1));
	Asset_Path = memcpy(Asset_Path, Executable_Path, sizeof(char) * (String_length(Executable_Path)));
	memcpy(Asset_Path + String_length(Executable_Path), "Assets/", sizeof(char) * (String_length("Assets/") + 1));

	log_info("Done initializing path");

	DefaultFontManager = NULL;
	DefaultFontManager = Font_Init();
	check_mem(DefaultFontManager);

	HighDefaultFont = Font_Add(DefaultFontManager,
			"Font/Cousine-Regular.ttf", 50);
	check(HighDefaultFont >= 0, "Couldn't load default font : %s",
			"Font/Cousine-Regular.ttf");

	log_info("Done loading high definition font");

	LowDefaultFont = Font_Add(DefaultFontManager,
			"Font/Cousine-Regular.ttf", 25);
	check(LowDefaultFont >= 0, "Couldn't load default font : %s",
			"Font/Cousine-Regular.ttf");

	log_info("Done loading low definition font");

	Font_Use(DefaultFontManager, HighDefaultFont);

	ImageEngine_SetUp();
	Renderer_SetUp();

	gettimeofday(&Frame_TimePassed, NULL);

	log_info("Done initializing util library");

	return;
	error: Application_Error(); return;
}
Example #16
0
void Serial_printString(const String s)
{
    for (u32 i = 0; i < String_length(s); i++)
        Serial_printChar(s[i]);
}
Example #17
0
Errors File_makeDirectory(const String pathName,
                          uint32       userId,
                          uint32       groupId,
                          uint32       permission
                         )
{
  mode_t          currentCreationMask;
  StringTokenizer pathNameTokenizer;
  String          directoryName;
  uid_t           uid;
  gid_t           gid;
  Errors          error;
  String          name;

  assert(pathName != NULL);

  /* get current umask */
  currentCreationMask = umask(0);
  umask(currentCreationMask);

  /* create directory including parent directories */
  directoryName = File_newFileName();
  File_initSplitFileName(&pathNameTokenizer,pathName);
  if (File_getNextSplitFileName(&pathNameTokenizer,&name))
  {
    if (String_length(name) > 0)
    {
      File_setFileName(directoryName,name);
    }
    else
    {
      File_setFileNameChar(directoryName,FILES_PATHNAME_SEPARATOR_CHAR);
    }
  }
  if (!File_exists(directoryName))
  {
    if (mkdir(String_cString(directoryName),0777 & ~currentCreationMask) != 0)
    {
      error = ERRORX(IO_ERROR,errno,String_cString(directoryName));
      File_doneSplitFileName(&pathNameTokenizer);
      File_deleteFileName(directoryName);
      return error;
    }
    if (   (userId  != FILE_DEFAULT_USER_ID)
        || (groupId != FILE_DEFAULT_GROUP_ID)
       )
    {
      uid = (userId  != FILE_DEFAULT_USER_ID ) ? (uid_t)userId  : -1;
      gid = (groupId != FILE_DEFAULT_GROUP_ID) ? (gid_t)groupId : -1;
      if (chown(String_cString(directoryName),uid,gid) != 0)
      {
        error = ERRORX(IO_ERROR,errno,String_cString(directoryName));
        File_doneSplitFileName(&pathNameTokenizer);
        File_deleteFileName(directoryName);
        return error;
      }
    }
    if (permission != FILE_DEFAULT_PERMISSION)
    {
      if (chmod(String_cString(directoryName),(permission|S_IXUSR|S_IXGRP|S_IXOTH) & ~currentCreationMask) != 0)
      {
        error = ERROR(IO_ERROR,errno);
        File_doneSplitFileName(&pathNameTokenizer);
        File_deleteFileName(directoryName);
        return error;
      }
    }
  }
  while (File_getNextSplitFileName(&pathNameTokenizer,&name))
  {
    if (String_length(name) > 0)
    {     
      File_appendFileName(directoryName,name);

      if (!File_exists(directoryName))
      {
        if (mkdir(String_cString(directoryName),0777 & ~currentCreationMask) != 0)
        {
          error = ERRORX(IO_ERROR,errno,String_cString(directoryName));
          File_doneSplitFileName(&pathNameTokenizer);
          File_deleteFileName(directoryName);
          return error;
        }
        if (   (userId  != FILE_DEFAULT_USER_ID)
            || (groupId != FILE_DEFAULT_GROUP_ID)
           )
        {
          uid = (userId  != FILE_DEFAULT_USER_ID ) ? (uid_t)userId  : -1;
          gid = (groupId != FILE_DEFAULT_GROUP_ID) ? (gid_t)groupId : -1;
          if (chown(String_cString(directoryName),uid,gid) != 0)
          {
            error = ERRORX(IO_ERROR,errno,String_cString(directoryName));
            File_doneSplitFileName(&pathNameTokenizer);
            File_deleteFileName(directoryName);
            return error;
          }
        }
        if (permission != FILE_DEFAULT_PERMISSION)
        {
          if (chmod(String_cString(directoryName),(permission|S_IXUSR|S_IXGRP|S_IXOTH) & ~currentCreationMask) != 0)
          {
            error = ERRORX(IO_ERROR,errno,String_cString(directoryName));
            File_doneSplitFileName(&pathNameTokenizer);
            File_deleteFileName(directoryName);
            return error;
          }
        }
      }
    }
  }
  File_doneSplitFileName(&pathNameTokenizer);
  File_deleteFileName(directoryName);

  return ERROR_NONE;
}
Example #18
0
void Terminal_putString(const String s, u8 x, u8 y)
{
    for (u32 i = 0; i < String_length(s); i++, x++)
        Terminal_putChar(s[i], x, y);
}
Example #19
0
bool chunks_write(ChunkInfoBlock *chunkInfoBlock, const void *data, int definition[])
{
  int z;

  assert(chunkInfoBlock != NULL);
  assert(data != NULL);
  assert(definition != NULL);

  for (z = 0; definition[z] != 0; z++)
  {
    switch (definition[z])
    {
      case CHUNK_DATATYPE_UINT8:
      case CHUNK_DATATYPE_INT8:
        {
          uint8 n;

          n = (*((uint8*)data));
          if (!chunkInfoBlock->writeFile(chunkInfoBlock->userData,&n,1))
          {
            return FALSE;
          }
          chunkInfoBlock->size  += 1;
          chunkInfoBlock->index += 1;
          data = ((char*)data) + 4;
        }
        break;
      case CHUNK_DATATYPE_UINT16:
      case CHUNK_DATATYPE_INT16:
        {
          uint16 n;

          n = htons(*((uint16*)data));
          if (!chunkInfoBlock->writeFile(chunkInfoBlock->userData,&n,2))
          {
            return FALSE;
          }
          chunkInfoBlock->size  += 2;
          chunkInfoBlock->index += 2;
          data = ((char*)data) + 4;
        }
        break;
      case CHUNK_DATATYPE_UINT32:
      case CHUNK_DATATYPE_INT32:
        {
          uint32 n;

          n = htonl(*((uint32*)data));
          if (!chunkInfoBlock->writeFile(chunkInfoBlock->userData,&n,4))
          {
            return FALSE;
          }
          chunkInfoBlock->size  += 4;
          chunkInfoBlock->index += 4;
          data = ((char*)data) + 4;
        }
        break;
      case CHUNK_DATATYPE_UINT64:
      case CHUNK_DATATYPE_INT64:
        {
          uint64 n;
          uint32 l[2];

          n = (*((uint64*)data));
          l[0] = htonl((n & 0xFFFFffff00000000LL) >> 32);
          l[1] = htonl((n & 0x00000000FFFFffffLL) >>  0);
          if (!chunkInfoBlock->writeFile(chunkInfoBlock->userData,l,8))
          {
            return FALSE;
          }
          chunkInfoBlock->size  += 8;
          chunkInfoBlock->index += 8;
          data = ((char*)data) + 8;
        }
        break;
      case CHUNK_DATATYPE_NAME:
        {
          String s;
          ulong  length;
          uint16 n;

          s = (*((String*)data));
          assert(s != NULL);
          length = String_length(s);
          n = htons(length);
          if (!chunkInfoBlock->writeFile(chunkInfoBlock->userData,&n,2))
          {
            return FALSE;
          }
          if (!chunkInfoBlock->writeFile(chunkInfoBlock->userData,String_cString(s),length))
          {
            return FALSE;
          }
          chunkInfoBlock->size  += 2+length;
          chunkInfoBlock->index += 2+length;
//pointer size???
          data = ((char*)data) + 4;
        }
        break;
      case CHUNK_DATATYPE_DATA:
        break;
      default:
        HALT_INTERAL_ERROR_UNHANDLED_SWITCH_CASE();
        break;
    }
  }

  return TRUE;
}