🚀 go-pugleaf

tutaj jest sam kod (podkreslam ze to kod na brudno - prototypy do testow, idea jest dobra ale forme mozna by poprawic, choc nie wiem czy akurat teraz wykrzesam z siebie checi by to poprawiac, chyba akurat wlasnie nie teraz) 

/*
    small-icl.c

    some routines for text prosessing based
    on chunk idea (it is also based on relocable
    internal pools here)

    version of 27.xi.2016

    (it is early version, some things need to be
    throwed out some added, most revritten but
    it in general works and is usable and quite 
    lot can be done with this easily)



*/



#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <sys/stat.h>
#include <string.h>


void ERROR_EXIT(char *format, ...)
{
  // put your error reporting routine here


    va_list args;
    va_start(args, format);
     vprintf(format, args);
    va_end(args);

    exit(-1);


}


typedef struct
 {
   char* beg;
   char* end;
 }   chunk;

typedef struct
  {
  chunk* first;
  chunk* last;
  }   chunks;


inline chunk Chunk(char* str)
{

  int len = strlen(str);
  chunk c = {str, str+len-1};

  return c;
}


inline int ChunkIsEmpty(chunk c)
{

  if(c.beg==NULL || c.end==NULL || c.beg>c.end)
  {
     c.beg   = NULL;
     c.end   = NULL;
     return 1;
  }

  return 0;
}

inline void AssertChunkValidity(chunk text, char* file, int line)
{
   if(text.beg==NULL)     ERROR_EXIT("text.beg==NULL %s %d", file, line);
   if(text.end==NULL)     ERROR_EXIT("text.end==NULL %s %d", file, line);
   if(text.beg>text.end)  ERROR_EXIT("text.beg>text.end %s %d", file, line);

}

// chunk Chunk2(char* a, char* b)
// {
//   chunk c = {a,b};
//
//   if(a==NULL || b==NULL || a>b) c = { NULL,  NULL };
//
//   return c;
// }

inline int ChunkLength(chunk a)
{
  int len = a.end - a.beg + 1;
  if(len<0) ERROR_EXIT("chunk length < 0");
  return len;
}


 int GetFileSize1(FILE* file)
 {
  int seek_pos = ftell(file);
  int error = fseek(file, 0, SEEK_END);

     if(error) ERROR_EXIT("seek1 error");

  int file_length = ftell(file) ;
  error = fseek(file, seek_pos, SEEK_SET);

     if(error) ERROR_EXIT("seek2 error");

  return file_length;
 }


 int GetFileSize2(char *filename)
 {
    struct stat st;

    if (stat(filename, &st) == 0)
        return (int) st.st_size;

      ERROR_EXIT("error obtaining file size for &s", filename);

    return -1;
}



chunk LoadChunk(char* file_name)
{
  static char* internal_text = NULL;

  FILE * file = fopen(file_name, "rb");

    if(file == NULL) ERROR_EXIT( " cannot open file %s  ", file_name);

  int file_length = GetFileSize1(file);

  internal_text = (char*)realloc(internal_text, file_length + 10);

    if(internal_text == NULL) ERROR_EXIT(" cannot mallock data for file %s ",  file_name);

  int readed =  fread(internal_text, 1, file_length, file);

  int error = fclose(file);

    if(error) ERROR_EXIT("\n cannot close file %s", file_name);

  chunk text = {internal_text, internal_text + file_length - 1};
  return text;

}


void CreateFile(char* filename)
{
  FILE* file = fopen (filename, "wb");

  if(file == NULL) ERROR_EXIT( " cannot open file %s  ", filename);

//  fwrite (ch.beg , 1, ChunkLength(ch), file);

  fclose (file);

}

void SaveChunk(chunk ch, char* filename)
{
  if(ChunkIsEmpty(ch)) return;

  FILE* file = fopen (filename, "wb");

  if(file == NULL) ERROR_EXIT( " cannot open file %s  ", filename);

  fwrite (ch.beg , 1, ChunkLength(ch), file);

  fclose (file);

}

void SaveChunkTextMode(chunk ch, char* filename)
{
  if(ChunkIsEmpty(ch)) return;

  FILE* file = fopen (filename, "wt");

  if(file == NULL) ERROR_EXIT( " cannot open file %s  ", filename);

  fwrite (ch.beg , 1, ChunkLength(ch), file);

  fclose (file);

}

void AppendChunk(chunk ch, char* filename)
{
  if(ChunkIsEmpty(ch)) return;

  FILE* file = fopen (filename, "ab");

    if(file == NULL) ERROR_EXIT( " cannot open file %s  ", filename);

  fwrite (ch.beg , 1, ChunkLength(ch), file);

  fclose (file);

}

// void WriteNewTextChunk(chunk ch, char* filename)
// {
//   FILE* file = fopen (filename, "wt");
//
//     if(file == NULL) ERROR_EXIT( " cannot open file %s  ", filename);
//
//   fwrite (ch.beg , 1, ChunkLength(ch), file);
//
//   fclose (file);
//
// }

void AppendChunkTextMode(chunk ch, char* filename)
{
  FILE* file = fopen (filename, "at");

    if(file == NULL) ERROR_EXIT( " cannot open file %s  ", filename);

  fwrite (ch.beg , 1, ChunkLength(ch), file);

  fclose (file);

}


int PrintChunk(chunk ch)
{
  if(ch.beg == NULL || ch.end == NULL || ch.beg > ch.end )
  {
    printf(" chunk is NULL ");
    return 0;
  }

  int len = ChunkLength(ch);
  printf("%.*s", len, ch);
  return len;
}


int PrintChunkNL(chunk ch)
{
  if(ch.beg == NULL || ch.end == NULL || ch.beg > ch.end )
  {
    printf(" chunk is NULL ");
    return 0;
  }

   int len = ChunkLength(ch);

   if(len<=0) ERROR_EXIT("len<=0 in print line");

   printf("\n%.*s", len, ch);
   return len;

}

int PrintChunkInHex(chunk ch)
{
  //todo
}


chunk ReallocChunk(chunk c, int new_size)
{
     c.beg = (char*) realloc(c.beg, new_size );
     if(c.beg==NULL) ERROR_EXIT("cant realloc chunk");
     c.end = c.beg + new_size - 1;

     return c;

}

chunk PrintfToChunk( char *format, ... )
{



    static chunk ch;

    static int current_ram_size = 1024;

    static int initialised = 0;
    if(!initialised)
    {
      ch = ReallocChunk(ch, current_ram_size);
      initialised = 1;
    }



    va_list args;
    va_start(args, format);

    int len = 0;

    for(;;)
    {

      len = vsnprintf(ch.beg, current_ram_size, format, args);
//      int vasprintf(char **ret, const char *format, va_list ap);
//      char *tab;  vasprintf(&tab,  format, args);

      if( len < current_ram_size )
      {
           ch.end = ch.beg + len - 1;
           break;
      }
      else
      {
            current_ram_size *=2;
            ch = ReallocChunk(ch,  current_ram_size );
//           printf("growing to %d", current_ram_size );
      }


    }

      va_end(args);


      return ch;

}
//////////

inline char* Find1stChar_ByPredicate(chunk text, int (*IsWordCharacter)(char ch))
{
   AssertChunkValidity(text, __FILE__, __LINE__);

   for(char* s=text.beg; s<=text.end; s++)
     if(IsWordCharacter(*s))
      return s;

   return NULL;
}

inline char* Find1stNotChar_ByPredicate(chunk text, int (*IsWordCharacter)(char ch))
{
   AssertChunkValidity(text, __FILE__, __LINE__);

   for(char* s=text.beg; s<=text.end; s++)
     if(!IsWordCharacter(*s))
       return s;

   return NULL;
}

inline chunk Find1stWord_ByPredicate(chunk text, int (*BelongingPredicate)(char ch))
{

   chunk found = {0};

   if(text.beg>text.end) return found;

   found.beg = Find1stChar_ByPredicate(text, BelongingPredicate);

   if(found.beg==NULL) return found;
   if(found.beg==text.end) { found.end=found.beg; return found; }

   text.beg = found.beg + 1;

   char* char_after_word  =  Find1stNotChar_ByPredicate(text, BelongingPredicate);
   if(char_after_word==NULL) {
     found.end = text.end; return found;   }

   found.end = char_after_word -1;

  return found;

}

inline int  PreCountNumberOfWords_ByPredicate(chunk text, int (*BelongingPredicate)(char ch))
{
  int counter = 0;

  chunk where = text;

  for(;;)
  {
   chunk found = Find1stWord_ByPredicate( where, BelongingPredicate);
   if(found.beg == NULL) break;

   counter ++;

   where.beg = found.end +1;
   if(where.beg>where.end) break;
  }

  return counter;

}

/////////

int IsDigit(char c)
{
  if(c>='0' && c<='9') return 1;
  else return 0;
}

int IsLetter(char c)
{
  if(c>='a' && c<='z') return 1;
  if(c>='A' && c<='Z') return 1;

  return 0;

}

int IsHexDigit(char c)
{
  if(IsDigit(c)) return 1;
  if(c>='a' && c<='f') return 1;
  if(c>='A' && c<='F') return 1;
  else return 0;
}


int IsNewline(char c)
{
  if(c==0xd || c==0xa) return 1;

  return 0;
}

int IsWhiteSpace(char c)
{
  if(c == 0x20 ||
     c == 0x09 ||
     c == 0x0a ||
     c == 0x0b ||
     c == 0x0c ||
     c == 0x0d ) return 1;

  return 0;

}

int IsInvisible(char c)
{
  if(c>0 && c<32 && ! IsWhiteSpace(c)) return 1;

  return 0;
}

int IsPunctuation(char c)
{
  if( !IsDigit(c) && !IsLetter(c)
   && !IsWhiteSpace(c) && !IsInvisible(c))
 return 1;

 return 0;

}
////////

int max(int a, int b)
{
  if(a>=b) return a;
  return b;
}

chunks FindAllWordsByPredicate(chunk text, int (*BelongingPredicate)(char ch))
{


  chunks results = {0};


  static chunk* internal_ram_chunks = NULL;
  static int internal_ram_length = 0;
  const  int down_limit_for_internal_ram_chunks = 64*1024;

  if(internal_ram_chunks == NULL)// || internal_ram_length > down_limit_for_internal_ram_chunks) //preallok pool
  {
   internal_ram_length = down_limit_for_internal_ram_chunks;
   internal_ram_chunks = (chunk*) realloc(internal_ram_chunks, internal_ram_length );
  }


  chunk where = text;

  int i;
  int n = internal_ram_length / sizeof(chunk);

//  for(i=0;i< down_limit_for_internal_ram_chunks/sizeof(chunk); i++)
  for(i=0;i< n; i++)
  {

   internal_ram_chunks[i] = Find1stWord_ByPredicate( where, BelongingPredicate);
   if(internal_ram_chunks[0].beg == NULL) return results; //none found


   if( (! internal_ram_chunks[i].beg) || (! internal_ram_chunks[i].end) || (internal_ram_chunks[i].beg > internal_ram_chunks[i].end) )
   {

    //down allock
     if(  ( i*sizeof(chunk)    < internal_ram_length ) &&
          ( internal_ram_length > down_limit_for_internal_ram_chunks) )
          {
            internal_ram_length = max(i*sizeof(chunk), down_limit_for_internal_ram_chunks);
            internal_ram_chunks = (chunk*) realloc(internal_ram_chunks, internal_ram_length );
         //   printf("\nresize");
          }

//     printf("\n internal pool length %d chunks \n", internal_ram_length/sizeof(chunk));

     return results  =  { internal_ram_chunks,  internal_ram_chunks + i - 1 };
   }

   where.beg = internal_ram_chunks[i].end + 1;

  }


  //not enough  prealocked ram
  // resize too needed length

  int how_many_yet = PreCountNumberOfWords_ByPredicate(where, BelongingPredicate);
  if(how_many_yet==0) return  results  =  { internal_ram_chunks,  internal_ram_chunks + i - 1 };

  // up allock

  internal_ram_length += how_many_yet * sizeof(chunk);
  internal_ram_chunks = (chunk*) realloc(internal_ram_chunks, internal_ram_length );
//  printf("\nupsize");


  for(int j=i; j<i+how_many_yet; j++)
  {
   internal_ram_chunks[j] = Find1stWord_ByPredicate( where, BelongingPredicate);
   where.beg = internal_ram_chunks[j].end + 1;
  }
//  printf("\n internal pool length %d chunks \n", internal_ram_length/sizeof(chunk));

  return results  =  { internal_ram_chunks,  internal_ram_chunks + i + how_many_yet - 1 };


}

int WordsBelongingStdPredicate(char ch)
{
   if(IsWhiteSpace(ch)) return 0;
   return 1;


//     if(ch>='a' && ch<='z') return 1;
//     if(ch>='A' && ch<='Z') return 1;
//     if(ch>='0' && ch<='9') return 1;
//     return 0;
}

chunks SplitAllStdWords(chunk text)
{
 chunks s = FindAllWordsByPredicate(text, WordsBelongingStdPredicate );
 return s;
}
//////////////


chunk TrimEdgeWhitespaces(chunk text)
{
   chunk out = text;

   for(char* c=text.beg; c<=text.end; c++)
      if( ! IsWhiteSpace(*c)) { out.beg = c; break;}

   for(char* c=text.end; c>=text.beg; c--)
      if( ! IsWhiteSpace(*c)) { out.end = c; break; }

   return out;

}



 void SkipCharsTillNumber(char** p)
 {
   for(;;)
   {
     if( **p==0 ) break;
     if(IsDigit(**p)) break;

     if((**p)=='-' && IsDigit( *((*p)+1) ) ) break;

   //  printf("\n skipped char: %c", **p);

     (*p)++;
   }

 }


 int DigInt(char**p, int* value)
 {

   for(;;)
   {

     SkipCharsTillNumber(p);
     if(**p==0) break;

     char* s = *p;
     *value = strtol(s, p, 10);

     if (errno)  ERROR_EXIT("\n*** ERROR: Out Of range conversion in DigInt routine at '%.*s' ***", *p-s, s );

     return 1;
   }

   return 0;
 }



chunk FindFirstEmbeddedIntegerChunk(chunk text)
{
  chunk word = {NULL, NULL};

  for(char* i = text.beg; i <= text.end; i++)
  {
   if( IsDigit( *i ) )
   {
          word.beg = i;
          break;
   }
  }


  if(word.beg==NULL) return word;


  for(char* i = word.beg; i <= text.end; i++)
  {
   if( !IsDigit( *i ) )
   {
     word.end = i - 1;

     if(word.beg[-1]=='-' && word.beg-1>=text.beg)
        word.beg--;
     return word;
   }
  }
     word.end = text.end;

     if(word.beg[-1]=='-' && word.beg-1>=text.beg)
        word.beg--;

     return word;

}

int IsPureIntegerChunk(chunk word)
{
    for(char* c=word.beg; c<=word.end; c++)
    {
      if(c==word.beg && (*c=='-')) continue;
      if( ! IsDigit(*c)) return 0;
    }

    if(ChunkLength(word)==1 && word.beg[0]=='-') return 0;

    return 1;
}

int IsPureHexChunk(chunk word)
{
    for(char* c=word.beg; c<=word.end; c++)
    {
       if( ! IsHexDigit(*c)) return 0;
    }

    return 1;

}



long ConvertChunk2Int(chunk word)
{
  static char buf[100];

  int len = word.end - word.beg +  1;

  for(int i=0; i<len; i++)
     buf[i] = word.beg[i];

  buf[len] = 0;

//  int i =  atoi(buf);
  long i =  atol(buf);

  return i;

}



//////////

int ChunksLength(chunks s)
{
//  alert("L");

  if(s.first == NULL || s.last == NULL || s.first > s.last) return 0;

  return s.last - s.first + 1;
}


void SaveChunks(chunks cs, char*filename)
{
  FILE* file = fopen (filename, "wb");
    if(file == NULL) ERROR_EXIT( " cannot open file %s  ", filename);

  for(chunk* s = cs.first; s<=cs.last; s++)
  {
    if(ChunkIsEmpty(*s)) continue;

    fwrite ((*s).beg , 1, ChunkLength(*s), file);
  }

  fclose (file);

}

void PrintChunks(chunks s)
{
  printf("\n");

  int i = 0;

  for(chunk* line = s.first; line<=s.last; line++)
  {
    if(line==NULL) continue;
    printf("\n %d '%.*s'", i++, ChunkLength(*line), *line);


  }

}

 int CountNumberOfSplitChunks(chunk text, char split_character)
{
  int counter = 1;

   for(char* c = text.beg; c <= text.end; c++ )
    if(*c == split_character) counter++;

  return counter;
}


//    splits text into chunks ( not tested for edge cases )
//      array of chunks is reallocked and maneged internally
chunks SplitAfterCharacter(chunk text, char split_character)
{

  int split_chunks_count = CountNumberOfSplitChunks(text, split_character);

  //realloc internal ram to fit
  static chunk* internal_ram_chunks = NULL;
  int internal_ram_length = split_chunks_count * sizeof(chunk);
  internal_ram_chunks = (chunk*) realloc(internal_ram_chunks, internal_ram_length );

  // now internal_ram_chunks is an array of N chunks
  // we will fill it


  int current_chunk_length = 0;
  int current_chunk_number = 0;

  internal_ram_chunks[current_chunk_number].beg = text.beg; //open first


  for(char* c = text.beg; c <= text.end; c++ )
  {

    current_chunk_length++;

    if(*c == split_character) //end chunk
    {
        internal_ram_chunks[current_chunk_number].end = c;


       if(c+1<=text.end)  // open next
       {
        current_chunk_length = 0;
        current_chunk_number ++;

        internal_ram_chunks[current_chunk_number].beg = c + 1;
       }

      }

  }


  internal_ram_chunks[current_chunk_number].end = text.end; //finish last

//  if(split_chunks_count != current_chunk_number + 1) ERROR_("something wrong");

  //send output
  chunks splited = {internal_ram_chunks, internal_ram_chunks + current_chunk_number} ;
  return splited;

}

//////////////



int Compare(chunk a, chunk b)
{
  char* c = a.beg;
  char* d = b.beg;

  if(c==NULL || d==NULL) return 0;

  while( c <= a.end && d <= b.end )
  {
    if((*c) < (*d) ) return -1;
    if((*c) > (*d) ) return +1;

    c++;
    d++;
  }
  if(ChunkLength(a) < ChunkLength(b)) return -1;
  if(ChunkLength(a) > ChunkLength(b)) return +1;
  return 0;
}


void Quicksort(chunks a)
{
  int lo = 0;
  int hi = a.last - a.first ;

 // alert("%d", hi);

    int i = lo;
    int j = hi;

    while (i < hi) {
//    while (i <= hi) {

        chunk pivot =  a.first[(lo+hi)/2];
        // Partition
        while (i <= j)
        {
            while ( Compare(a.first[i], pivot) < 0 )
            {
                i = i + 1;
            }
            while (Compare( a.first[j], pivot) > 0)
            {
                j = j - 1;
            }
            if (i <= j)
            {
                chunk t  = a.first[i];
                a.first[i] = a.first[j];
                a.first[j] = t;
                i = i + 1;
                j = j - 1;
            }
        }

        // Recursion for quicksort
        if (lo < j)
        {
            chunks x = { a.first + lo, a.first + j };

            Quicksort(x);
        }
        lo = i;
        j = hi;
    }
}

void NullRepeatingChunks(chunks s)
{
  for(chunk* l = s.first; l<=s.last; l++)
  {
     if((*l).beg==NULL) continue;

     for(chunk* k = l + 1; k<=s.last; k++)
     {
       if(Compare(*l, *k)==0)
       {
        (*k).beg = NULL;

         continue;
       }

       break;

     }

  }

}


// 919 lines of source

wyglad kodu (postac, forma) jest tutaj drugorzędny w stosunku do idei (ktora jest 'przednia' jak dla mnie)

nad forma tak naprawde (jak i nad szczegolami kodu) nie rozmyslalem zbytnio - (nie majac czasu testujac prototypy) ale jak ktos ma jakies rzeczowe uwagi konstruktywne to moze i chetnie przeczytam

z ewidentnych beldow ktore rzucaja mi sie w oczy to np nazwy Compare i Quicksort (powinno byc oczywiscie CompareChunks i Quicksortchunks), bledow formy ktore mozna by tu wymienic jest zapewne duzo wiecej ale jak mowie nie mialem czasu na takie detale (a i dzis ciegle nie chce mi sie nad tym przysiąść)

W dniu poniedziałek, 7 sierpnia 2017 19:27:50 UTC+2 użytkownik (fir) napisał:
> wyglad kodu (postac, forma) jest tutaj drugorzędny w stosunku do idei (ktora jest 'przednia' jak dla mnie)
> 
> nad forma tak naprawde (jak i nad szczegolami kodu) nie rozmyslalem zbytnio - (nie majac czasu testujac prototypy) ale jak ktos ma jakies rzeczowe uwagi konstruktywne to moze i chetnie przeczytam
> 
> z ewidentnych beldow ktore rzucaja mi sie w oczy to np nazwy Compare i Quicksort (powinno byc oczywiscie CompareChunks i Quicksortchunks), bledow formy ktore mozna by tu wymienic jest zapewne duzo wiecej ale jak mowie nie mialem czasu na takie detale (a i dzis ciegle nie chce mi sie nad tym przysiąść)

ew mozna zastanowic sie jakie operacje na plikach tekstowych/teklstach w ramie moglyby byc uzyteczne a ja moglbym sie zastanowic jakby to wygladalo w implementacji 

jak widac takie operacje jak wczytanie pliku tekstowego posortowanie lini dodanie czegos do nich i zapisanie na dysk wykonuje sie tutaj latwo - kilkoma linijkami kosu, prostu bez zadnych wyrazen regularnych i tego typu badziewia 9mimoze biblioteczka jest mala 1000 linijek c)

mozna by sie jednak zastanowic co jeszcze powinna miec by miala szeroki generalny aspekt praktycznej uzytecznosci 

W dniu poniedziałek, 7 sierpnia 2017 20:17:39 UTC+2 użytkownik (fir) napisał:
> W dniu poniedziałek, 7 sierpnia 2017 19:27:50 UTC+2 użytkownik (fir) napisał:
> > wyglad kodu (postac, forma) jest tutaj drugorzędny w stosunku do idei (ktora jest 'przednia' jak dla mnie)
> > 
> > nad forma tak naprawde (jak i nad szczegolami kodu) nie rozmyslalem zbytnio - (nie majac czasu testujac prototypy) ale jak ktos ma jakies rzeczowe uwagi konstruktywne to moze i chetnie przeczytam
> > 
> > z ewidentnych beldow ktore rzucaja mi sie w oczy to np nazwy Compare i Quicksort (powinno byc oczywiscie CompareChunks i Quicksortchunks), bledow formy ktore mozna by tu wymienic jest zapewne duzo wiecej ale jak mowie nie mialem czasu na takie detale (a i dzis ciegle nie chce mi sie nad tym przysiąść)
> 
> ew mozna zastanowic sie jakie operacje na plikach tekstowych/teklstach w ramie moglyby byc uzyteczne a ja moglbym sie zastanowic jakby to wygladalo w implementacji 
> 
> jak widac takie operacje jak wczytanie pliku tekstowego posortowanie lini dodanie czegos do nich i zapisanie na dysk wykonuje sie tutaj latwo - kilkoma linijkami kosu, prostu bez zadnych wyrazen regularnych i tego typu badziewia 9mimoze biblioteczka jest mala 1000 linijek c)

nie wiem, co jest badziewnego w wyrażeniach regularnych.
Twoich kilka linijek w C to z grubsza jedna linijka w perlu albo awk.

myślę też, że zrobiłbyś wielką przysługę wszystkim czytającym Twój kod,
zakładając sobie konto na githubie.

funkcję IsWhiteSpace powinieneś raczej zdefiniować używając literałów
znakowych, zamiast kodów ASCII, np. c == ' ' || c == '\t' itd.
(pomijając kwestię, że prawdopodobnie już jest zdefiniowana np.
w <ctype.h>)

szczerze mówiąc, osobiście wolę korzystać z gotowych i ogólnych
rozwiązań, niż wynajdywać koło na nowo

On Mon, 7 Aug 2017 14:14:25 -0700 (PDT), godek.maciek@gmail.com wrote:
> rozwiązań, niż wynajdywać koło na nowo

Czasem fajnie jest wynaleźć coś na nowo, np. nowy dowód tw. 
Pitagorasa. 

Ad rem. 

1. Nazwy są mało systematyczne: zamiast SortChunk,  CopyChunk lepiej 
jest dać ChunkSort, ChunkCopy itd. Dlaczego? Łatwiej znaleźć co 
trzeba i nie tylko.

2. Oddzielić interfejs od implementacji. Czyli definicje częściowe 
struktur i takie tam.

3. I tak cała rzecz zredukuje się do klasy Chunk.

4. A nazwa jakoś kojarzy się z sick.

5. Doxygen rulez. Sprawdź dlaczego. 


Tyle z grubsza. Bo nie wynikałem.

On Mon, 7 Aug 2017 14:14:25 -0700 (PDT), godek.maciek@gmail.com wrote:
> rozwiązań, niż wynajdywać koło na nowo

A jeszcze pikuś: encoding.

On Monday, August 7, 2017 at 11:14:27 PM UTC+2, godek....@gmail.com wrote:

> szczerze mówiąc, osobiście wolę korzystać z gotowych i ogólnych
> rozwiązań, niż wynajdywać koło na nowo

Pewnie, kto nie woli? Każdy by chciał ogólnego i zarazem wydajnego
gotowca, ale ogólne często właśnie nie spełniają wymagań wydajnościowych, albo
wbrew pozorom nie są takie ogólne za jakie uchodzą - i trzeba zakodzić.

Pozdrawiam

W dniu poniedziałek, 7 sierpnia 2017 23:14:27 UTC+2 użytkownik godek....@gmail.com napisał:
> W dniu poniedziałek, 7 sierpnia 2017 20:17:39 UTC+2 użytkownik (fir) napisał:
> > W dniu poniedziałek, 7 sierpnia 2017 19:27:50 UTC+2 użytkownik (fir) napisał:
> > > wyglad kodu (postac, forma) jest tutaj drugorzędny w stosunku do idei (ktora jest 'przednia' jak dla mnie)
> > > 
> > > nad forma tak naprawde (jak i nad szczegolami kodu) nie rozmyslalem zbytnio - (nie majac czasu testujac prototypy) ale jak ktos ma jakies rzeczowe uwagi konstruktywne to moze i chetnie przeczytam
> > > 
> > > z ewidentnych beldow ktore rzucaja mi sie w oczy to np nazwy Compare i Quicksort (powinno byc oczywiscie CompareChunks i Quicksortchunks), bledow formy ktore mozna by tu wymienic jest zapewne duzo wiecej ale jak mowie nie mialem czasu na takie detale (a i dzis ciegle nie chce mi sie nad tym przysiąść)
> > 
> > ew mozna zastanowic sie jakie operacje na plikach tekstowych/teklstach w ramie moglyby byc uzyteczne a ja moglbym sie zastanowic jakby to wygladalo w implementacji 
> > 
> > jak widac takie operacje jak wczytanie pliku tekstowego posortowanie lini dodanie czegos do nich i zapisanie na dysk wykonuje sie tutaj latwo - kilkoma linijkami kosu, prostu bez zadnych wyrazen regularnych i tego typu badziewia 9mimoze biblioteczka jest mala 1000 linijek c)
> 
> nie wiem, co jest badziewnego w wyrażeniach regularnych.
> Twoich kilka linijek w C to z grubsza jedna linijka w perlu albo awk.
> 

moze nie wiesz ale z mojego punktu widzenia to twoj problem nie moj ;c

jutro mozemy porownac jak wyglada np przerobianie plikow tekstowych przy 
pomocy tej mojej biblioteczki (ew lekko poprawionej bo che ja udoskonalic ) i tych skryptow o ktorch mowisz (a ktorych ja nigdy nie pisalem) - to moze byc ciekawe, ale dzis juz ide spac

mozesz pomyslec np jak wygladalyby jakies proste do wymyslanie zadania, np

1) posortowanie lini w pliku i zapisanie posortowanego
2) policzenie slow
3) posortowanie slow
4) wyszukanie jakichs slow i ich podmienienie
5) ponumerowanie lini i wstawienie tych numerow z lewej strony

itd itd


> myślę też, że zrobiłbyś wielką przysługę wszystkim czytającym Twój kod,
> zakładając sobie konto na githubie.
> 
> funkcję IsWhiteSpace powinieneś raczej zdefiniować używając literałów
> znakowych, zamiast kodów ASCII, np. c == ' ' || c == '\t' itd.
> (pomijając kwestię, że prawdopodobnie już jest zdefiniowana np.
> w <ctype.h>)
> 
> szczerze mówiąc, osobiście wolę korzystać z gotowych i ogólnych
> rozwiązań, niż wynajdywać koło na nowo

to jest nieistotna kurat napisalem to bo czasem wole unikac zewnetrznych zaleznosci jesli mozna to krotko napisac - ale to jest nieistotne i nie chcialbym raczej o tym dyskutowac i tracic na to czas

On Tuesday, August 8, 2017 at 12:48:20 AM UTC+2, (fir) wrote:
> W dniu poniedziałek, 7 sierpnia 2017 23:14:27 UTC+2 użytkownik godek....@gmail.com napisał:
> > W dniu poniedziałek, 7 sierpnia 2017 20:17:39 UTC+2 użytkownik (fir) napisał:
> > > W dniu poniedziałek, 7 sierpnia 2017 19:27:50 UTC+2 użytkownik (fir) napisał:
> > > > wyglad kodu (postac, forma) jest tutaj drugorzędny w stosunku do idei (ktora jest 'przednia' jak dla mnie)
> > > > 
> > > > nad forma tak naprawde (jak i nad szczegolami kodu) nie rozmyslalem zbytnio - (nie majac czasu testujac prototypy) ale jak ktos ma jakies rzeczowe uwagi konstruktywne to moze i chetnie przeczytam
> > > > 
> > > > z ewidentnych beldow ktore rzucaja mi sie w oczy to np nazwy Compare i Quicksort (powinno byc oczywiscie CompareChunks i Quicksortchunks), bledow formy ktore mozna by tu wymienic jest zapewne duzo wiecej ale jak mowie nie mialem czasu na takie detale (a i dzis ciegle nie chce mi sie nad tym przysiąść)
> > > 
> > > ew mozna zastanowic sie jakie operacje na plikach tekstowych/teklstach w ramie moglyby byc uzyteczne a ja moglbym sie zastanowic jakby to wygladalo w implementacji 
> > > 
> > > jak widac takie operacje jak wczytanie pliku tekstowego posortowanie lini dodanie czegos do nich i zapisanie na dysk wykonuje sie tutaj latwo - kilkoma linijkami kosu, prostu bez zadnych wyrazen regularnych i tego typu badziewia 9mimoze biblioteczka jest mala 1000 linijek c)
> > 
> > nie wiem, co jest badziewnego w wyrażeniach regularnych.
> > Twoich kilka linijek w C to z grubsza jedna linijka w perlu albo awk.
> > 
> 
> moze nie wiesz ale z mojego punktu widzenia to twoj problem nie moj ;c
> 
> jutro mozemy porownac jak wyglada np przerobianie plikow tekstowych przy 
> pomocy tej mojej biblioteczki (ew lekko poprawionej bo che ja udoskonalic ) i tych skryptow o ktorch mowisz (a ktorych ja nigdy nie pisalem) - to moze byc ciekawe, ale dzis juz ide spac
> 
> mozesz pomyslec np jak wygladalyby jakies proste do wymyslanie zadania, np
> 
> 1) posortowanie lini w pliku i zapisanie posortowanego
> 2) policzenie slow
> 3) posortowanie slow
> 4) wyszukanie jakichs slow i ich podmienienie
> 5) ponumerowanie lini i wstawienie tych numerow z lewej strony

Rozmowa nie ma sensu gdy to zadanie jest wyrwane z kontekstu. 

Gdy trzeba zrobić to tak po prostu to używa się właśnie
programów narzędziowych typu awk, grep, wc, sort, sed, czasami
łączy się te polecenia w jakimś glue-language.

Pozdrawiam

W dniu wtorek, 8 sierpnia 2017 00:41:27 UTC+2 użytkownik M.M. napisał:
> On Monday, August 7, 2017 at 11:14:27 PM UTC+2, godek....@gmail.com wrote:
> 
> > szczerze mówiąc, osobiście wolę korzystać z gotowych i ogólnych
> > rozwiązań, niż wynajdywać koło na nowo
> 
> Pewnie, kto nie woli? Każdy by chciał ogólnego i zarazem wydajnego
> gotowca, ale ogólne często właśnie nie spełniają wymagań wydajnościowych, albo
> wbrew pozorom nie są takie ogólne za jakie uchodzą - i trzeba zakodzić.
> 
> Pozdrawiam

z tego co wiem jesli w ktos stawia jakies zadanie typu, dajmy na to

"policz i wypisz na ekran linie z pliku notatki.txt ktore sa dluzsze niz 75 znakow"

to zwykle e c robi sie to ręcznie (czyli 'rzezbi' na poziomie petli ifow tablic i znakow itd

moja biblioteczka dostarcza mz dosyc odkrywczej generalizacji ktorej mozna tu 
uzyc - latwo i szynko

konkretnie byloby to

int main()
{
 chunk text = LoadChunk("notatki.txt");
  //wczytuje plik do ramu

 chunks lines = SplitChunkOnLines(text); 

  // dzieli na linie i zwraca tablice lini 
  // (w postaci bar {poczatek, koniec lini})

 int n = ChunksLength(lines);

 int long_lines_counter = 0;

 for(int i=0; i<n; i++)
 {
    int line_length = ChunkLength(lines.first[i]);
    
    if(line_length>75)
    {
      PrintfChunk(lines.first[i]);
      
      long_lines_counter++; 
    }
    
 }
 printf("\n number of  long lines: %d", long_lines_counter);

 return long_lines_counter;
}

uwagi
I. logiczne, przyjemne, proste a byc moze calkiem odkrywcze (ze wzgledu na idee chunk/chunks) [moge wyjasnic dokladniej jak to dziala ale raczej jutro bo ide spac]

II. nie znam za duzo rzeczy w c tego typu (nie znam wcale ale moje doswiadczenie jest ograniczone)

III. dla mnie lepsze niz wyrazenia regularne

IV. nie jestem pewien jak to sie ma do wersji na kontenerach w c++ javaskrypcie czy pythonie ale raczej nie wypada calkiem zle, 
prawdopodobnie jest z grubsza na rowni a dla koderow w c moze miec dodatkowe zalety bo rozumieja co jest under the hood bo to jest kod w c (dosyc krotki)

W dniu wtorek, 8 sierpnia 2017 00:55:35 UTC+2 użytkownik M.M. napisał:
> On Tuesday, August 8, 2017 at 12:48:20 AM UTC+2, (fir) wrote:
> > W dniu poniedziałek, 7 sierpnia 2017 23:14:27 UTC+2 użytkownik godek....@gmail.com napisał:
> > > W dniu poniedziałek, 7 sierpnia 2017 20:17:39 UTC+2 użytkownik (fir) napisał:
> > > > W dniu poniedziałek, 7 sierpnia 2017 19:27:50 UTC+2 użytkownik (fir) napisał:
> > > > > wyglad kodu (postac, forma) jest tutaj drugorzędny w stosunku do idei (ktora jest 'przednia' jak dla mnie)
> > > > > 
> > > > > nad forma tak naprawde (jak i nad szczegolami kodu) nie rozmyslalem zbytnio - (nie majac czasu testujac prototypy) ale jak ktos ma jakies rzeczowe uwagi konstruktywne to moze i chetnie przeczytam
> > > > > 
> > > > > z ewidentnych beldow ktore rzucaja mi sie w oczy to np nazwy Compare i Quicksort (powinno byc oczywiscie CompareChunks i Quicksortchunks), bledow formy ktore mozna by tu wymienic jest zapewne duzo wiecej ale jak mowie nie mialem czasu na takie detale (a i dzis ciegle nie chce mi sie nad tym przysiąść)
> > > > 
> > > > ew mozna zastanowic sie jakie operacje na plikach tekstowych/teklstach w ramie moglyby byc uzyteczne a ja moglbym sie zastanowic jakby to wygladalo w implementacji 
> > > > 
> > > > jak widac takie operacje jak wczytanie pliku tekstowego posortowanie lini dodanie czegos do nich i zapisanie na dysk wykonuje sie tutaj latwo - kilkoma linijkami kosu, prostu bez zadnych wyrazen regularnych i tego typu badziewia 9mimoze biblioteczka jest mala 1000 linijek c)
> > > 
> > > nie wiem, co jest badziewnego w wyrażeniach regularnych.
> > > Twoich kilka linijek w C to z grubsza jedna linijka w perlu albo awk.
> > > 
> > 
> > moze nie wiesz ale z mojego punktu widzenia to twoj problem nie moj ;c
> > 
> > jutro mozemy porownac jak wyglada np przerobianie plikow tekstowych przy 
> > pomocy tej mojej biblioteczki (ew lekko poprawionej bo che ja udoskonalic ) i tych skryptow o ktorch mowisz (a ktorych ja nigdy nie pisalem) - to moze byc ciekawe, ale dzis juz ide spac
> > 
> > mozesz pomyslec np jak wygladalyby jakies proste do wymyslanie zadania, np
> > 
> > 1) posortowanie lini w pliku i zapisanie posortowanego
> > 2) policzenie slow
> > 3) posortowanie slow
> > 4) wyszukanie jakichs slow i ich podmienienie
> > 5) ponumerowanie lini i wstawienie tych numerow z lewej strony
> 
> Rozmowa nie ma sensu gdy to zadanie jest wyrwane z kontekstu. 
> 
> Gdy trzeba zrobić to tak po prostu to używa się właśnie
> programów narzędziowych typu awk, grep, wc, sort, sed, czasami
> łączy się te polecenia w jakimś glue-language.
> 
mi sie wydaje ze zamiast "awk, grep, wc, sort, sed, czasami łączy się te polecenia w jakimś glue-language. " raczej pisze sie program w pythonie - co chyba byloby prostsze - ale nie jestem pewien (bo nie uzywam anie tego ani tego)
mozesz w kazdym razie porownac ta wersje ktore masz na mysli a wersją na tym moim siclu w c i pokazac jakies wady czy zalety

- ja che miedzy innymi pokazac ze wyglada na to ze w c to sie da ladnie robic - wlasciwie wlasnie tutaj w tym siclu pokazalem jak

W dniu wtorek, 8 sierpnia 2017 00:48:20 UTC+2 użytkownik (fir) napisał:
> W dniu poniedziałek, 7 sierpnia 2017 23:14:27 UTC+2 użytkownik godek....@gmail.com napisał:
> 
> 
> > myślę też, że zrobiłbyś wielką przysługę wszystkim czytającym Twój kod,
> > zakładając sobie konto na githubie.
> > 
> > funkcję IsWhiteSpace powinieneś raczej zdefiniować używając literałów
> > znakowych, zamiast kodów ASCII, np. c == ' ' || c == '\t' itd.
> > (pomijając kwestię, że prawdopodobnie już jest zdefiniowana np.
> > w <ctype.h>)
> > 
> > szczerze mówiąc, osobiście wolę korzystać z gotowych i ogólnych
> > rozwiązań, niż wynajdywać koło na nowo
> 
> to jest nieistotna kurat napisalem to bo czasem wole unikac zewnetrznych zaleznosci jesli mozna to krotko napisac - ale to jest nieistotne i nie chcialbym raczej o tym dyskutowac i tracic na to czas

co do tych zewnetrznych zaleznosci to ten sicl jest mocno uzalezniony od rodziny printfów/scanfow w c (i pokrewnych) - oczywiscie chcialbym ta zaleznosc wywalic ale tez to jest (albo wydaj sie byc)  za duzym zadaniem (rowniez koncepcyjnym nie tylko albo nie tyle praktycznym - bo znajac siebie pewnie nie tyle chcialbym napisac swoje printfy co przerobic koncept (a to wymaga namyslu itp i nie chcialo mi sie tego robic)

On Tuesday, August 8, 2017 at 1:34:50 AM UTC+2, (fir) wrote:
> W dniu wtorek, 8 sierpnia 2017 00:41:27 UTC+2 użytkownik M.M. napisał:
> > On Monday, August 7, 2017 at 11:14:27 PM UTC+2, godek....@gmail.com wrote:
> > 
> > > szczerze mówiąc, osobiście wolę korzystać z gotowych i ogólnych
> > > rozwiązań, niż wynajdywać koło na nowo
> > 
> > Pewnie, kto nie woli? Każdy by chciał ogólnego i zarazem wydajnego
> > gotowca, ale ogólne często właśnie nie spełniają wymagań wydajnościowych, albo
> > wbrew pozorom nie są takie ogólne za jakie uchodzą - i trzeba zakodzić.
> > 
> > Pozdrawiam
> 
> z tego co wiem jesli w ktos stawia jakies zadanie typu, dajmy na to
> 
> "policz i wypisz na ekran linie z pliku notatki.txt ktore sa dluzsze niz 75 znakow"
> 
> to zwykle e c robi sie to ręcznie (czyli 'rzezbi' na poziomie petli ifow tablic i znakow itd

Osobiście, gdy nie mam powodu, albo nawet gdy mam mało ważny powód, ale 
wolę przeznaczyć czas na coś innego, to nie rzeźbię takich zadań w
forach i ifach. Używam np. awka i wc; a nawet w C++ używam QStringa i
QRegExp. Co innego gdy bardzo ważna jest wydajność. 


> konkretnie byloby to
> 
> int main()
> {
>  chunk text = LoadChunk("notatki.txt");
>   //wczytuje plik do ramu
> 
>  chunks lines = SplitChunkOnLines(text); 
> 
>   // dzieli na linie i zwraca tablice lini 
>   // (w postaci bar {poczatek, koniec lini})
> 
>  int n = ChunksLength(lines);
> 
>  int long_lines_counter = 0;
> 
>  for(int i=0; i<n; i++)
>  {
>     int line_length = ChunkLength(lines.first[i]);
>     
>     if(line_length>75)
>     {
>       PrintfChunk(lines.first[i]);
>       
>       long_lines_counter++; 
>     }
>     
>  }
>  printf("\n number of  long lines: %d", long_lines_counter);
> 
>  return long_lines_counter;
> }
> 
> uwagi
> I. logiczne, przyjemne, proste a byc moze calkiem odkrywcze (ze wzgledu na idee chunk/chunks) [moge wyjasnic dokladniej jak to dziala ale raczej jutro bo ide spac]
> 
> II. nie znam za duzo rzeczy w c tego typu (nie znam wcale ale moje doswiadczenie jest ograniczone)
> 
> III. dla mnie lepsze niz wyrazenia regularne
> 
> IV. nie jestem pewien jak to sie ma do wersji na kontenerach w c++ javaskrypcie czy pythonie ale raczej nie wypada calkiem zle, 
> prawdopodobnie jest z grubsza na rowni a dla koderow w c moze miec dodatkowe zalety bo rozumieja co jest under the hood bo to jest kod w c (dosyc krotki)

W QT prościej. 22 linijki włącznie z helpem, kodowaniem, argumentami z
linii polecenia:

#include <cstdio>
#include <cstdlib>
#include <QTextStream>

int main(int argc, char *argv[])
{
    QTextStream out(stdout);
    QTextStream inp(stdin);
    if( argc != 3 ) {
        out << "using:\n" << "cat notatki.txt | wc len encode";
        abort();
    }
    int count = 0;
    const int len = QString(argv[1]).toInt();
    inp.setCodec(argv[2]);
    while( ! inp.atEnd() ) {
        count += inp.readLine().size() >= len;
    }
    out << "count = " << count << endl;
    return 0;
}
 


> raczej pisze sie program w pythonie 
Python to moim zdaniem też język klej, ponieważ w operacjach na 
"pojedynczej zmiennej" jest koszmarnie wolny.

Pozdrawiam

W dniu wtorek, 8 sierpnia 2017 01:34:50 UTC+2 użytkownik (fir) napisał:
> W dniu wtorek, 8 sierpnia 2017 00:41:27 UTC+2 użytkownik M.M. napisał:
> > On Monday, August 7, 2017 at 11:14:27 PM UTC+2, godek....@gmail.com wrote:
> > 
> > > szczerze mówiąc, osobiście wolę korzystać z gotowych i ogólnych
> > > rozwiązań, niż wynajdywać koło na nowo
> > 
> > Pewnie, kto nie woli? Każdy by chciał ogólnego i zarazem wydajnego
> > gotowca, ale ogólne często właśnie nie spełniają wymagań wydajnościowych, albo
> > wbrew pozorom nie są takie ogólne za jakie uchodzą - i trzeba zakodzić.
> > 
> > Pozdrawiam
> 
> z tego co wiem jesli w ktos stawia jakies zadanie typu, dajmy na to
> 
> "policz i wypisz na ekran linie z pliku notatki.txt ktore sa dluzsze niz 75 znakow"
> 
> to zwykle e c robi sie to ręcznie (czyli 'rzezbi' na poziomie petli ifow tablic i znakow itd
> 
> moja biblioteczka dostarcza mz dosyc odkrywczej generalizacji ktorej mozna tu 
> uzyc - latwo i szynko
> 
> konkretnie byloby to
> 
> int main()
> {
>  chunk text = LoadChunk("notatki.txt");
>   //wczytuje plik do ramu
> 
>  chunks lines = SplitChunkOnLines(text); 
> 
>   // dzieli na linie i zwraca tablice lini 
>   // (w postaci bar {poczatek, koniec lini})
> 
>  int n = ChunksLength(lines);
> 
>  int long_lines_counter = 0;
> 
>  for(int i=0; i<n; i++)
>  {
>     int line_length = ChunkLength(lines.first[i]);
>     
>     if(line_length>75)
>     {
>       PrintfChunk(lines.first[i]);
>       
>       long_lines_counter++; 
>     }
>     
>  }
>  printf("\n number of  long lines: %d", long_lines_counter);
> 
>  return long_lines_counter;
> }
> 
> uwagi
> I. logiczne, przyjemne, proste a byc moze calkiem odkrywcze (ze wzgledu na idee chunk/chunks) [moge wyjasnic dokladniej jak to dziala ale raczej jutro bo ide spac]
> 


ok w sumie krotkie wyjasnienie 

I. CHUNK

podstawa jest idea ktora nazywam chunk
(dlatego biblioteka nazywa sie 'initial chunk library' bo 'narosla' wobec tego konceptu chunka

chnk to para wskaznikow jednego wskazujacego na poczatek drugiego na koniec, pierwszy i ostatni znak danego 'wyrazu' /czy tez chunka czyli kawalka, paska ramu (mozna powiedziec lekkie koncepcyjne pomieszanie bo chunkiem nazywam zarowno pare wskaznikow jak i sam blok ramu przez nie wskazywany)

te wskazniki nazywam begin i end (w kodzie sa one pisane beg i end bo w niektorych odach lepiej wygladalo jak mialy rowna dlugosc)

begin zawsze wskazuje na pierwszy znak a end na ostatni, nie jest tak ze end wskazuje 'za' ram tylko wskazuje na ostatni bajt ramu 

II. CHUNKS

Dalsza koncepcja jest cos co nazywam chunks
czyli tablica chunkow - czyli tablica par wskaznikow, W pewnym sesnie rdzeniem sicla
sa funkce Split() ktore produkuja z danego duzego chunka wlasnie chunks czyli tablice 
subchunkow

na przyklad jesli mamy 

chunk  txt = "ala ma kota";

chunks words = SplitOnWords(txt);

to words bedzie tablica 6 wskaznikow
 
{ {wskazujacego na a, wskazujacego na a},
 {wskazujacego na m, wskazujacego na a},
 {wskazujacego na k, wskazujacego na a} }

III. ogolne idee

ogolna idea jest taka by ladowac caly wejsciowy tekst do ramu ale nie modyfikowac go w miejscu, jesli robimy operacje np sortowanie to sortuje sie wsazniki w chunks 
a output flushuje sie printfami tym samym 
jakby input jest niemodyfikowalny w sumie ram tekst w postaci roboczego outputu tez nie istnieje a aoutput jest jakby ksztaltowany przez kolejnosc flushów do strumienia wyjsciowego printfami - to jest bardzo ekonomiczne fizycznie - jest tez w praktyce dosyc pojemna klasa przypadkow, jak na dzis doklenie nie wiem co sie w nim nie miesci i co wymagalo by robeni kopi roboczej w ramie i 
przepisywania jej w pamieci - moim zdaniem tego nalzey unikac

pisalem pewne funkcje pracujace na  ralokowaniu chunkow w ramie ale koniec koncow wywalilem je do czegos co nazwalem 'ricl' (reallock related part of icl) i nie jestem pewien czy jest to potrzebne, raczej moim zdaniem nalezy popracowac nad wersja 'statyczną')

tak to z grubsza dziala

 








> II. nie znam za duzo rzeczy w c tego typu (nie znam wcale ale moje doswiadczenie jest ograniczone)
> 
> III. dla mnie lepsze niz wyrazenia regularne
> 
> IV. nie jestem pewien jak to sie ma do wersji na kontenerach w c++ javaskrypcie czy pythonie ale raczej nie wypada calkiem zle, 
> prawdopodobnie jest z grubsza na rowni a dla koderow w c moze miec dodatkowe zalety bo rozumieja co jest under the hood bo to jest kod w c (dosyc krotki)

W dniu wtorek, 8 sierpnia 2017 02:06:03 UTC+2 użytkownik M.M. napisał:
> On Tuesday, August 8, 2017 at 1:34:50 AM UTC+2, (fir) wrote:
> > W dniu wtorek, 8 sierpnia 2017 00:41:27 UTC+2 użytkownik M.M. napisał:
> > > On Monday, August 7, 2017 at 11:14:27 PM UTC+2, godek....@gmail.com wrote:
> > > 
> > > > szczerze mówiąc, osobiście wolę korzystać z gotowych i ogólnych
> > > > rozwiązań, niż wynajdywać koło na nowo
> > > 
> > > Pewnie, kto nie woli? Każdy by chciał ogólnego i zarazem wydajnego
> > > gotowca, ale ogólne często właśnie nie spełniają wymagań wydajnościowych, albo
> > > wbrew pozorom nie są takie ogólne za jakie uchodzą - i trzeba zakodzić.
> > > 
> > > Pozdrawiam
> > 
> > z tego co wiem jesli w ktos stawia jakies zadanie typu, dajmy na to
> > 
> > "policz i wypisz na ekran linie z pliku notatki.txt ktore sa dluzsze niz 75 znakow"
> > 
> > to zwykle e c robi sie to ręcznie (czyli 'rzezbi' na poziomie petli ifow tablic i znakow itd
> 
> Osobiście, gdy nie mam powodu, albo nawet gdy mam mało ważny powód, ale 
> wolę przeznaczyć czas na coś innego, to nie rzeźbię takich zadań w
> forach i ifach. Używam np. awka i wc; a nawet w C++ używam QStringa i
> QRegExp. Co innego gdy bardzo ważna jest wydajność. 
> 
> 
> > konkretnie byloby to
> > 
> > int main()
> > {
> >  chunk text = LoadChunk("notatki.txt");
> >   //wczytuje plik do ramu
> > 
> >  chunks lines = SplitChunkOnLines(text); 
> > 
> >   // dzieli na linie i zwraca tablice lini 
> >   // (w postaci bar {poczatek, koniec lini})
> > 
> >  int n = ChunksLength(lines);
> > 
> >  int long_lines_counter = 0;
> > 
> >  for(int i=0; i<n; i++)
> >  {
> >     int line_length = ChunkLength(lines.first[i]);
> >     
> >     if(line_length>75)
> >     {
> >       PrintfChunk(lines.first[i]);
> >       
> >       long_lines_counter++; 
> >     }
> >     
> >  }
> >  printf("\n number of  long lines: %d", long_lines_counter);
> > 
> >  return long_lines_counter;
> > }
> > 
> > uwagi
> > I. logiczne, przyjemne, proste a byc moze calkiem odkrywcze (ze wzgledu na idee chunk/chunks) [moge wyjasnic dokladniej jak to dziala ale raczej jutro bo ide spac]
> > 
> > II. nie znam za duzo rzeczy w c tego typu (nie znam wcale ale moje doswiadczenie jest ograniczone)
> > 
> > III. dla mnie lepsze niz wyrazenia regularne
> > 
> > IV. nie jestem pewien jak to sie ma do wersji na kontenerach w c++ javaskrypcie czy pythonie ale raczej nie wypada calkiem zle, 
> > prawdopodobnie jest z grubsza na rowni a dla koderow w c moze miec dodatkowe zalety bo rozumieja co jest under the hood bo to jest kod w c (dosyc krotki)
> 
> W QT prościej. 22 linijki włącznie z helpem, kodowaniem, argumentami z
> linii polecenia:
> 
> #include <cstdio>
> #include <cstdlib>
> #include <QTextStream>
> 
> int main(int argc, char *argv[])
> {
>     QTextStream out(stdout);
>     QTextStream inp(stdin);
>     if( argc != 3 ) {
>         out << "using:\n" << "cat notatki.txt | wc len encode";
>         abort();
>     }
>     int count = 0;
>     const int len = QString(argv[1]).toInt();
>     inp.setCodec(argv[2]);
>     while( ! inp.atEnd() ) {
>         count += inp.readLine().size() >= len;
>     }
>     out << "count = " << count << endl;
>     return 0;
> }
>  
> 

to chyba nie jest krocej , bo jak wywale komentarze to u mnie jest

int main()
 {
  chunk text = LoadChunk("notatki.txt");
  chunks lines = SplitChunkOnLines(text); 
  int n = ChunksLength(lines);
  int long_lines_counter = 0;
  for(int i=0; i<n; i++)  {
    int line_length = ChunkLength(lines.first[i]);
   if(line_length>75) {      PrintfChunk(lines.first[i]);       long_lines_counter++;      }
  }
  printf("\n number of  long lines: %d", long_lines_counter);
 return long_lines_counter;
}

to ze w szerz jest dluzej wynika tylko z tego ze osobiscie wole dlugie nazwy nie z kodu

pozatym to co ty piszesz robi chyba raczej cos innego niz moj program, co to dokladnie robi?

> 
> > raczej pisze sie program w pythonie 
> Python to moim zdaniem też język klej, ponieważ w operacjach na 
> "pojedynczej zmiennej" jest koszmarnie wolny.
> 
czytalem jakies dyskucje na temat podobnego przetwarzania tekstow w pythonie i nie byl koszmarnie wolny, wiekszosc roboty robil w api swoich kontenerow ktore i tak bylo zaimplementowane w c

W dniu wtorek, 8 sierpnia 2017 02:20:19 UTC+2 użytkownik (fir) napisał:
> W dniu wtorek, 8 sierpnia 2017 01:34:50 UTC+2 użytkownik (fir) napisał:
> > W dniu wtorek, 8 sierpnia 2017 00:41:27 UTC+2 użytkownik M.M. napisał:
> > > On Monday, August 7, 2017 at 11:14:27 PM UTC+2, godek....@gmail.com wrote:
> > > 
> > > > szczerze mówiąc, osobiście wolę korzystać z gotowych i ogólnych
> > > > rozwiązań, niż wynajdywać koło na nowo
> > > 
> > > Pewnie, kto nie woli? Każdy by chciał ogólnego i zarazem wydajnego
> > > gotowca, ale ogólne często właśnie nie spełniają wymagań wydajnościowych, albo
> > > wbrew pozorom nie są takie ogólne za jakie uchodzą - i trzeba zakodzić.
> > > 
> > > Pozdrawiam
> > 
> > z tego co wiem jesli w ktos stawia jakies zadanie typu, dajmy na to
> > 
> > "policz i wypisz na ekran linie z pliku notatki.txt ktore sa dluzsze niz 75 znakow"
> > 
> > to zwykle e c robi sie to ręcznie (czyli 'rzezbi' na poziomie petli ifow tablic i znakow itd
> > 
> > moja biblioteczka dostarcza mz dosyc odkrywczej generalizacji ktorej mozna tu 
> > uzyc - latwo i szynko
> > 
> > konkretnie byloby to
> > 
> > int main()
> > {
> >  chunk text = LoadChunk("notatki.txt");
> >   //wczytuje plik do ramu
> > 
> >  chunks lines = SplitChunkOnLines(text); 
> > 
> >   // dzieli na linie i zwraca tablice lini 
> >   // (w postaci bar {poczatek, koniec lini})
> > 
> >  int n = ChunksLength(lines);
> > 
> >  int long_lines_counter = 0;
> > 
> >  for(int i=0; i<n; i++)
> >  {
> >     int line_length = ChunkLength(lines.first[i]);
> >     
> >     if(line_length>75)
> >     {
> >       PrintfChunk(lines.first[i]);
> >       
> >       long_lines_counter++; 
> >     }
> >     
> >  }
> >  printf("\n number of  long lines: %d", long_lines_counter);
> > 
> >  return long_lines_counter;
> > }
> > 
> > uwagi
> > I. logiczne, przyjemne, proste a byc moze calkiem odkrywcze (ze wzgledu na idee chunk/chunks) [moge wyjasnic dokladniej jak to dziala ale raczej jutro bo ide spac]
> > 
> 
> 
> ok w sumie krotkie wyjasnienie 
> 
> I. CHUNK
> 
> podstawa jest idea ktora nazywam chunk
> (dlatego biblioteka nazywa sie 'initial chunk library' bo 'narosla' wobec tego konceptu chunka
> 
> chnk to para wskaznikow jednego wskazujacego na poczatek drugiego na koniec, pierwszy i ostatni znak danego 'wyrazu' /czy tez chunka czyli kawalka, paska ramu (mozna powiedziec lekkie koncepcyjne pomieszanie bo chunkiem nazywam zarowno pare wskaznikow jak i sam blok ramu przez nie wskazywany)
> 
> te wskazniki nazywam begin i end (w kodzie sa one pisane beg i end bo w niektorych odach lepiej wygladalo jak mialy rowna dlugosc)
> 
> begin zawsze wskazuje na pierwszy znak a end na ostatni, nie jest tak ze end wskazuje 'za' ram tylko wskazuje na ostatni bajt ramu 
> 
> II. CHUNKS
> 
> Dalsza koncepcja jest cos co nazywam chunks
> czyli tablica chunkow - czyli tablica par wskaznikow, W pewnym sesnie rdzeniem sicla
> sa funkce Split() ktore produkuja z danego duzego chunka wlasnie chunks czyli tablice 
> subchunkow
> 
> na przyklad jesli mamy 
> 
> chunk  txt = "ala ma kota";
> 
> chunks words = SplitOnWords(txt);
> 
> to words bedzie tablica 6 wskaznikow
>  
> { {wskazujacego na a, wskazujacego na a},
>  {wskazujacego na m, wskazujacego na a},
>  {wskazujacego na k, wskazujacego na a} }
> 

przy czym moge dodac ze chunks nie jest fizycznie przekazywane jako tutaj tablica 6-ciu wskaznikow, chunks jest tworzona wewnetrzenie w funkcji Split - przekazywany jest tylko para wskaznikow - na pierwsza pare i na ostatnia  (tcala tablica chunow jest wewnetrz Splita realokowana - dlatego kolejne wywolanie tej funkcji zamaze wynik, poprzedniej - jest to pewna niedogodnosc wynikajaca z niedorobek koncepcyjnych w c - ale w praktyce da sie przezyc - i tak jest pewnym niemal cudem ze to sie da zrobic w c tak jak sie tu daje zrobic czyli normalnie zwracajac rezultaty co mozna laczyc w ladne ksakady 
 
 SaveChunks( "out.txt", Removeduplicates(SortChunks( LoadChunk("notatki.txt") ) )); 

 itd
)


> III. ogolne idee
> 
> ogolna idea jest taka by ladowac caly wejsciowy tekst do ramu ale nie modyfikowac go w miejscu, jesli robimy operacje np sortowanie to sortuje sie wsazniki w chunks 
> a output flushuje sie printfami tym samym 
> jakby input jest niemodyfikowalny w sumie ram tekst w postaci roboczego outputu tez nie istnieje a aoutput jest jakby ksztaltowany przez kolejnosc flushów do strumienia wyjsciowego printfami - to jest bardzo ekonomiczne fizycznie - jest tez w praktyce dosyc pojemna klasa przypadkow, jak na dzis doklenie nie wiem co sie w nim nie miesci i co wymagalo by robeni kopi roboczej w ramie i 
> przepisywania jej w pamieci - moim zdaniem tego nalzey unikac
> 
> pisalem pewne funkcje pracujace na  ralokowaniu chunkow w ramie ale koniec koncow wywalilem je do czegos co nazwalem 'ricl' (reallock related part of icl) i nie jestem pewien czy jest to potrzebne, raczej moim zdaniem nalezy popracowac nad wersja 'statyczną')
> 
> tak to z grubsza dziala
> 
>  
> 
> 
> 
> 
> 
> 
> 
> 
> > II. nie znam za duzo rzeczy w c tego typu (nie znam wcale ale moje doswiadczenie jest ograniczone)
> > 
> > III. dla mnie lepsze niz wyrazenia regularne
> > 
> > IV. nie jestem pewien jak to sie ma do wersji na kontenerach w c++ javaskrypcie czy pythonie ale raczej nie wypada calkiem zle, 
> > prawdopodobnie jest z grubsza na rowni a dla koderow w c moze miec dodatkowe zalety bo rozumieja co jest under the hood bo to jest kod w c (dosyc krotki)

W dniu wtorek, 8 sierpnia 2017 00:48:20 UTC+2 użytkownik (fir) napisał:

> > nie wiem, co jest badziewnego w wyrażeniach regularnych.
> > Twoich kilka linijek w C to z grubsza jedna linijka w perlu albo awk.
> > 
> 
> moze nie wiesz ale z mojego punktu widzenia to twoj problem nie moj ;c

nie rozumiem, w jaki sposób użyłeś tutaj słowa "problem".
w moim odczuciu to, że mogę coś szybko zrobić, i mam do tego gotowe
narzędzia, nie jest problemem

> jutro mozemy porownac jak wyglada np przerobianie plikow tekstowych przy 
> pomocy tej mojej biblioteczki (ew lekko poprawionej bo che ja udoskonalic ) i tych skryptow o ktorch mowisz (a ktorych ja nigdy nie pisalem) - to moze byc ciekawe, ale dzis juz ide spac
> 
> mozesz pomyslec np jak wygladalyby jakies proste do wymyslanie zadania, np

do większości rzeczy pewnie nawet bym nie uruchamiał perla
w unksie:

> 1) posortowanie lini w pliku i zapisanie posortowanego

sort plik > posortowany

> 2) policzenie slow

wc plik

> 3) posortowanie slow

jakoś mniej więcej tak

#!/bin/perl
%count = {};
while(<>) {
  for $word split(/\s+/) {
    $count{$word}++
  }
}

for $word sort keys(%count)
{
  print $word+": "+$count{$word}+"\n"
}

czy coś

> 4) wyszukanie jakichs slow i ich podmienienie

sed -e 's/jakies_slowo/podmianka/g'

(pewnie tak naprawdę chciałoby się zrobić /\bjakies_slowo\b/ albo
coś w tym rodzaju, żeby zakotwiczyć wyrażenia regularne)

> 5) ponumerowanie lini i wstawienie tych numerow z lewej strony

#!/bin/perl
$counter = 0;
while(<>) {
  print ++$counter + ": ";
  print;
}


> > myślę też, że zrobiłbyś wielką przysługę wszystkim czytającym Twój kod,
> > zakładając sobie konto na githubie.
> > 
> > funkcję IsWhiteSpace powinieneś raczej zdefiniować używając literałów
> > znakowych, zamiast kodów ASCII, np. c == ' ' || c == '\t' itd.
> > (pomijając kwestię, że prawdopodobnie już jest zdefiniowana np.
> > w <ctype.h>)
> > 
> > szczerze mówiąc, osobiście wolę korzystać z gotowych i ogólnych
> > rozwiązań, niż wynajdywać koło na nowo
> 
> to jest nieistotna kurat napisalem to bo czasem wole unikac zewnetrznych zaleznosci jesli mozna to krotko napisac - ale to jest nieistotne i nie chcialbym raczej o tym dyskutowac i tracic na to czas

Zasadniczo nie da się unikać zewnętrznych zależności, dlatego
IMO lepiej skupić się na poznawaniu narzędzi, które się ma do dyspozycji
w swoim uwikłaniu. A jeżeli chcesz się z czegoś rozwikłać, to warto
najpierw rozważyć, w jakim celu.

On Tuesday, August 8, 2017 at 2:29:47 AM UTC+2, (fir) wrote:
> W dniu wtorek, 8 sierpnia 2017 02:06:03 UTC+2 użytkownik M.M. napisał:
> > On Tuesday, August 8, 2017 at 1:34:50 AM UTC+2, (fir) wrote:
> > > W dniu wtorek, 8 sierpnia 2017 00:41:27 UTC+2 użytkownik M.M. napisał:
> > > > On Monday, August 7, 2017 at 11:14:27 PM UTC+2, godek....@gmail.com wrote:
> > > > 
> > > > > szczerze mówiąc, osobiście wolę korzystać z gotowych i ogólnych
> > > > > rozwiązań, niż wynajdywać koło na nowo
> > > > 
> > > > Pewnie, kto nie woli? Każdy by chciał ogólnego i zarazem wydajnego
> > > > gotowca, ale ogólne często właśnie nie spełniają wymagań wydajnościowych, albo
> > > > wbrew pozorom nie są takie ogólne za jakie uchodzą - i trzeba zakodzić.
> > > > 
> > > > Pozdrawiam
> > > 
> > > z tego co wiem jesli w ktos stawia jakies zadanie typu, dajmy na to
> > > 
> > > "policz i wypisz na ekran linie z pliku notatki.txt ktore sa dluzsze niz 75 znakow"
> > > 
> > > to zwykle e c robi sie to ręcznie (czyli 'rzezbi' na poziomie petli ifow tablic i znakow itd
> > 
> > Osobiście, gdy nie mam powodu, albo nawet gdy mam mało ważny powód, ale 
> > wolę przeznaczyć czas na coś innego, to nie rzeźbię takich zadań w
> > forach i ifach. Używam np. awka i wc; a nawet w C++ używam QStringa i
> > QRegExp. Co innego gdy bardzo ważna jest wydajność. 
> > 
> > 
> > > konkretnie byloby to
> > > 
> > > int main()
> > > {
> > >  chunk text = LoadChunk("notatki.txt");
> > >   //wczytuje plik do ramu
> > > 
> > >  chunks lines = SplitChunkOnLines(text); 
> > > 
> > >   // dzieli na linie i zwraca tablice lini 
> > >   // (w postaci bar {poczatek, koniec lini})
> > > 
> > >  int n = ChunksLength(lines);
> > > 
> > >  int long_lines_counter = 0;
> > > 
> > >  for(int i=0; i<n; i++)
> > >  {
> > >     int line_length = ChunkLength(lines.first[i]);
> > >     
> > >     if(line_length>75)
> > >     {
> > >       PrintfChunk(lines.first[i]);
> > >       
> > >       long_lines_counter++; 
> > >     }
> > >     
> > >  }
> > >  printf("\n number of  long lines: %d", long_lines_counter);
> > > 
> > >  return long_lines_counter;
> > > }
> > > 
> > > uwagi
> > > I. logiczne, przyjemne, proste a byc moze calkiem odkrywcze (ze wzgledu na idee chunk/chunks) [moge wyjasnic dokladniej jak to dziala ale raczej jutro bo ide spac]
> > > 
> > > II. nie znam za duzo rzeczy w c tego typu (nie znam wcale ale moje doswiadczenie jest ograniczone)
> > > 
> > > III. dla mnie lepsze niz wyrazenia regularne
> > > 
> > > IV. nie jestem pewien jak to sie ma do wersji na kontenerach w c++ javaskrypcie czy pythonie ale raczej nie wypada calkiem zle, 
> > > prawdopodobnie jest z grubsza na rowni a dla koderow w c moze miec dodatkowe zalety bo rozumieja co jest under the hood bo to jest kod w c (dosyc krotki)
> > 
> > W QT prościej. 22 linijki włącznie z helpem, kodowaniem, argumentami z
> > linii polecenia:
> > 
> > #include <cstdio>
> > #include <cstdlib>
> > #include <QTextStream>
> > 
> > int main(int argc, char *argv[])
> > {
> >     QTextStream out(stdout);
> >     QTextStream inp(stdin);
> >     if( argc != 3 ) {
> >         out << "using:\n" << "cat notatki.txt | wc len encode";
> >         abort();
> >     }
> >     int count = 0;
> >     const int len = QString(argv[1]).toInt();
> >     inp.setCodec(argv[2]);
> >     while( ! inp.atEnd() ) {
> >         count += inp.readLine().size() >= len;
> >     }
> >     out << "count = " << count << endl;
> >     return 0;
> > }
> >  
> > 
> 
> to chyba nie jest krocej , bo jak wywale komentarze to u mnie jest
> 
> int main()
>  {
>   chunk text = LoadChunk("notatki.txt");
>   chunks lines = SplitChunkOnLines(text); 
>   int n = ChunksLength(lines);
>   int long_lines_counter = 0;
>   for(int i=0; i<n; i++)  {
>     int line_length = ChunkLength(lines.first[i]);
>    if(line_length>75) {      PrintfChunk(lines.first[i]);       long_lines_counter++;      }
>   }
>   printf("\n number of  long lines: %d", long_lines_counter);
>  return long_lines_counter;
> }
> 
> to ze w szerz jest dluzej wynika tylko z tego ze osobiscie wole dlugie nazwy nie z kodu

Programy takie same nie są, Twój np. wczytuje cały plik do RAM, mój 
działa inline na jednym wierszu. Faktycznie, mój jest ciut dłuższy, ale
ma help, obslugę kodowania i długość wiersza z linii komend.

Ten program robi to samo co Twój:
#include <cstdio>
#include <cstdlib>
#include <QTextStream>
#include <QRegExp>

int main(int argc, char *argv[])
{
    QTextStream out(stdout);
    QTextStream inp(stdin);
    if( argc != 4 ) {
        out << "using:\n" << "cat notatki.txt | wc len encode regexp";
        abort();
    }
    int count = 0;
    const int len = QString(argv[1]).toInt();
    inp.setCodec(argv[2]);
    const QRegExp rxp( argv[3]);
    while( ! inp.atEnd() ) {
        const QStringList tokens = inp.readLine().split( rxp );
        if( tokens.size() > 0 && tokens[0].size() > len ) {
            count++;
            out << tokens[0] << endl;
        }
    }
    out << "count = " << count << endl;
    return 0;
}

Ma 27 linii. Skompiluje się na wiele systemów. Ma już podręczny help i
wszystkie parametry bierze z linii polecenia.

Po obdarciu ma 17 linijek i chyba nadal robi to samo co Twój:
#include <cstdio>
#include <QTextStream>
#include <QRegExp>
int main(int argc, char *argv[])
{
    QTextStream out(stdout), inp(stdin);
    int count = 0;
    while( ! inp.atEnd() ) {
        const QStringList tokens = inp.readLine().split( QRegExp("\\s+") );
        if( tokens.size() > 0 && tokens[0].size() > 75 ) {
            count++;
            out << tokens[0] << endl;
        }
    }
    out << "count = " << count << endl;
    return 0;
}

Na pewno jest równie zwarty jak Twój i pewnie uruchomi się poprawnie na
wielu różnych systemach.



> 
> pozatym to co ty piszesz robi chyba raczej cos innego niz moj program, co to dokladnie robi?
Teraz chyba już to samo.

> 
> > 
> > > raczej pisze sie program w pythonie 
> > Python to moim zdaniem też język klej, ponieważ w operacjach na 
> > "pojedynczej zmiennej" jest koszmarnie wolny.
> > 
> czytalem jakies dyskucje na temat podobnego przetwarzania tekstow w pythonie i nie byl koszmarnie wolny, wiekszosc roboty robil w api swoich kontenerow ktore i tak bylo zaimplementowane w c

Tak, przetwarzanie tekstu może zachodzić głównie w jakimś kodzie 
bibliotecznym napisanym w C. Jeśli duże fragmenty tekstu są
obrabiane "naraz", to nie zaobserwujemy aż 100 krotnego spadku 
wydajności.

Pozdrawiam

W dniu poniedziałek, 7 sierpnia 2017 23:14:27 UTC+2 użytkownik godek....@gmail.com napisał:
> W dniu poniedziałek, 7 sierpnia 2017 20:17:39 UTC+2 użytkownik (fir) napisał:

> nie wiem, co jest badziewnego w wyrażeniach regularnych.

Jest taka książka "Beautiful Code", zawierająca opisy implementacji
różnych pomysłów z informatyki, klasycznych i mniej klasycznych
(m.in. pamięć transakcyjna w Haskellu, autorstwa Simona Peytona Jonesa,
czy system makr syntax-case w Schemie opisany przez Kenta Dybviga).

Pierwszy rozdział zawiera klasyczną implementację wyrażeń regularnych w C,
w ok. 30 linijkach. Polecam lekturę.

Jest też łatwy do znalezienia w Internecie pejper Daniela Friedmana
i Jasona Hemana o systemie "micro-kanren", prezentującym implementację
języka podobnego do Prologa w ok. 40 linijkach kodu funkcyjnego
(oryginał jest w Scheme, ale programiści go sobie przeportowali do języków
takich jak F#, Haskell, ML, Clojure czy Python).

Piszę o tym, bo w moim odczuciu 1000 linii to całkiem sporo.

W dniu wtorek, 8 sierpnia 2017 07:00:11 UTC+2 użytkownik godek....@gmail.com napisał:
> W dniu wtorek, 8 sierpnia 2017 00:48:20 UTC+2 użytkownik (fir) napisał:
> 
> > > nie wiem, co jest badziewnego w wyrażeniach regularnych.
> > > Twoich kilka linijek w C to z grubsza jedna linijka w perlu albo awk.
> > > 
> > 
> > moze nie wiesz ale z mojego punktu widzenia to twoj problem nie moj ;c
> 
> nie rozumiem, w jaki sposób użyłeś tutaj słowa "problem".
> w moim odczuciu to, że mogę coś szybko zrobić, i mam do tego gotowe
> narzędzia, nie jest problemem
> 
> > jutro mozemy porownac jak wyglada np przerobianie plikow tekstowych przy 
> > pomocy tej mojej biblioteczki (ew lekko poprawionej bo che ja udoskonalic ) i tych skryptow o ktorch mowisz (a ktorych ja nigdy nie pisalem) - to moze byc ciekawe, ale dzis juz ide spac
> > 
> > mozesz pomyslec np jak wygladalyby jakies proste do wymyslanie zadania, np
> 
> do większości rzeczy pewnie nawet bym nie uruchamiał perla
> w unksie:
> 
> > 1) posortowanie lini w pliku i zapisanie posortowanego
> 
> sort plik > posortowany
> 
> > 2) policzenie slow
> 
> wc plik
> 
> > 3) posortowanie slow
> 
> jakoś mniej więcej tak
> 
> #!/bin/perl
> %count = {};
> while(<>) {
>   for $word split(/\s+/) {
>     $count{$word}++
>   }
> }
> 
> for $word sort keys(%count)
> {
>   print $word+": "+$count{$word}+"\n"
> }
> 
> czy coś
> 
> > 4) wyszukanie jakichs slow i ich podmienienie
> 
> sed -e 's/jakies_slowo/podmianka/g'
> 
> (pewnie tak naprawdę chciałoby się zrobić /\bjakies_slowo\b/ albo
> coś w tym rodzaju, żeby zakotwiczyć wyrażenia regularne)
> 
> > 5) ponumerowanie lini i wstawienie tych numerow z lewej strony
> 
> #!/bin/perl
> $counter = 0;
> while(<>) {
>   print ++$counter + ": ";
>   print;
> }
> 
odpowiadam na dwa posty naraz (te od perla i te od c++)

nieststy nie umiem tego w 100% zweryfikowac, ale ok moge zalozyc ze z grubsza tak to wyglada

zaznaczyc jednak mozna ze nie jest to odpowiedz na moja kwestie zwiazana z napisaniem tej biblioteki sicl a jedynie komentarz do jednego z jej licznych aspektow
- bo aspektow jest wiele

jeden z moze bardziej waznych jest taki:
te przyklady powyzej w bashu perlu czy co to jest plus w c++ nie są w c.. moja biblioteka jest w c - co do 'skompiluje sie na wielu systemach' to sicl tez skompiluje sie na wielu systemach 

o innych aspektach pozniej 



 

> 
> > > myślę też, że zrobiłbyś wielką przysługę wszystkim czytającym Twój kod,
> > > zakładając sobie konto na githubie.
> > > 
> > > funkcję IsWhiteSpace powinieneś raczej zdefiniować używając literałów
> > > znakowych, zamiast kodów ASCII, np. c == ' ' || c == '\t' itd.
> > > (pomijając kwestię, że prawdopodobnie już jest zdefiniowana np.
> > > w <ctype.h>)
> > > 
> > > szczerze mówiąc, osobiście wolę korzystać z gotowych i ogólnych
> > > rozwiązań, niż wynajdywać koło na nowo
> > 
> > to jest nieistotna kurat napisalem to bo czasem wole unikac zewnetrznych zaleznosci jesli mozna to krotko napisac - ale to jest nieistotne i nie chcialbym raczej o tym dyskutowac i tracic na to czas
> 
> Zasadniczo nie da się unikać zewnętrznych zależności, dlatego
> IMO lepiej skupić się na poznawaniu narzędzi, które się ma do dyspozycji
> w swoim uwikłaniu. A jeżeli chcesz się z czegoś rozwikłać, to warto
> najpierw rozważyć, w jakim celu.

W dniu wtorek, 8 sierpnia 2017 10:36:49 UTC+2 użytkownik (fir) napisał:
> W dniu wtorek, 8 sierpnia 2017 07:00:11 UTC+2 użytkownik godek....@gmail.com napisał:
> > W dniu wtorek, 8 sierpnia 2017 00:48:20 UTC+2 użytkownik (fir) napisał:
> > 
> > > > nie wiem, co jest badziewnego w wyrażeniach regularnych.
> > > > Twoich kilka linijek w C to z grubsza jedna linijka w perlu albo awk.
> > > > 
> > > 
> > > moze nie wiesz ale z mojego punktu widzenia to twoj problem nie moj ;c
> > 
> > nie rozumiem, w jaki sposób użyłeś tutaj słowa "problem".
> > w moim odczuciu to, że mogę coś szybko zrobić, i mam do tego gotowe
> > narzędzia, nie jest problemem
> > 
> > > jutro mozemy porownac jak wyglada np przerobianie plikow tekstowych przy 
> > > pomocy tej mojej biblioteczki (ew lekko poprawionej bo che ja udoskonalic ) i tych skryptow o ktorch mowisz (a ktorych ja nigdy nie pisalem) - to moze byc ciekawe, ale dzis juz ide spac
> > > 
> > > mozesz pomyslec np jak wygladalyby jakies proste do wymyslanie zadania, np
> > 
> > do większości rzeczy pewnie nawet bym nie uruchamiał perla
> > w unksie:
> > 
> > > 1) posortowanie lini w pliku i zapisanie posortowanego
> > 
> > sort plik > posortowany
> > 
> > > 2) policzenie slow
> > 
> > wc plik
> > 
> > > 3) posortowanie slow
> > 
> > jakoś mniej więcej tak
> > 
> > #!/bin/perl
> > %count = {};
> > while(<>) {
> >   for $word split(/\s+/) {
> >     $count{$word}++
> >   }
> > }
> > 
> > for $word sort keys(%count)
> > {
> >   print $word+": "+$count{$word}+"\n"
> > }
> > 
> > czy coś
> > 
> > > 4) wyszukanie jakichs slow i ich podmienienie
> > 
> > sed -e 's/jakies_slowo/podmianka/g'
> > 
> > (pewnie tak naprawdę chciałoby się zrobić /\bjakies_slowo\b/ albo
> > coś w tym rodzaju, żeby zakotwiczyć wyrażenia regularne)
> > 
> > > 5) ponumerowanie lini i wstawienie tych numerow z lewej strony
> > 
> > #!/bin/perl
> > $counter = 0;
> > while(<>) {
> >   print ++$counter + ": ";
> >   print;
> > }
> > 
> odpowiadam na dwa posty naraz (te od perla i te od c++)
> 
> nieststy nie umiem tego w 100% zweryfikowac, ale ok moge zalozyc ze z grubsza tak to wyglada
> 
> zaznaczyc jednak mozna ze nie jest to odpowiedz na moja kwestie zwiazana z napisaniem tej biblioteki sicl a jedynie komentarz do jednego z jej licznych aspektow
> - bo aspektow jest wiele
> 
> jeden z moze bardziej waznych jest taki:
> te przyklady powyzej w bashu perlu czy co to jest plus w c++ nie są w c.. moja biblioteka jest w c - co do 'skompiluje sie na wielu systemach' to sicl tez skompiluje sie na wielu systemach 
> 
> o innych aspektach pozniej 
> 

jeszcze inny aspekt jest taki ze te klocki do 
przerabiania tekstu jakie ja dostarczam czy moge dostarczyc w siclu sa bardzo logiczne i wyjatkowo ladnie sie skladają.. (nad tym zestawem klockow w sumie warto by wlasnie pomyslec) w tych innych implementacjach czegos podobnego czytli wlasnie w c++, pythonie czy perlu mam wrazenie w sumie mozliwosci wywolania operacji sa dosyc analogiczne ale te klocki do zabawy nie skladaja sie tak czysto jak tutaj (to mnie zawsze odstraszalo) - do tego tam nie wiesz jakie operacje dzieja sie pod spodem tutaj dokladnie widac

(a sklada sie to ladnie co mam nadzieje widac: np jedna linijka wczytujesz tekst do ramu, jedna linijka splitujesz na linie czy slowa czy w inny sposob, iterujesz po tych wysplitowanych kawalkach prosta petlą w c [mozesz ew dopisac w siclu tez predefiniowane funkcje typu sort itd]
i mozesz na nich dokonywac prostych operacji,
odrzucac porownywac zmieniac, wynik na biezaco mozesz flushowac do ouputu (zaoszczedzajac ram] itd itd
- ogolnie jest to idealnie proste - moim zdaniem bez dwu zdan w pewnych aspektach c potrzebuje takiej biblioteki  bo to co daje standardowa biblioteka w c do pracy z tekstem to jednak troche męka)

ew jak ktos chce moze wymyslec i podac jakies nieco bardziej skompikowane przypadki przerobki tekstu w plikach i moge sie zastanowaic na jakie klocki api to podzielic lub ew porownac kod w c na siclu z wersjami
w perlu czy c++


> 
> 
>  
> 
> > 
> > > > myślę też, że zrobiłbyś wielką przysługę wszystkim czytającym Twój kod,
> > > > zakładając sobie konto na githubie.
> > > > 
> > > > funkcję IsWhiteSpace powinieneś raczej zdefiniować używając literałów
> > > > znakowych, zamiast kodów ASCII, np. c == ' ' || c == '\t' itd.
> > > > (pomijając kwestię, że prawdopodobnie już jest zdefiniowana np.
> > > > w <ctype.h>)
> > > > 
> > > > szczerze mówiąc, osobiście wolę korzystać z gotowych i ogólnych
> > > > rozwiązań, niż wynajdywać koło na nowo
> > > 
> > > to jest nieistotna kurat napisalem to bo czasem wole unikac zewnetrznych zaleznosci jesli mozna to krotko napisac - ale to jest nieistotne i nie chcialbym raczej o tym dyskutowac i tracic na to czas
> > 
> > Zasadniczo nie da się unikać zewnętrznych zależności, dlatego
> > IMO lepiej skupić się na poznawaniu narzędzi, które się ma do dyspozycji
> > w swoim uwikłaniu. A jeżeli chcesz się z czegoś rozwikłać, to warto
> > najpierw rozważyć, w jakim celu.

On Tue, 8 Aug 2017 01:24:56 -0700 (PDT), godek.maciek@gmail.com wrote:
> Piszę o tym, bo w moim odczuciu 1000 linii to...

A mi jakoś tak wychodzi 1000 linii z byle czego, wliczając 
komentarze. Tzn. więcej mi się nie chce. Mniej zachęca do dopisania 
czegoś jeszcze. I nigdy nie mam ochoty siedzieć tydzień nad tym jak 
zawrzeć w 40 linijkach tego co już jest ładnie zrobione w 240. Choć 
często wywalam jakieś bazgroły (cudze) na 3000 linijek, zwykle potem 
mam coś na 200 do 300 (czasem od 10 do 20) linijek jako "bibliotekę" 
i tuzin jednolinijkowych odwołań do tego.

"(fir)" <profesor.fir@gmail.com> wrote:

>     (it is early version, some things need to be
>     throwed out some added, most revritten but

Hmm, jest bug posixie - jest funkcja write, nie ma vrite... trzeba 
poprawić.

>      vprintf(format, args);

Generalnie błędy wyrzuca się na stderr... no i nie wyrzucasz newline w 
wywołaniach ERROR_EXIT, czyli powinieneś tutaj.

> inline int ChunkIsEmpty(chunk c)
> {
> 
>   if(c.beg==NULL || c.end==NULL || c.beg>c.end)
>   {
>      c.beg   = NULL;
>      c.end   = NULL;
>      return 1;
>   }
> 
>   return 0;
> }

Funkcja, która sprawdza, czy chunk jest pusty, modyfikuje tego chunka?

>     ERROR_EXIT("error obtaining file size for &s", filename);

%s

> chunk LoadChunk(char* file_name)
> {
>   static char* internal_text = NULL;

Po co ten static tu?

>   int readed =  fread(internal_text, 1, file_length, file);

Gdzie używasz readed?

> void CreateFile(char* filename)

Modyfikujesz zawartość filename? Nie... to gdzie const?

> int IsDigit(char c)
> {
>   if(c>='0' && c<='9') return 1;
>   else return 0;
> }

#include <ctype.h>
isdigit()

I tak dalej.

-- 
[ Email: a@b a=grp b=chmurka.net ]
[ Web:   http://www.chmurka.net/ ]

jeszcze by mozna powiedziec o kwestii nazewniczej bo to wazny temat, cala koncepcja stoi na tym

typedef
    struct     
    { 
     char* beg;
     char* end;  
    }
     chunk; 

typedef 
  struct   
  { 
   chunk* first; 
   chunk* last; 
  }
   chunks; 

mozna by uzyc innych nazw np 
 chunk ~ string
chunks ~ strings


troche byloby latwiejsze w rozumieniu,
myslalem tez o chnk ~ bytes albo czunk ~ chars  (ale wtedy liczba mnoga nie widowomo jak by byla charss? bytess? ;c ew chunks ~ list_of chars, chunk_of_bytes itp)

na razie zostalo jednak chunk

inna kwestia jak nazwac ten pierwszy i ten ostatni wskaznik - z poczatku nazywalem .begin i .end w obu tj i w chunk i w chunks 
ale bylo to konfudujace w niektorych kodach i okazalo sie ze lepiej uzywac .begin i .end jako wskaznikow w chunku a .first i .last na
wskazniki w na same chunki (pozniej begin skrocilem na beg bo lepiej wygladalo w pewnych kodach bo czasem te kody przy rownej dlugosci wygladaja symetrycznie a z .begin .end krzywo)

z tym first i last jest chytelniej np

s.first[3].begin[3]
 jest raczej czytelniejszni niz 
s.begin[3].begin[3]

a znaczy to 4-ty znak w 4-tym stringu z kolekcji stringow s

przez to .begin i end mozna adresowac zawartosc chunka czyli robi to troche za 
dostep jak tablicja tj

// chunk str 

  str.begin[3] //4-ty znak
  str.end[-2] //trzeci od konca
 
co troche brzydko wyglada, wydaje sie ze przydaloby sie adresowanie od poczatku zrobic 
po prostu jako str[3] (lub tez zmienic ew nazwe begin na troche stosowniejsza) ale tak sie tymczasowo nie da

struct A {
   char* x;
 };

A a,b,c;

// a[5] = 4 zamiast a.x[5]=5
 
czytalem cos kiedys o anonimowych strukturach czy polach w strukturach ale juz nie pamietam czy c czy c++ to ma, zreszta nie wiem czy to by ni zaciemnialo obrazu - tak ze summa sumarum to nazewnicto wjest takie jakie podoalem, przy pewnych zarysowanych wątpliwosciach

pozniejjeszcze moglbym powiedziec nieco wiecej na temat przykladow uzycia i moze napisze cos ale musze zdeczka odpoczac bo ostatnie nie mam na nic sily i wszystko mnie diablo meczy

ogolnie pewnie powinienem zastanowic sie jakie lub jakie jeszcze funkcje tam zaimplementowac by latwo sie tego uzywalo i by sie przydawaly - mysle zwlaszcza w szczegolnosci o przypadkupisania kompilatora

o ile pamietam wczesniej zaimplementowalem funkcje FindFirstInteger(chunk) ktora zwracala pierwszego znalezionego inta - pozniej chyba przerobilem ja na krotsza funkcje o nazwie DigInt() (gdzie dig zastapilo findfirst) a uzywalo sie tego tak

   char* txt = "some: 100, 200, 300; then: 3, 4, 5, 6, 7, 8, 9; and then: -10, -20, -30; 1 2 3 4 5 6 2333333333331 1 2 3"; 

     char* p = txt; 
     int value; 

     while(DigInt(&p, &value)) AddInt(value); 

funkcja kopala integera i przesówala wskaznik  w wejsciu (akurat malo chunkowo ale prosta skladnia)

trzebby dla przykladu zastanowic sie czy kopanie slow byloby uzyteczne i jak mialoby postepowac ze znakami przestankowymi typu nawias przecinek kropka (nawet top jak kopac integery budzi o ile pamietam pewne watpliwosci zwlaszcza dotyczace minusow)

W dniu wtorek, 8 sierpnia 2017 21:41:03 UTC+2 użytkownik (fir) napisał:
> ogolnie pewnie powinienem zastanowic sie jakie lub jakie jeszcze funkcje tam zaimplementowac by latwo sie tego uzywalo i by sie przydawaly - mysle zwlaszcza w szczegolnosci o przypadkupisania kompilatora
> 
> o ile pamietam wczesniej zaimplementowalem funkcje FindFirstInteger(chunk) ktora zwracala pierwszego znalezionego inta - pozniej chyba przerobilem ja na krotsza funkcje o nazwie DigInt() (gdzie dig zastapilo findfirst) a uzywalo sie tego tak
> 
>    char* txt = "some: 100, 200, 300; then: 3, 4, 5, 6, 7, 8, 9; and then: -10, -20, -30; 1 2 3 4 5 6 2333333333331 1 2 3"; 
> 
>      char* p = txt; 
>      int value; 
> 
>      while(DigInt(&p, &value)) AddInt(value); 
> 
> funkcja kopala integera i przesówala wskaznik  w wejsciu (akurat malo chunkowo ale prosta skladnia)
> 
> trzebby dla przykladu zastanowic sie czy kopanie slow byloby uzyteczne i jak mialoby postepowac ze znakami przestankowymi typu nawias przecinek kropka (nawet top jak kopac integery budzi o ile pamietam pewne watpliwosci zwlaszcza dotyczace minusow)

jak ktos ma jakies propozycje dotyczace tych funkcji kopiacych jak to powinno dzialac (a moze zamiasttego cos innego?) to moze wspomniec, pytanie takie sobie ale jak ktos wypoczety moze warto chwile sie pozastanawiac
(mz te funkcje na splitach sa elegantsze ale te kopiace moze tez sie moga przydac)

On Tue, 8 Aug 2017 12:43:23 -0700 (PDT), "(fir)" 
<profesor.fir@gmail.com> wrote:
> jak kopac integery budzi o ile pamietam
> pewne watpliwosci 

Fir, a czy nie powinieneś przekwalifikować się na humanistę? 
Mielibyśmy kolejnego noblistę po Miłoszu i Szymborskiej... 

I nie chcę cię zmartwić, ale to co jest twoim prawdziwym problem to 
nieumiejętność sformułowania jaki to ważny problem rozwiązuje to co 
nam przedstawiasz. Kopiowanie plików? Jest tuzin prostych sposobów, 
włącznie z system("copy a.txt b.txt"). Regex? Już zrobione, są gotowe 
rozwiązania.

Czym twoje pomysły przebijają to co jest w sed czy awk? Komu mogą być 
potrzebne? Dlaczego są lepsze? Od czego lepsze?

W dniu wtorek, 8 sierpnia 2017 22:41:07 UTC+2 użytkownik slawek napisał:
> On Tue, 8 Aug 2017 12:43:23 -0700 (PDT), "(fir)" 
> <profesor.fir@gmail.com> wrote:
> > jak kopac integery budzi o ile pamietam
> > pewne watpliwosci 
> 
> Fir, a czy nie powinieneś przekwalifikować się na humanistę? 
> Mielibyśmy kolejnego noblistę po Miłoszu i Szymborskiej... 
> 
> I nie chcę cię zmartwić, ale to co jest twoim prawdziwym problem to 
> nieumiejętność sformułowania jaki to ważny problem rozwiązuje to co 
> nam przedstawiasz. Kopiowanie plików? Jest tuzin prostych sposobów, 
> włącznie z system("copy a.txt b.txt"). Regex? Już zrobione, są gotowe 
> rozwiązania.
> 
> Czym twoje pomysły przebijają to co jest w sed czy awk? Komu mogą być 
> potrzebne? Dlaczego są lepsze? Od czego lepsze?

bylo napisane:

z tego co wiem jesli podobne zadania do wymienionych stawia sie przed jakims programista czy studentem c to konczy sie na 'rzezbieniu' z ręki (masa watkow zreszta jest na ten temat na roznych grupach c - jak ktos pyta jak zrobic cos co jakos tam zachaczajace o przerobke tekstow to zwykle sie mu podoaje jakies wyrzezbione przyklady)

jakies generyczne rozwiazania w c nie sa mi znane (pewnie jakies są ale raczej jakos nie sa zbyt popularne co widac chocby po tych reakcjach na forach) 

moje rozwiazanie jest pewna kontrą w stosunku do tej sytuacji 

(pominawszy zaprezentowanie tej kontry chodzi tez ew o porozmyslanie jak to jeszcze poprawic - choc moze wybralem zly moment bo ostatnio nie mam na nic sily, mam nadzieje ze to nie jakies poczatki cukrzycy czy cos bo nawet wzrok mi sie diablo pogorszyl litery mi sie rozmywaja w cholere - choc czasem mialem juz podobne fazy zwykle to mija)

jesli odzyskam troche energii pomysle jeszcze
o tym jakich klockow ew potrzebuje to rozwiazanie (bo to jest glowna kwestia - pokazane jak z grubsza jak to ma wygladac chodzi jednek dalej o pewne dopracowanie tak by wycisnac z tego ile sie da - zrobic sicla jak najuzyteczniejszym i najprostszym w uzyciu)

On Tue, 8 Aug 2017 15:01:53 -0700 (PDT), "(fir)" 
<profesor.fir@gmail.com> wrote:
> z tego co wiem jesli podobne zadania do wymienionych stawia sie 
przed jakim=
> s programista czy studentem c to konczy sie na 'rzezbieniu' z ręki 
(ma=

Student ma zrobić nie po to aby złapał króliczka, a nie po to aby go 
złapał. Ma przemęczyć zadanie i w ten sposób nauczył się pętli for i 
takich tam.

A programista z przeciętnym doświadczeniem machnie to w parę godzin 
lub znajdzie coś przez Google.

>  jeszcze poprawic - choc moze wybralem zly moment bo ostatnio nie 
mam na ni=
> c sily, mam nadzieje ze to nie jakies poczatki cukrzycy czy cos bo 
nawet wz=


W twoim przypadku należałoby zacząć od psychiatry.

I to nie jest żart.


> opracowanie tak by wycisnac z tego ile sie da - zrobic sicla jak 
najuzytecz=
> niejszym i najprostszym w uzyciu)

Najpierw: krótki opis do czego ma to służyć.

Potem: dobra dokumentacja.

W dniu środa, 9 sierpnia 2017 16:56:16 UTC+2 użytkownik slawek napisał:
> On Tue, 8 Aug 2017 15:01:53 -0700 (PDT), "(fir)" 
> <profesor.fir@gmail.com> wrote:
> > z tego co wiem jesli podobne zadania do wymienionych stawia sie 
> przed jakim=
> > s programista czy studentem c to konczy sie na 'rzezbieniu' z ręki 
> (ma=
> 
> Student ma zrobić nie po to aby złapał króliczka, a nie po to aby go 
> złapał. Ma przemęczyć zadanie i w ten sposób nauczył się pętli for i 
> takich tam.
> 
> A programista z przeciętnym doświadczeniem machnie to w parę godzin 
> lub znajdzie coś przez Google.
> 
> >  jeszcze poprawic - choc moze wybralem zly moment bo ostatnio nie 
> mam na ni=
> > c sily, mam nadzieje ze to nie jakies poczatki cukrzycy czy cos bo 
> nawet wz=
> 
> 
> W twoim przypadku należałoby zacząć od psychiatry.
> 
> I to nie jest żart.
> 

wiem ze to nie jest zart - kolega jest po prostu prymitywnym burakiem popylajacym w aluminiowym hełmofonie - wiec wszystki eteksty i madrosci sa na adekwatnym poziomie..

juz nie raz wspominalem o tym problemi bo 
kolega tak zenuje grupe tym swoim dziadoskretynieniem ze odechciewa sie tu pisac, zawsze jak sie zmusze i odpowiem cos na cos co i tak balansuje na krawiedzi totalenej glupoty lameriady i nieznosnego
nudziarstwa to i tak zaluje

- tak jest z ludzmi ktorzy sa kompletnie indolentni w temacie podjecia jakich kolwiek sensownych wątkow - i to byl chyba ostatni raz, nie beirz tego do siebie po prostu 
rozmowa z ludzmi na twoim poziomie "nie dziala" chocbym mial najlepsze intencje ,
tak ze sorki



> 
> > opracowanie tak by wycisnac z tego ile sie da - zrobic sicla jak 
> najuzytecz=
> > niejszym i najprostszym w uzyciu)
> 
> Najpierw: krótki opis do czego ma to służyć.
> 
> Potem: dobra dokumentacja.

W dniu środa, 9 sierpnia 2017 17:40:51 UTC+2 użytkownik (fir) napisał:
> 
> wiem ze to nie jest zart - kolega jest po prostu prymitywnym burakiem popylajacym w aluminiowym hełmofonie - wiec wszystki eteksty i madrosci sa na adekwatnym poziomie..
> 
> juz nie raz wspominalem o tym problemi bo 
> kolega tak zenuje grupe tym swoim dziadoskretynieniem ze odechciewa sie tu pisac, zawsze jak sie zmusze i odpowiem cos na cos co i tak balansuje na krawiedzi totalenej glupoty lameriady i nieznosnego
> nudziarstwa to i tak zaluje

dużo prościej jest po prostu ignorować, zamiast się denerwować.
polecam!

W dniu wtorek, 8 sierpnia 2017 21:43:25 UTC+2 użytkownik (fir) napisał:
> W dniu wtorek, 8 sierpnia 2017 21:41:03 UTC+2 użytkownik (fir) napisał:
> > ogolnie pewnie powinienem zastanowic sie jakie lub jakie jeszcze funkcje tam zaimplementowac by latwo sie tego uzywalo i by sie przydawaly - mysle zwlaszcza w szczegolnosci o przypadkupisania kompilatora
> > 
> > o ile pamietam wczesniej zaimplementowalem funkcje FindFirstInteger(chunk) ktora zwracala pierwszego znalezionego inta - pozniej chyba przerobilem ja na krotsza funkcje o nazwie DigInt() (gdzie dig zastapilo findfirst) a uzywalo sie tego tak
> > 
> >    char* txt = "some: 100, 200, 300; then: 3, 4, 5, 6, 7, 8, 9; and then: -10, -20, -30; 1 2 3 4 5 6 2333333333331 1 2 3"; 
> > 
> >      char* p = txt; 
> >      int value; 
> > 
> >      while(DigInt(&p, &value)) AddInt(value); 
> > 
> > funkcja kopala integera i przesówala wskaznik  w wejsciu (akurat malo chunkowo ale prosta skladnia)
> > 
> > trzebby dla przykladu zastanowic sie czy kopanie slow byloby uzyteczne i jak mialoby postepowac ze znakami przestankowymi typu nawias przecinek kropka (nawet top jak kopac integery budzi o ile pamietam pewne watpliwosci zwlaszcza dotyczace minusow)
> 
> jak ktos ma jakies propozycje dotyczace tych funkcji kopiacych jak to powinno dzialac (a moze zamiasttego cos innego?) to moze wspomniec, pytanie takie sobie ale jak ktos wypoczety moze warto chwile sie pozastanawiac
> (mz te funkcje na splitach sa elegantsze ale te kopiace moze tez sie moga przydac)

jak troche o tym myslem to wyszlo mi ze mozna napisac funkcje kilku roznych kategorii 9wejsciem jest zaladowany do ramu tekst)

- np splitujace - splitujacymi nazywam takie ktore dzielą tekst na chunki w ten sposob ze 
podzial jestkompletny/wyczerpujacy tj czunki po zlozeniu utworza wyjsciowy tekst - tekst jest po prostu polamany (splitowaac zas mozna pod owonym kryterjum np po newline albo po spacji albo po granicy digit-nie digit ablbo alafanumaric no alfanumeric)

- collecty - (nazwa wymyslona ad hoc) - produkuje chunki z zawartoscia ale odrzuca 
niektore znaki np mozna skollektowac 9zebrac) 
same grupki ddigitow czyu alfanumerykow (czyli klasyczne slowa) a odrzucic symbole - wtedy kazy chunk bylby kolakcja digitow albo slowem

- mozna by tez robic funkcje typu "find first"/"dig" - moze sa handy ale nie jestem pewien czy przypadkiem splity czy collecty nie sa jednak lepsze (bo te find first wymagaja jakiegos tam zapamietywania/trackowania pozycji)

what else?

(ogolnie problem jest taki ze mozna robic to rozmaicie a warto by sie zastanowic ktore opcje z tego 'rozmaicie' sa naprawde ok a ktore mozna sobie darowac)

W dniu środa, 9 sierpnia 2017 17:50:25 UTC+2 użytkownik godek....@gmail.com napisał:
> W dniu środa, 9 sierpnia 2017 17:40:51 UTC+2 użytkownik (fir) napisał:
> > 
> > wiem ze to nie jest zart - kolega jest po prostu prymitywnym burakiem popylajacym w aluminiowym hełmofonie - wiec wszystki eteksty i madrosci sa na adekwatnym poziomie..
> > 
> > juz nie raz wspominalem o tym problemi bo 
> > kolega tak zenuje grupe tym swoim dziadoskretynieniem ze odechciewa sie tu pisac, zawsze jak sie zmusze i odpowiem cos na cos co i tak balansuje na krawiedzi totalenej glupoty lameriady i nieznosnego
> > nudziarstwa to i tak zaluje
> 
> dużo prościej jest po prostu ignorować, zamiast się denerwować.
> polecam!

nie denerwuje sie, szczerze mowiac to przyzwyczailem sie juz do tych prymitywnych kmiotow - czuje jednak pewien niesmak - taki prostego typu: np przychodzisz gdzies na uczelnie sie czegos nauczyc podyskutowac o fizyce a spotykasz dziadow w papierowych czapkach ktorzy klekoczą ci swoje dziadowskie glupoty - wiem ze moge ignorowac i w sumie nic innego nie robie, jednak pewne wyjasnienie uwazam nawet dziadowi sie nalezy, by mial choc teoretyczna sznse zmądrzec , wazne tez by zwrocic uwage na to co jest na tej grupie ok/ciekawe i czym warto sie zajmowac a co jest jakims natrętnym dziadostwem bez merytorycznej wartosci :C

> 
> jak troche o tym myslem to wyszlo mi ze mozna napisac funkcje kilku roznych kategorii 9wejsciem jest zaladowany do ramu tekst)
> 
> - np splitujace - splitujacymi nazywam takie ktore dzielą tekst na chunki w ten sposob ze 
> podzial jestkompletny/wyczerpujacy tj czunki po zlozeniu utworza wyjsciowy tekst - tekst jest po prostu polamany (splitowaac zas mozna pod owonym kryterjum np po newline albo po spacji albo po granicy digit-nie digit ablbo alafanumaric no alfanumeric)
> 
> - collecty - (nazwa wymyslona ad hoc) - produkuje chunki z zawartoscia ale odrzuca 
> niektore znaki np mozna skollektowac 9zebrac) 
> same grupki ddigitow czyu alfanumerykow (czyli klasyczne slowa) a odrzucic symbole - wtedy kazy chunk bylby kolakcja digitow albo slowem
> 
> - mozna by tez robic funkcje typu "find first"/"dig" - moze sa handy ale nie jestem pewien czy przypadkiem splity czy collecty nie sa jednak lepsze (bo te find first wymagaja jakiegos tam zapamietywania/trackowania pozycji)
> 
> what else?
> 
> (ogolnie problem jest taki ze mozna robic to rozmaicie a warto by sie zastanowic ktore opcje z tego 'rozmaicie' sa naprawde ok a ktore mozna sobie darowac)

wiecej o tym jeszcze troche pozniej

On Wed, 9 Aug 2017 08:40:49 -0700 (PDT), "(fir)" 
<profesor.fir@gmail.com> wrote:
> wiem ze to nie jest zart

To jest już pierwszy dobry krok.

Teraz trzeba po prostu iść do lekarza.


> kolega jest po prostu prymitywnym burakiem
> popylajacym w aluminiowym hełmofonie

Na literata się nadajesz. Na programistę nie.

W dniu środa, 9 sierpnia 2017 18:24:04 UTC+2 użytkownik (fir) napisał:
> > 
> > jak troche o tym myslem to wyszlo mi ze mozna napisac funkcje kilku roznych kategorii 9wejsciem jest zaladowany do ramu tekst)
> > 
> > - np splitujace - splitujacymi nazywam takie ktore dzielą tekst na chunki w ten sposob ze 
> > podzial jestkompletny/wyczerpujacy tj czunki po zlozeniu utworza wyjsciowy tekst - tekst jest po prostu polamany (splitowaac zas mozna pod owonym kryterjum np po newline albo po spacji albo po granicy digit-nie digit ablbo alafanumaric no alfanumeric)
> > 
> > - collecty - (nazwa wymyslona ad hoc) - produkuje chunki z zawartoscia ale odrzuca 
> > niektore znaki np mozna skollektowac 9zebrac) 
> > same grupki ddigitow czyu alfanumerykow (czyli klasyczne slowa) a odrzucic symbole - wtedy kazy chunk bylby kolakcja digitow albo slowem
> > 
> > - mozna by tez robic funkcje typu "find first"/"dig" - moze sa handy ale nie jestem pewien czy przypadkiem splity czy collecty nie sa jednak lepsze (bo te find first wymagaja jakiegos tam zapamietywania/trackowania pozycji)
> > 
> > what else?
> > 
> > (ogolnie problem jest taki ze mozna robic to rozmaicie a warto by sie zastanowic ktore opcje z tego 'rozmaicie' sa naprawde ok a ktore mozna sobie darowac)
> 
> wiecej o tym jeszcze troche pozniej

ostatnio wspominalem ze np funkcje do rysowania lini na ekranie mozna przerobic na posac z "generatorem"

while( DrawNextPixel(x_goal, y_goal) );

cos w tym stylu (kazde wywolanie wysuje czy tam wyzanacza jeden pixel) jest t mz postac jakby bardziej ogolna [co prawda niektorych wnioskow nie pamietam]

tutaj z tymi splitami vs funkcjami findfirst 
jest chyba tez jakas analogia (findfirsty sa jakby generatorami) tyle ze tutaj splity wydaja mi sie chwilowo wlasnie lepsze niz te generatory

aczkolwiek jest to mysl dosyc poboczna, zastanawiam sie czy taki sicl nie potrzebuje wogole czegos jakby innego (nowego) niz to
wspomniane.. 

czego i dlaczego?

W dniu środa, 9 sierpnia 2017 22:43:21 UTC+2 użytkownik (fir) napisał:
> while( DrawNextPixel(x_goal, y_goal) );
> 
> cos w tym stylu (kazde wywolanie wysuje czy tam wyzanacza jeden pixel) jest t mz postac jakby bardziej ogolna 

bardziej ogolna bylaby 

while( DrawPixel (NextPixel (goal)))

chodzi o odzielenie wyznaczanie pixeli od rysowania (i w moim kodzie tak bylo bo czasem potrzebyowalem wynikow bressenhama 
nap do algorytmu sprawdzania widocznosci a nie konkretnie do rysowania))

while tutaj tez powinno byc jakaz mechanika raczej wewnetrzną w jezyku tak by mozna pisac

DrawPixel(NewPixel(goal));

lub przynajmniej

repeating DrawPixel(NewPixel(goal));

bez martwienie sie przekazywaniem warunkow końca co jest nieporeczne

ale poki co c czegos takiego nie przewiduje

(dygresja)
[te rozmyslanie nad jezykiem to troche meka wiec chyba lepiej wrocic do sicla ]

W dniu środa, 9 sierpnia 2017 22:52:17 UTC+2 użytkownik (fir) napisał:
> W dniu środa, 9 sierpnia 2017 22:43:21 UTC+2 użytkownik (fir) napisał:
> > while( DrawNextPixel(x_goal, y_goal) );
> > 
> > cos w tym stylu (kazde wywolanie wysuje czy tam wyzanacza jeden pixel) jest t mz postac jakby bardziej ogolna 
> 
> bardziej ogolna bylaby 
> 
> while( DrawPixel (NextPixel (goal)))
> 
> chodzi o odzielenie wyznaczanie pixeli od rysowania (i w moim kodzie tak bylo bo czasem potrzebyowalem wynikow bressenhama 
> nap do algorytmu sprawdzania widocznosci a nie konkretnie do rysowania))
> 
> while tutaj tez powinno byc jakaz mechanika raczej wewnetrzną w jezyku tak by mozna pisac
> 
> DrawPixel(NewPixel(goal));
> 
> lub przynajmniej
> 
> repeating DrawPixel(NewPixel(goal));
> 
> bez martwienie sie przekazywaniem warunkow końca co jest nieporeczne
> 
> ale poki co c czegos takiego nie przewiduje
> 
> (dygresja)
> [te rozmyslanie nad jezykiem to troche meka wiec chyba lepiej wrocic do sicla ]

w sumie mozna by sie zastanowic nad uzytecznymi funkcjami sicle w kontekscie dwu 
troche znanych mi zadań
- pisania asemblera
- pisanie kompilatora c

o asmie chyba juz kiedys myslelem 

poczatek jak zwykle



#include "small-icl.c" 

int main() 
{ 

  chunk asm = LoadChunk("some.asm"); 

  chunks lines = SplitAfterCharacter(asm, 0x0a); 

  int asm_lines_length = ChunksLength(lines); 

  CreateFile("asm output.bin"); 

    for(int i=0; i<asm_lines_length; i++) 
    { 
     // use lines.beg[i]   

    }

  return 0; 

} 

w srodku trzebby chyba dac po prostu splitowanie po slowach i switche.. ale o tym troche pozniej bo jestem zmeczony jak zwykle

fir

W dniu sobota, 12 sierpnia 2017 12:17:53 UTC+2 użytkownik (fir) napisał:
> W dniu środa, 9 sierpnia 2017 22:52:17 UTC+2 użytkownik (fir) napisał:
> > W dniu środa, 9 sierpnia 2017 22:43:21 UTC+2 użytkownik (fir) napisał:
> > > while( DrawNextPixel(x_goal, y_goal) );
> > > 
> > > cos w tym stylu (kazde wywolanie wysuje czy tam wyzanacza jeden pixel) jest t mz postac jakby bardziej ogolna 
> > 
> > bardziej ogolna bylaby 
> > 
> > while( DrawPixel (NextPixel (goal)))
> > 
> > chodzi o odzielenie wyznaczanie pixeli od rysowania (i w moim kodzie tak bylo bo czasem potrzebyowalem wynikow bressenhama 
> > nap do algorytmu sprawdzania widocznosci a nie konkretnie do rysowania))
> > 
> > while tutaj tez powinno byc jakaz mechanika raczej wewnetrzną w jezyku tak by mozna pisac
> > 
> > DrawPixel(NewPixel(goal));
> > 
> > lub przynajmniej
> > 
> > repeating DrawPixel(NewPixel(goal));
> > 
> > bez martwienie sie przekazywaniem warunkow końca co jest nieporeczne
> > 
> > ale poki co c czegos takiego nie przewiduje
> > 
> > (dygresja)
> > [te rozmyslanie nad jezykiem to troche meka wiec chyba lepiej wrocic do sicla ]
> 
> w sumie mozna by sie zastanowic nad uzytecznymi funkcjami sicle w kontekscie dwu 
> troche znanych mi zadań
> - pisania asemblera
> - pisanie kompilatora c
> 
> o asmie chyba juz kiedys myslelem 
> 
> poczatek jak zwykle
> 
> 
> 
> #include "small-icl.c" 
> 
> int main() 
> { 
> 
>   chunk asm = LoadChunk("some.asm"); 
> 
>   chunks lines = SplitAfterCharacter(asm, 0x0a); 
> 
>   int asm_lines_length = ChunksLength(lines); 
> 
>   CreateFile("asm output.bin"); 
> 
>     for(int i=0; i<asm_lines_length; i++) 
>     { 
>      // use lines.beg[i]   
> 


sorry powinno byc raczej lines.first[i] (pisalem o tych pomylkach)

z tego co kojarze wiec powino byc 

 chunks words = SplitOnWords(lines.first[i]);

 dalej raczej przydalyby sie (jesli mowimy ciagle o ogolnych funkcjach tekstowych) pewnie sprawdzenia czy dane slowo jest slowem czy liczbą (cos w stylu funkcji check if number (?) trzebby sie tez zdecydowac czy to splitowanie na slowa ma uwzgledniac slowa z symbolami w srodku (ttaj pewnie tak i pewnie to jest troche nistandardowe, dzilenie na slowa pewnie by szlo po spacjach czyli moze lepiej uzyc SplitOnWordsByWhitespaces())

moze pozniej skrobne kod na sucho bo kompilowac mi sie nie chce (pisanie na suchop swoja droga wartoby sie pewnie pouczyc bo podejrzewam moze byc szybkim sposobem pisania)

 


>     }
> 
>   return 0; 
> 
> } 
> 
> w srodku trzebby chyba dac po prostu splitowanie po slowach i switche.. ale o tym troche pozniej bo jestem zmeczony jak zwykle
> 
> fir

W dniu sobota, 12 sierpnia 2017 12:29:24 UTC+2 użytkownik (fir) napisał:
> W dniu sobota, 12 sierpnia 2017 12:17:53 UTC+2 użytkownik (fir) napisał:
> > W dniu środa, 9 sierpnia 2017 22:52:17 UTC+2 użytkownik (fir) napisał:
> > > W dniu środa, 9 sierpnia 2017 22:43:21 UTC+2 użytkownik (fir) napisał:
> > > > while( DrawNextPixel(x_goal, y_goal) );
> > > > 
> > > > cos w tym stylu (kazde wywolanie wysuje czy tam wyzanacza jeden pixel) jest t mz postac jakby bardziej ogolna 
> > > 
> > > bardziej ogolna bylaby 
> > > 
> > > while( DrawPixel (NextPixel (goal)))
> > > 
> > > chodzi o odzielenie wyznaczanie pixeli od rysowania (i w moim kodzie tak bylo bo czasem potrzebyowalem wynikow bressenhama 
> > > nap do algorytmu sprawdzania widocznosci a nie konkretnie do rysowania))
> > > 
> > > while tutaj tez powinno byc jakaz mechanika raczej wewnetrzną w jezyku tak by mozna pisac
> > > 
> > > DrawPixel(NewPixel(goal));
> > > 
> > > lub przynajmniej
> > > 
> > > repeating DrawPixel(NewPixel(goal));
> > > 
> > > bez martwienie sie przekazywaniem warunkow końca co jest nieporeczne
> > > 
> > > ale poki co c czegos takiego nie przewiduje
> > > 
> > > (dygresja)
> > > [te rozmyslanie nad jezykiem to troche meka wiec chyba lepiej wrocic do sicla ]
> > 
> > w sumie mozna by sie zastanowic nad uzytecznymi funkcjami sicle w kontekscie dwu 
> > troche znanych mi zadań
> > - pisania asemblera
> > - pisanie kompilatora c
> > 
> > o asmie chyba juz kiedys myslelem 
> > 
> > poczatek jak zwykle
> > 
> > 
> > 
> > #include "small-icl.c" 
> > 
> > int main() 
> > { 
> > 
> >   chunk asm = LoadChunk("some.asm"); 
> > 
> >   chunks lines = SplitAfterCharacter(asm, 0x0a); 
> > 
> >   int asm_lines_length = ChunksLength(lines); 
> > 
> >   CreateFile("asm output.bin"); 
> > 
> >     for(int i=0; i<asm_lines_length; i++) 
> >     { 
> >      // use lines.beg[i]   
> > 
> 
> 
> sorry powinno byc raczej lines.first[i] (pisalem o tych pomylkach)
> 
> z tego co kojarze wiec powino byc 
> 
>  chunks words = SplitOnWords(lines.first[i]);
> 
>  dalej raczej przydalyby sie (jesli mowimy ciagle o ogolnych funkcjach tekstowych) pewnie sprawdzenia czy dane slowo jest slowem czy liczbą (cos w stylu funkcji check if number (?) trzebby sie tez zdecydowac czy to splitowanie na slowa ma uwzgledniac slowa z symbolami w srodku (ttaj pewnie tak i pewnie to jest troche nistandardowe, dzilenie na slowa pewnie by szlo po spacjach czyli moze lepiej uzyc SplitOnWordsByWhitespaces())
> 
> moze pozniej skrobne kod na sucho bo kompilowac mi sie nie chce (pisanie na suchop swoja droga wartoby sie pewnie pouczyc bo podejrzewam moze byc szybkim sposobem pisania)
> 
>  
> 
> 
> >     }
> > 
> >   return 0; 
> > 
> > } 
> > 
> > w srodku trzebby chyba dac po prostu splitowanie po slowach i switche.. ale o tym troche pozniej bo jestem zmeczony jak zwykle
> > 

w sumie jak widac napisanie asemblera (gdzie mam na mysli flushowanie hexa na output) jest raczej bardzo latwe - niewiele jest to trudniejsze niz zliczenie wystapien liter w pliku

ciagle troche gorzej z wygenerowaniem tej peowkiej obwoluty (o czym juz nieraz wspominalem) inny problem to tez problem tego 
ze to co kiedys wydawalo mi sie 'fascynujace' (jak napisanie sobie asemblera) dzis wydaje mi sie 'nudne' (oba te slowa nie sa zbyt dokladne ale nieststy roznica jest, slowo 'nudne' jest tu chyba nawet niedostateczne
ale chyba nie mam sily opisywac i uzmyslawiac 
sobie tego jaki jest dzis moj psychologiczny stosunek do pisania asemblera)

tak czy owak bede jednak musial to chyba 
(ten asembler) napisac i to chybe powinienem to zrobic najpozniej do konca roku (samej roboty przewiduje na maksymalnie tydzien ale
bedzie trzeba uwazac chyba by sie nie zniechcecic w polowie bo jak sie zniechcece to znowu odloze ta robote na pol roku i wtedy si enie wyrobie : o )

we will see, moze przysiade w jakis chlodniejszy dzien

W dniu wtorek, 15 sierpnia 2017 13:56:17 UTC+2 użytkownik (fir) napisał:
> W dniu sobota, 12 sierpnia 2017 12:29:24 UTC+2 użytkownik (fir) napisał:
> > W dniu sobota, 12 sierpnia 2017 12:17:53 UTC+2 użytkownik (fir) napisał:
> > > W dniu środa, 9 sierpnia 2017 22:52:17 UTC+2 użytkownik (fir) napisał:
> > > > W dniu środa, 9 sierpnia 2017 22:43:21 UTC+2 użytkownik (fir) napisał:
> > > > > while( DrawNextPixel(x_goal, y_goal) );
> > > > > 
> > > > > cos w tym stylu (kazde wywolanie wysuje czy tam wyzanacza jeden pixel) jest t mz postac jakby bardziej ogolna 
> > > > 
> > > > bardziej ogolna bylaby 
> > > > 
> > > > while( DrawPixel (NextPixel (goal)))
> > > > 
> > > > chodzi o odzielenie wyznaczanie pixeli od rysowania (i w moim kodzie tak bylo bo czasem potrzebyowalem wynikow bressenhama 
> > > > nap do algorytmu sprawdzania widocznosci a nie konkretnie do rysowania))
> > > > 
> > > > while tutaj tez powinno byc jakaz mechanika raczej wewnetrzną w jezyku tak by mozna pisac
> > > > 
> > > > DrawPixel(NewPixel(goal));
> > > > 
> > > > lub przynajmniej
> > > > 
> > > > repeating DrawPixel(NewPixel(goal));
> > > > 
> > > > bez martwienie sie przekazywaniem warunkow końca co jest nieporeczne
> > > > 
> > > > ale poki co c czegos takiego nie przewiduje
> > > > 
> > > > (dygresja)
> > > > [te rozmyslanie nad jezykiem to troche meka wiec chyba lepiej wrocic do sicla ]
> > > 
> > > w sumie mozna by sie zastanowic nad uzytecznymi funkcjami sicle w kontekscie dwu 
> > > troche znanych mi zadań
> > > - pisania asemblera
> > > - pisanie kompilatora c
> > > 
> > > o asmie chyba juz kiedys myslelem 
> > > 
> > > poczatek jak zwykle
> > > 
> > > 
> > > 
> > > #include "small-icl.c" 
> > > 
> > > int main() 
> > > { 
> > > 
> > >   chunk asm = LoadChunk("some.asm"); 
> > > 
> > >   chunks lines = SplitAfterCharacter(asm, 0x0a); 
> > > 
> > >   int asm_lines_length = ChunksLength(lines); 
> > > 
> > >   CreateFile("asm output.bin"); 
> > > 
> > >     for(int i=0; i<asm_lines_length; i++) 
> > >     { 
> > >      // use lines.beg[i]   
> > > 
> > 
> > 
> > sorry powinno byc raczej lines.first[i] (pisalem o tych pomylkach)
> > 
> > z tego co kojarze wiec powino byc 
> > 
> >  chunks words = SplitOnWords(lines.first[i]);
> > 
> >  dalej raczej przydalyby sie (jesli mowimy ciagle o ogolnych funkcjach tekstowych) pewnie sprawdzenia czy dane slowo jest slowem czy liczbą (cos w stylu funkcji check if number (?) trzebby sie tez zdecydowac czy to splitowanie na slowa ma uwzgledniac slowa z symbolami w srodku (ttaj pewnie tak i pewnie to jest troche nistandardowe, dzilenie na slowa pewnie by szlo po spacjach czyli moze lepiej uzyc SplitOnWordsByWhitespaces())
> > 
> > moze pozniej skrobne kod na sucho bo kompilowac mi sie nie chce (pisanie na suchop swoja droga wartoby sie pewnie pouczyc bo podejrzewam moze byc szybkim sposobem pisania)
> > 
> >  
> > 
> > 
> > >     }
> > > 
> > >   return 0; 
> > > 
> > > } 
> > > 
> > > w srodku trzebby chyba dac po prostu splitowanie po slowach i switche.. ale o tym troche pozniej bo jestem zmeczony jak zwykle
> > > 
> 
> w sumie jak widac napisanie asemblera (gdzie mam na mysli flushowanie hexa na output) jest raczej bardzo latwe - niewiele jest to trudniejsze niz zliczenie wystapien liter w pliku
> 
> ciagle troche gorzej z wygenerowaniem tej peowkiej obwoluty (o czym juz nieraz wspominalem) inny problem to tez problem tego 
> ze to co kiedys wydawalo mi sie 'fascynujace' (jak napisanie sobie asemblera) dzis wydaje mi sie 'nudne' (oba te slowa nie sa zbyt dokladne ale nieststy roznica jest, slowo 'nudne' jest tu chyba nawet niedostateczne
> ale chyba nie mam sily opisywac i uzmyslawiac 
> sobie tego jaki jest dzis moj psychologiczny stosunek do pisania asemblera)
> 
> tak czy owak bede jednak musial to chyba 
> (ten asembler) napisac i to chybe powinienem to zrobic najpozniej do konca roku (samej roboty przewiduje na maksymalnie tydzien ale
> bedzie trzeba uwazac chyba by sie nie zniechcecic w polowie bo jak sie zniechcece to znowu odloze ta robote na pol roku i wtedy si enie wyrobie : o )
> 
> we will see, moze przysiade w jakis chlodniejszy dzien

chyba zebym zrobil wczesniej troche roboty na sucho? (przez robote na sucho mam na mysli glownie czytanie i ew przemyslanie/przedyskutowanie paru wnioskow bez klepania i odpalania kompilatora)

co prawda od roboty na sucho tez mozna, 
wydaje sie, zniechęcic - robota na sucho 
jest chyba postrzegana jako bardziej lajtowa 
niz typowa mokra robota, jak to jest naprawde to nie wiem