같이 일한 동생인 정원민군의 삽질의 산물.
감사합니다 ㅠ.ㅠ



f4 key -> 파일탐색기
f8 key -> 함수 리스트

좌하단 -> 열린 파일

기타 마우스를 써도 되고.. vim의 기능은 ctrl w + w 를 써도 된다.
ctrl + ] 를 쓰면 ctag + cscope로 동작한다.



첨부된 파일을 자기 계정에 푼다.

/root/에도 풀어놓는다.
.vimrc도 /root/.vimrc에 위치하도록 한다.





참고로 리눅스에서 스크린샷 쉽게 찍으려면 compiz에서 스크린샷을 켜고.
윈도우 키 + 좌클릭 한 상태에서 드래그하면 파일이 생긴다.

wine, ultraedit, ctags, linux


와인으로 울트라에디트를 돌릴 때..
ctag를 쓰고 싶다면.. 그냥 리눅스 ctag를 쓰면 된다.

ctags -R ./ 등으로 tags를 만들거나
커널이라면
make tags로 태그 파일을 만든 후,


울트라에디터에서
project->ctags options 의 default tagfile에 방금 만든 tag 파일을 지정하면 된다.

따로 프로젝트 안 만들어도 된다.
프로젝트 만들면 여러 태그를 관리할 수 있긴 하다.


tag 찾기 키는 F11이다.

이제 앞 키 뒷 키를 ctrl [, ] 로 각각 바인딩하자.
소스 인사이트처럼 ctrl <, > 로 바인딩 하던가.. vim 처럼 ctrl ], ctrl t 로 바인딩 해도 좋다.

와인에 소스 인사이트가 있어도..

vim에 ctag은 피할 수 없는 숙명..

apt-get install ctags



우분투의 기본 vim은 기능 다 빠진 vim.tiny 이므로

apt-get install vim



커널에서

make tags한다.
이렇게 하면 태그 파일이 있는 커널 소스 루트에서만 먹응께..

echo set tags+=$PWD/tags >> $HOME/.vimrc



이건 걍 스크립트로 만들어놓고 쓰자.


#!/bin/sh
echo set tags+=$PWD/tags >> $HOME/.vimrc



실행 퍼미션 부여해서 /usr/bin 등에 복사해 줌..








이제 커널 소스에서.. ctrl+] 키로 점프.. ctrl + t 키로 돌아오기를 쓰자.
아참.. 대문자 K로 맨 페이지도 들락거립시다;; 알면서 꼭 새 터미널에서 하는 악습;;


나는 vim에서 cscope를 사용하지 않으므로.. 나처럼 그냥 심볼 검색기로 사용하는 사람들은..
다음 스크립트로 파일만 만들고 터미널에 하나 띄워놓고 보면 된다.

http://mustafa.tistory.com/19

간단한 이중 포인터 예제.

포인터를 다수 써야 하는 데,
이걸 포인터의 배열로 쓰기는 싫고..
힙에서 끌어오고 싶을 때는..

이중 포인터를 쓴다.

뭐 대부분은 굳이 몇 바이트까지 바득바득 쥐어짜는 것 보다는..
전역변수를 잡는 것이 성능에서 유리하지만..

소프트웨어 신뢰성도 그렇고 폼도 안 나니깐..


#include <stdio.h> #include <stdlib.h> #include <time.h> main() {         int i;         time_t tt;         char **pp;         char **temp;         pp = (char **)malloc(30000 * sizeof(char *));         srandom(time(&tt));         temp = pp;         for (i = 0; i < 30000; i++) { // 셋 다 동치임을 이해할 수 있어야 함, //              pp[i] = malloc(random() % 72); //              *(pp + i) = malloc(random() % 72);                 *temp = malloc(random() % 72);                 temp++;         }         for (i = 0; i < 30000; i++) {                 free(pp[i]);  // 이렇게 해지해되 된다능.         }         free(pp); }

옛날엔 어떻게 했는지 기억도 안 나고..



해야 할 일이 있어서 해봤다.
크로스 빌드가 아니라 걍 하면 되는듯.

하는 법 : 매뉴얼 보고 하면 된다. 끗.




.
.
.

매뉴얼 보기 귀찮은 사람은..

1. 매뉴얼 / http://gcc.gnu.org/install/

2. 4.6 다운로드 / http://ftp.gnu.org/pub/pub/gnu/gcc/
; 참고 / svn 으로 다운로드 받으면 천년 걸림... -_-;

3. ./configure 하면 에러난다.

4. ftp://gcc.gnu.org/pub/gcc/infrastructure/ 방문한다.

5. gmp, 4.3.2 다운로드
./configure
make
make check
make install

6. mpfr 2.4.2 다운로드
./configure
make
make check
make install

7. mpc-0.8.1 다운로드
./configure
make
make check
make install

8. 에러나면 ldconfig 한 번 때려본다. /etc/ld.so.conf 에 자료만 추가되고 ldconfig 명령이 실행이 안 된 것 같다.

9. gcc 디렉토리로 들어가서 다시 ./configure, make make install 한다.

끗.

참고 / 크로스 빌드는 케겔운동 부터 시작하자 / http://www.kegel.com/crosstool/



linux from scratch
http://www.linuxfromscratch.org/lfs/vi ··· dex.html


glibc 의 모든 것
http://www.gnu.org/s/hello/manual/libc/index.html#Top

LFS w-get 하기
http://www.linuxfromscratch.org/lfs/view/development/w붙여쓰자get-list

옛 블로그 보관자료.


원 출처 링크는 지오씨티라서...
오래전에 개발살..





추억 속의 지오씨티여..

------------------------------------------------------------------------
		     Introduction to GCC Inline Asm

			    By Robin Miyagi
			    
	    http://www.geocities.com/SiliconValley/Ridge/2544/ 
	   
			Wed Sep 13 19:18:50 UTC
------------------------------------------------------------------------

* `as' and AT&T Syntax
------------------------------------------------------------------------

    The  GNU C  Compiler uses  the assembler  `as' as  a  backend.  This
    assembler uses AT&T syntax.  Here is a brief overview of the syntax.
    For  more   information  about  `as',   look  in  the   system  info
    documentation.
    
    - as uses the form;
    
        nemonic source, destination (opposite to intel syntax)
    
    - as  prefixes registers  with `%',  and prefixes  numeric constants
      with `$'.
    
    - Effective addresses use the following general syntax;
    
        SECTION:DISP(BASE, INDEX, SCALE)
    
      As in other assemblers, any one or more of these components may be
      ommited,  within constraints  of valid  intel  instruction syntax.
      The above syntax was shamelessly  copied from the info pages under
      the i386 dependant features of as.
    
    - As suffixes  the assembler nemonics  with a letter  indicating the
      operand sizes  ('b' for  byte, 'w' for  word, 'l' for  long word).
      Read  the info  pages for  more information  such as  suffixes for
      floating point registers etc.
    
    Example code (raw asm, not gcc inline)
    --------------------------------------------------------------------
    movl %eax, %ebx     /* intel: mov ebx, eax */                       
    movl $56, %esi      /* intel: mov esi, 56 */                        
    movl %ecx, $label(%edx,%ebx,$4) /* intel: mov [edx+ebx*4+4], ecx */ 
    movb %ah, (%ebx)    /* intel: mov [ebx], ah */                      
    --------------------------------------------------------------------
    
    Notice that  as uses  C comment  syntax.  As can  also use  `#' that
    works the same way as `;' in most other intel assemblers.
    
    Above code in inline asm
    --------------------------------------------------------------------
      __asm__ ("movl %eax, %ebx\n\t"
	       "movl $56, %esi\n\t"
	       "movl %ecx, $label(%edx,%ebx,$4)\n\t"
	       "movb %ah, (%ebx)");
    --------------------------------------------------------------------
    
    Notice that in the above example, the __ prefixing and suffixing asm
    are not neccesary,  but may prevent name conflicts  in your program.
    You can read  more about this in [C  enxtensions|extended asm] under
    the info documentation  for gcc.
    
    Also notice the '\n\t' at the  end of each line except the last, and
    that each  line is  inclosed in quotes.   This is because  gcc sends
    each as instruction to as  as a string.  The newline/tab combination
    is required so that the lines are fed to as according to the correct
    format  (recall that  each line  in asssembler  is indented  one tab
    stop, generally 8 characters).
    
    You can also use labels from  your C code (variable names and such).
    In  Linux, underscores prefixing  C variables  are not  Necessary in
    your code; e.g.
    
       int main (void) {
    	   int Cvariable;	
    	   __asm__ ("movl Cvariable, %eax"); # Cvariable contents > eax
	   __asm__ ("movl $Cvariable, %ebx"); # ebx ---> Cvariable
       }
    
     Notice that  in the documentation for  DJGPP, it will  say that the
     underscore is  necessary.  The difference is do  to the differences
     between  djgpp RDOFF  format  and  Linux's ELF  format.   I am  not
     certain, but I think that the old Linux a.out object files also use
     underscores (please contact me if you have comments on this).

* Extended Asm
------------------------------------------------------------------------

    The code  in the  above example will  most probably  cause conflicts
    with the rest of your C code, especially with compiler optimizations
    (recall that gcc is an  optimizing compiler).  Any registers used in
    your code may be used to hold  C variable data from the rest of your
    program.  You  would not want  to inadvertently modify  the register
    without telling gcc to take  this into account when compiling.  This
    is where extended asm comes into play.

    Extended  asm   allows  you  to  specify   input  registers,  output
    registers, and clobbered registers  as interface information to your
    block of asm code.  You can even allow gcc to choose actual physical
    CPU   registers  automatically,   that  probably   fit   into  gcc's
    optimization  scheme better.  An  example will  demonstrate extended
    asm better.

    Example code
    --------------------------------------------------------------------
     #include < stdlib.h >
    
    int main (void) {
      int operand1, operand2, sum, accumulator;
    
      operand1 = rand (); operand2 = rand ();
      
      __asm__ ("movl %1, %0\n\t"
      	       "addl %2, %0"
	       : "=r" (sum)			/* output operands */
	       : "r" (operand1), "r" (operand2) /* input operands */
	       : "0");				/* clobbered operands */
      
      accumulator = sum;
      
      __asm__ ("addl %1, %0\n\t"
	       "addl %2, %0"
	       : "=r" (accumulator)
	       : "0" (accumulator), "g" (operand1), "r" (operand2)
	       : "0");
      return accumulator;
    }
     --------------------------------------------------------------------

    The  first  the line  that  begins  with  ':' specifies  the  output
    operands,  the second  indicates the  input operands,  and  the last
    indicates  the  clobbered  operands.   the  "r", "g",  and  "0"  are
    examples of  constraints.  Output constraints must  be prefixed with
    an '=',  as in  "=r" (= is  a constraint modifier,  indicating write
    only).  Input  and output constraints  must have its  correspoding C
    argument included with it enclosed  in parenthisis (this must not be
    done with  the clobbered line, I  figured this out after  an hour of
    fustration).  "r"  means assign a general register  register for the
    argument,  "g" means  to assign  any register,  memory  or immediate
    integer for this.

    Notice the use of "0", "1",  "2" etc.  These are used to ensure that
    when the  same variable is indicated  in more than one  place in the
    extended asm, that is variable is only `mapped' to one register.  If
    you had merely used another "r" for example, the compiler may or may
    not assign  this variable to the  same register as  before.  You can
    surmise from this that "0"  refers to the first register assigned to
    a variable,  "1" the second etc.   When these registers  are used in
    the asm code, they are refered to as "%0", "%1" etc.

    Summary of  constraints. (copied from the  system info documentation
    for gcc)
    --------------------------------------------------------------------
    `m'

        A memory operand  is allowed, with any kind  of address that the
    	machine supports in general.
    
    `o'

        A  memory  operand  is  allowed,  but only  if  the  address  is
	"offsettable".    This  means  that   adding  a   small  integer
	(actually, the width  in bytes of the operand,  as determined by
	its machine mode) may be added  to the address and the result is
	also a valid memory address.
    
	For example, an address which  is constant is offsettable; so is
	an address that is the sum of a register and a constant (as long
	as  a slightly  larger  constant  is also  within  the range  of
	address-offsets supported by  the machine); but an autoincrement
	or autodecrement  address is not  offsettable.  More complicated
	indirect/indexed  addresses  may   or  may  not  be  offsettable
	depending  on  the  other  addressing  modes  that  the  machine
	supports.
    
	Note that in  an output operand which can  be matched by another
	operand,  the   constraint  letter   `o'  is  valid   only  when
	accompanied by both `<'  (if the target machine has predecrement
	addressing)  and `>'  (if  the target  machine has  preincrement
	addressing).
    
    `V'

        A  memory operand  that  is not  offsettable.   In other  words,
	anything  that would  fit the  `m'  constraint but  not the  `o'
	constraint.
    
    `<'

        A   memory  operand   with   autodecrement  addressing   (either
	predecrement or postdecrement) is allowed.
    
    `>'

        A   memory  operand   with   autoincrement  addressing   (either
	preincrement or postincrement) is allowed.
    
    `r'

        A register operand  is allowed provided that it  is in a general
	register.
    
    `d', `a', `f', ...
    
	Other  letters can  be defined  in machine-dependent  fashion to
	stand for particular classes of registers.  `d', `a' and `f' are
	defined  on  the 68000/68020  to  stand  for  data, address  and
	floating point registers.
    
    `i'
    
	An  immediate  integer  operand  (one with  constant  value)  is
	allowed.  This includes symbolic  constants whose values will be
	known only at assembly time.
    
    `n'
    
	An  immediate integer  operand  with a  known  numeric value  is
	allowed.   Many systems  cannot support  assembly-time constants
	for  operands less  than  a word  wide.   Constraints for  these
	operands should use `n' rather than `i'.
    
    `I', `J', `K', ... `P'
    
	Other letters in  the range `I' through `P' may  be defined in a
	machine-dependent fashion  to permit immediate  integer operands
	with explicit integer values  in specified ranges.  For example,
	on the 68000, `I' is defined  to stand for the range of values 1
	to 8.  This is the range permitted as a shift count in the shift
	instructions.
    
    `E'

        An immediate  floating operand (expression  code `const_double')
	is allowed, but only if  the target floating point format is the
	same  as that  of the  host machine  (on which  the  compiler is
	running).
    
    `F'
    
	An immediate  floating operand (expression  code `const_double')
	is allowed.
    
    `G', `H'
    
	`G' and  `H' may  be defined in  a machine-dependent  fashion to
	permit  immediate  floating  operands  in particular  ranges  of
	values.
    
    `s'
    
	An  immediate integer  operand whose  value is  not  an explicit
	integer is allowed.
    	
	This might appear strange; if  an insn allows a constant operand
	with a value not known  at compile time, it certainly must allow
	any known value.   So why use `s' instead  of `i'?  Sometimes it
	allows better code to be generated.
    	
	For  example, on  the  68000  in a  fullword  instruction it  is
	possible to use an immediate operand; but if the immediate value
	is between  -128 and 127,  better code results from  loading the
	value into a  register and using the register.   This is because
	the  load  into  the  register   can  be  done  with  a  `moveq'
	instruction.   We arrange  for this  to happen  by  defining the
	letter `K' to mean "any  integer outside the range -128 to 127",
	and then specifying `Ks' in the operand constraints.
    
    `g'
    
	Any register,  memory or  immediate integer operand  is allowed,
	except for registers that are not general registers.
    	
    `X'
    
	Any operand whatsoever  is allowed, even if it  does not satisfy
	`general_operand'.  This is normally used in the constraint of a
	`match_scratch'  when  certain  alternatives will  not  actually
	require a scratch register.
    
    `0', `1', `2', ... `9'
    
	An operand that matches the specified operand number is allowed.
	If  a  digit is  used  together  with  letters within  the  same
	alternative, the digit should come last.
    	
	This is called a "matching  constraint" and what it really means
	is that the  assembler has only a single  operand that fills two
	roles considered separate in the  RTL insn.  For example, an add
	insn has two  input operands and one output  operand in the RTL,
	but on most CISC machines an add instruction really has only two
	operands, one of them an input-output operand:
    	
	     addl #35,r12
    	
	Matching  constraints  are used  in  these circumstances.   More
	precisely,  the  two  operands   that  match  must  include  one
	input-only operand  and one output-only  operand.  Moreover, the
	digit must  be a smaller number  than the number  of the operand
	that uses it in the constraint.
    	
	For operands  to match in  a particular case usually  means that
	they  are  identical-looking  RTL  expressions.  But  in  a  few
	special cases specific kinds  of dissimilarity are allowed.  For
	example, `*x' as an input operand will match `*x++' as an output
	operand.  For proper results  in such cases, the output template
	should always use the  output-operand's number when printing the
	operand.
    
    `p'
    
	An operand that  is a valid memory address  is allowed.  This is
	for "load address" and "push address" instructions.
    	
	`p' in  the constraint must be  accompanied by `address_operand'
	as  the  predicate   in  the  `match_operand'.   This  predicate
	interprets the mode specified in the `match_operand' as the mode
	of the memory reference for which the address would be valid.
    
    `Q', `R', `S', ... `U'
    
	Letters  in  the range  `Q'  through `U'  may  be  defined in  a
	machine-dependent fashion to  stand for arbitrary operand types.
	The machine  description macro `EXTRA_CONSTRAINT'  is passed the
	operand as its  first argument and the constraint  letter as its
	second operand.
    	
	A typical use for this  would be to distinguish certain types of
	memory references that affect other insn operands.
    	
	Do  not  define  these  constraint letters  to  accept  register
	references  (`reg'); the reload  pass does  not expect  this and
	would not handle it properly.
    
        In order to have valid assembler code, each operand must satisfy
	its constraint.   But a  failure to do  so does not  prevent the
	pattern  from applying  to  an insn.   Instead,  it directs  the
	compiler  to modify  the code  so  that the  constraint will  be
	satisfied.  Usually  this is done  by copying an operand  into a
	register.
    
        Contrast, therefore, the two instruction patterns that follow:
    
	 (define_insn ""
	   [(set (match_operand:SI 0 "general_operand" "=r")
		 (plus:SI (match_dup 0)
			  (match_operand:SI 1 "general_operand" "r")))]
	   ""
	   "...")
    
	which has two operands, one  of which must appear in two places,
	and
    
	 (define_insn ""
	   [(set (match_operand:SI 0 "general_operand" "=r")
		 (plus:SI (match_operand:SI 1 "general_operand" "0")
			  (match_operand:SI 2 "general_operand" "r")))]
	   ""
	   "...")
    
	which  has  three operands,  two  of  which  are required  by  a
	constraint to  be identical.  If  we are considering an  insn of
	the form
    
	 (insn N PREV NEXT
	   (set (reg:SI 3)
		(plus:SI (reg:SI 6) (reg:SI 109)))
	   ...)
    
	the first pattern would not apply at all, because this insn does
	not  contain two  identical subexpressions  in the  right place.
	The  pattern  would  say,  "That  does  not  look  like  an  add
	instruction; try other patterns."  The second pattern would say,
	"Yes, that's  an add instruction,  but there is  something wrong
	with it."   It would direct the  reload pass of  the compiler to
	generate  additional insns  to  make the  constraint true.   The
	results might look like this:
    
	 (insn N2 PREV N
	   (set (reg:SI 3) (reg:SI 6))
	   ...)
	 
	 (insn N N2 NEXT
	   (set (reg:SI 3)
		(plus:SI (reg:SI 3) (reg:SI 109)))
	   ...)
    
	It is up to you to make sure that each operand, in each pattern,
	has constraints that can handle any RTL expression that could be
	present for  that operand.   (When multiple alternatives  are in
	use, each pattern must, for each possible combination of operand
	expressions, have at least one alternative which can handle that
	combination of operands.)  The constraints don't need to *allow*
	any  possible  operand--when  this  is  the case,  they  do  not
	constrain--but they must at least point the way to reloading any
	possible operand so that it will fit.
    
        * If  the  constraint accepts  whatever  operands the  predicate
	  permits, there is no problem: reloading is never necessary for
	  this operand.
    
	  For  example, an operand  whose constraints  permit everything
	  except  registers  is  safe  provided  its  predicate  rejects
	  registers.
    
	  An  operand whose  predicate accepts  only constant  values is
	  safe provided its constraints  include the letter `i'.  If any
	  possible constant  value is  accepted, then nothing  less than
	  `i'  will do;  if the  predicate is  more selective,  then the
	  constraints may also be more selective.
    
        * Any operand  expression can be  reloaded by copying it  into a
	  register.  So  if an operand's constraints allow  some kind of
	  register, it  is certain to be  safe.  It need  not permit all
	  classes  of  registers;  the  compiler  knows how  to  copy  a
	  register into another register of the proper class in order to
	  make an instruction valid.
    
       	* A nonoffsettable  memory reference can be  reloaded by copying
 	  the address  into a register.   So if the constraint  uses the
 	  letter `o', all memory references are taken care of.
     
       	* A  constant operand  can be  reloaded by  allocating  space in
 	  memory  to hold it  as preinitialized  data.  Then  the memory
 	  reference can  be used  in place of  the constant.  So  if the
 	  constraint uses the letters  `o' or `m', constant operands are
 	  not a problem.
     
       	* If  the constraint permits  a constant  and a  pseudo register
 	  used in  an insn was not  allocated to a hard  register and is
 	  equivalent to  a constant, the register will  be replaced with
 	  the constant.  If the predicate does not permit a constant and
 	  the insn  is re-recognized for some reason,  the compiler will
 	  crash.  Thus  the predicate must always  recognize any objects
 	  allowed by the constraint.
    
	If  the operand's  predicate  can recognize  registers, but  the
	constraint does not permit them, it can make the compiler crash.
	When this operand happens to be a register, the reload pass will
	be  stymied, because it  does not  know how  to copy  a register
	temporarily into memory.
    
	If  the  predicate  accepts  a unary  operator,  the  constraint
	applies to the operand.  For  example, the MIPS processor at ISA
	level  3 supports  an instruction  which adds  two  registers in
	`SImode' to produce a `DImode' result, but only if the registers
	are  correctly  sign extended.   This  predicate  for the  input
	operands accepts a `sign_extend' of an `SImode' register.  Write
	the constraint to indicate the type of register that is required
	for the operand of the `sign_extend'.
    ------------------------------------------------------------------------

    The '='  in the  "=r" is  a constraint modifier,  you can  find more
    information  about  constraint  modifiers,  in the  gcc  info  under
    Machine Descriptions : Constraints : Modifiers.

    I strongly recommend reading  more in the system info documentation.
    If  you haven't  had  much  experience with  the  info reader  (also
    accesable through  emacs), learn  it, it is  an excellent  source of
    information.

    The gcc info  documentation also explains how to  use a specific CPU
    register for  a constraint for various hardware  including the i386.
    You  can  find  this  information   under  [gcc  :  Machine  Desc  :
    Constraints : Machine Constraints] in the info documentation.

    You can specify specific registers in your constraints, e.g. "%eax".

* __asm__ __volatile__
------------------------------------------------------------------------

    Because of  the compilers optimization mechanism, your  code may not
    appear at  exactly in the  location specified by the  programmer.  I
    may  even be interspersed  with the  rest of  the code.   To prevent
    this, you can  use __asm__ __volotile__ instead.  Like  the '__' for
    asm, these  are also not needed  for volatile, but  can prevent name
    conflicts.

========================================================================
comments and suggestions 

 

세월도 바뀌고 VS2008을 처음 깔았고,
아키텍쳐도 막 바뀌어서.. 혹시나 해보고 찍어봤다.

char  = 1
int     = 4
short = 2

이런 구닥다리 기억부류는 안 쓰는 것이 상책이다.
마이컴 하다가 PC로 오니까 얼라인 잡아야지..

#pragma pack(1)    // 1바이트 얼라인
#pragma pack()     // 원복

소프트웨어 크라이시스 이야기 할 때 종종 나오는..
마스옵저버 패스파인더는 왜 뻗었을까.


http://catless.ncl.ac.uk/Risks/19.49.html


첫 페이지
http://catless.ncl.ac.uk/Risks

Forum On Risks To The Public In Computers And Related Systems

몰랐는데 RSS도 제공하네.

이런 것도 올라온다.
제목은 GPS humor;;

hash, 해쉬, 해시.



소스 위치.
http://www.cl.cam.ac.uk/~cwc22/hashtable/hashtable_powers.c

관련 링크.
http://www.cl.cam.ac.uk/~cwc22/hashtable/



BSD 라이선스니까 집에가서 걍 퍼다가 이 글에 저장해 놓쟈;;


머 근데 펌웨어 수준에서 쓰려면 malloc도 메롱이고..
있다해도 메모리 단편화 때문에 쓰기는 어렵다.

lst 파일 분석해서 메모리 사용 계획 잘 잡고 걍 배열 쌔리고 키 찾는 방식이 유리..

PC는 리틀엔디안이다.







int main(int argc, char* argv[]) {     unsigned int a = 0x11223344;     unsigned char *pa;         pa = (unsigned char *)&a;     printf("%x\n", *pa);     printf("%x\n", *(pa + 1));     printf("%x\n", *(pa + 2));     printf("%x\n", *(pa + 3));     return 0; }


결과는?

44
33
22
11

이 차이를 다들 알면서도 안 지키기도 하고,
백전노장의 도사 프로그래머이면서도 모르는 경우도 있다;;










#include "my.h" #include <my.h>



물론 나도 정확히 아는 건 아니고 걍 어디서 줏어들은 내력상..
다음과 같이 하자.

<> 꺽쇠는 POSIX등 표준 인클루드다. 당근 컴파일러가 지가 알아서 찾아온다.
"" 따옴표는 사용자 인클루드다. 컴파일러 옵션으로 -I 등을 명기하면 그 곳 부터 뒤진다.

같은 헤더 파일이 있다면 어떻게 될까?
"stdio.h" 하면 -I 안에 있는 곳 부터 뒤진 후 표준 인클루드를 뒤질 것이다. (추측 -_-)


터보 C 2 플로피 빌드 시절을 회상하면 간단하다. (기억이 틀릴 수 있음)

B 드라이브는 표준 라이브러리 및 표준 인클루드다.
A 드라이브는 사용자 파일 및 사용자 인클루드다.

""를 쓰면 알아서 A 드라이브의 인클루드를 얻어온다.



뭐 그렇다고..

박카스를 마셔봤다면 지킬건 지켜야지..
(아 그러고 보니 나는 헝가리안 표기법도 잘 안 지키는구나..;;)

보통 do {} while(0) 문은,
매크로로 정의된 리눅스 커널 헤더에서 흔하게 볼 수 있다.

인라인 펑션과는 또다른 쓰임새가 있다.


do { } while(0) 로 선언해두면.
다른 문장 없이 {} 로 씌울 때 에러나는 컴파일러에서 유용하다.

당해본 사람들은 알겠지만 {} 중괄호 없이 매크로 정의 함수를 쓸 때,
if ~ else 문 등에서 다양한 버그가 유발된다.


if ( ... ) a 문
else b 문

여기서 b 문에는 중괄호 {} 가 없으므로 else 뒤 단 한 문장만이 실행된다.
매크로 함수에 중괄호를 둘러치지 않았다면 매크로 함수의 최초 한 줄 만이 실행될 것이다.



do ~ while(0)는 사실 그 보다 continue를 통해 유용한 경우가 많다.



do {     a = looping_job()     if ( a != b) {         continue;     } else break; } while(0);

애초에 do ~ while(0)는 순환문으로서의 가치가 별로 없지만,
continue 문을 통해서 순환문의 가치를 부여 받는다.


이런 형식의 문장을 잘 쓰면 블럭 인덴트 판독이 어려운 대형 if 블럭,
에러 처리 상태 머쉰이 복잡하여 에라 모르겠다 goto 로 헤쳐모여 식의 문장을
상당히 구조적으로 바꿀 수도 있다.



그 보다는 이런 책을 읽으면 도움이 될지도. (광고)

http://me2day.net/bliss/2010/04/21#10:53:50




비전공자의 한계랄까.
패턴 고프책 한 번 제대로 안 읽었더니 몸으로 시간으로 깨우치는 것들이 많다.

임베디드에서 간단한 네트워크 프로토콜 헤더 짤 때 쓰는 방식

char *ddd; 를 선언하면 ARM에서 4바이트 먹는다.
char ddd[0]; 을 선언하면 0바이트다.



헤더 다음에 페이로드가 바로 따라올 때 공용체 스킬 안 쓰고 시리즈로 연결 할 수 있다.
gcc, ads는 되고 SDT는 안 될꺼다 아마...



struct aaa {     int a;     char ddd[0];  }; int main(int argc, char* argv[]) {     printf("--- %d\n", sizeof(aaa));     return 0; }

리눅스 드라이버에서 맨날 보지만서도..
. (점) 연산자가 왜 거기 있는지는 걍 그런갑다 했던 그것.





http://publib.boulder.ibm.com/infocent ··· tors.htm






static struct file_operations vd_fops = {     .owner      = THIS_MODULE,     .open       = pxa_camera_open,     .release    = pxa_camera_close,     .read       = pxa_camera_read,     .poll       = pxa_camera_poll,     .ioctl      = video_ioctl2, /* V4L2 ioctl handler */     .mmap       = pxa_camera_mmap,     .llseek     = no_llseek, };

PHP 손 놓은지 10년 -_-ㅋ
별건 아니고..

여튼.. 프락시 서버 내부에 아파치, PHP 엔진이 있는 경우.

fopen등으로 외부에서 url을 긁어오려면,
프락시 경유 때문에 문제가 된다.

사실 이게 리퀘스트만 조금 바꾸면 된다 -_-ㅋ





function pfopen($url) {             $proxy_server = "니네 프락시 주소";     $proxy_port = 니네 프락시 포트 넘버;     if (substr($url, 0,7) <> 'http://') {         return false;     }     $proxycon = fsockopen($proxy_server, $proxy_port, $errno, $errstr);     fputs($proxycon,"GET ".$url." HTTP/1.0 \r\n\r\n");     $reading_headers = true;     while (!feof ($proxycon)) {         $curline = fgets($proxycon, 4096);         if ($curline=="\r\n") {             $reading_headers = false;         }         if (!$reading_headers) {             $filecontent .= $curline;         }     }     fclose($proxycon);     return $filecontent; }

여기서 가져왔다.

http://webscripts.softpedia.com/script ··· 101.html

맨날 까먹어서 쓸 때마다 도로 검색하는 대표적인 코드








"너만 그래..."






#ifdef DEBUG #define dbg(format, arg...) \         printk(KERN_INFO format "\n" , ## arg) #else         #define dbg(format, arg...) do {} while (0) #endif

이건 전역도 지역도 아니여~









gcsVISUAL_PTR ivdkGetVisual(void) {     /* Define the visual object. */     static struct _gcsVISUAL visual = {{0}};     /* Return a pointer to the object. */     return &visual; }


음... 이 좌식;;;

linux,
framebuffer, mmap




리눅스 프레임버퍼에서 mmap으로 고속 그리기하는 기본 와꾸다.






    pfbdata = (unsigned short *)mmap(0, fbvar.xres * fbvar.yres * 2, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);     if((unsigned)pfbdata == (unsigned)-1)     {         perror("사대강 개발 반대!!");         exit(1);     }                temp = pfbdata;         for (y = 0; y < fbvar.yres; y++) {         for (x = 0; x < fbvar.xres; x++) {             *temp++ = 0xffff;         }     }        munmap(pfbdata, fbvar.xres * fbvar.yres * 2);

일반적인 수행 시간 측정.












    struct timeval tv;     long t1, t2;     gettimeofday(&tv, NULL);     t1 = tv.tv_sec * 1000 + tv.tv_usec / 1000; // 시작     gettimeofday(&tv, NULL);     t2 = tv.tv_sec * 1000 + tv.tv_usec / 1000; // 끝..

나머지는 지지고 볶고..

BSS / Block started by symbol



text 는 코드
data는 초기화 된 데이터
bss 는 초기화 되지 않은 데이터



요즘엔 맨날 보는 약어들의 원 정체에 대한 궁금증이 많다 ㅡ.ㅡ;


아 그리고.. 스택은 작은 순서로 늘어난다.
메모리 맵 주소를 거꾸로 그려놓으면 꼭 헷갈려서 어리버리..


--------------------------------------------------------------------------------


BSS
Definition, Meaning, Explanation


--------------------------------------------------------------------------------

this article is about Block started by symbol (BSS), BSS can also mean Base Station Subsystem in GSM
Block started by symbol (BSS) was a pseudo-op in UA-SAP (United Aircraft Symbolic Assembly Program), the assembler developed in the mid-1950's for the IBM 704 by Roy Nutt, Walter Ramshaw, and others at United Aircraft Corporation. This pseudo-op was later incorporated into FAP (FORTRAN Assembly Program), the standard IBM assembler for the IBM 709, 7090 and 7094 computers. It defined its label and reserved space for a given number of words.

Most modern assemblers produce a BSS section in their output object module containing all reserved but unitialized space


--------------------------------------------------------------------------------
http://www.free-definition.com/BSS.html



2003년 봄. 작성.

빨빤씨가 갈챠줌.

http://malsup.com/jquery/cycle/


자바스크립인데도 부드럽게 잘 되는구놔;;
파폭에서도 잘 되는 구놔;;



나중에 써먹어봐야지..




(과연 언제?!!)

구 블로그에 CIH 바이러스 소스코드가 있길래..


일단 펐더니..


이건 뭐 위키에도 있고 별별 분석 자료가 다 있구만.


http://en.wikipedia.org/wiki/CIH_virus


소스 코드 위치.
http://www.62nds.co.nz/62nds/documents/cih.txt


그냥 폼으로... 게시..

바이너리를 텍스트로, 텍스트를 바이너리로.
뭐 요즘에 쓸일은 없지만.

나우누리 ㅋㅋㅋ
어둠의 저장소 ㅋㅋㅋ 아는 넘들은 죄다 겜덕인증 ㅋㅋㅋ


이전 블로그 정리하면서 나왔다.


뭐 이런걸 다...



<PRE>Date: Wed, 09 Apr 1997 13:04:11 +0100 From: jim <j.cameron@physiology.ucl.ac.uk> To: webmaster@wotsit.demon.co.uk ===== UUENCODE ====== uuencode is a utility designed to enable arbitrary binary files to be transmitted using text-only media such as email. It does this by encoding the files in such a way that the encoded file contains only printable characters. (IMPORTANT Note: this file is the result of an afternoon's hacking by myself. I make no guarantees as to its completeness and accuracy. I have coded my own uuencode and uudecode programs which haven't let me down yet) The uuencode algorithm hinges around a 3-byte-to-4-byte (8-bit to 6-bit data) encoding to convert all data to printable characters. To perform this encoding read in 3 bytes from the file to be encoded whose binary representation is a7a6a5a4a3a2a1a0 b7b6b5b4b3b2b1b0 c7c6c5c4c3c2c1c0 and convert them into 4 bytes with values in the range 0-63 as follows: 0 0 a7a6a5a4a3a2 0 0 a1a0b7b6b5b4 0 0 b3b2b1b0c7c6 0 0 c5c4c3c2c1c0 Then convert these bytes to printable characters by adding 0x20 (32). EXCEPTION: if you end up with a zero byte it should be converted to 0x60 (back-quote '`') rather than 0x20 (space ' '). So if you read 3 bytes from the file as follows: 14 0F A8 (hex) i.e. 00010100 00001111 10101000 your 4 bytes output should be 25 60 5E 48 ("%`^H"). The intermediate 4 bytes in this case were 00000101 00000000 00111110 00101000 Note that the zero byte has been translated to 0x60 instead of 0x20. The body of a uuencoded file therefore only contains the characters 0x21 '!' to 0x60 '`', which are all printable and capable of being transmitted by email. (Note: this of course means that uuencoded files are slightly more than 33% longer than the originals. uuencoding text-only files is redundant and a silly thing to do. Standard and sensible practice is to compress the files first using a standard compression utility and then to uuencode them). In addition, the start of the encoding is marked by the line "start <mode> <filename>", where <mode> consists of 3 octal digits which are the Unix mode of the file, and <filename> is the original filename of the file encoded. The end of the encoding is marked by the line "end". The first character of each line contains the line length in bytes *in the original file*, encoded in the same way as an ordinary byte i.e. line length 0->0x60, all other lengths add 0x20 to convert to printable characters. Line lengths vary from 0 to 45 (which encodes to 'M'; this is why lines in a uuencoded file all start with an M), which is a line length of 61 characters (including the length character) in the encoded file. This is a nice safe length to transmit via email. Lines in the encoded file are always a multiple of 4 + 1 characters long; this sometimes means that 1 or 2 bytes are thrown away at the end of the decoding. (Note: I can't see any reason why lines shouldn't be an arbitrary length, and don't know whether the proper definition disallows this. I've never seen a uuencoded file where any line apart from the last one wasn't 'M' followed by 60 characters, though) To decode, simply perform the inverse of the encoding algorithm. ===== SAMPLE CODE ===== I include here the C source code to a small uuencode and uudecode utility I coded myself. It isn't very sophisticated and probably not very complete, but it does its job, and is very useful for my PC where I don't have access to the standard Unix stuff. It took me about half an hour to write, and another hour or so to iron out the obvious bugs. It works quite happily under DOS (uuencoding needs practically no internal storage). It isn't a great masterpiece of software design and coding, but might be worth a look. Feel free to do whatever you want to it, up to and including throwing it in the bin. ===== uuencode.c ===== /* * uuencode.c - * Simple uuencode utility * Jim Cameron, 1997 */ #include "stdio.h" #include "stdlib.h" #define MAX_LINELEN 45 #define ENCODE_BYTE(b) (((b) == 0) ? 0x60 : ((b) + 0x20)) typedef unsigned char BYTE; int main (int argc, char *argv []) { FILE *infile = NULL; FILE *outfile = NULL; int linelen; int linecnt; BYTE inbuf [MAX_LINELEN]; BYTE *inbytep; char outbuf [5]; if (argc != 3) { fprintf (stderr, "Syntax: uuencode <infile> <outfile>\n"); exit (1); } /* Try and open the input file (binary) */ infile = fopen (argv [1], "rb"); if (infile == NULL) { fprintf (stderr, "uuencode: Couldn't open input file %s\n", argv [1]); exit (1); } /* Try and open the output file (text) */ outfile = fopen (argv [2], "wt"); if (outfile == NULL) { fprintf (stderr, "uuencode: Couldn't open output file %s\n", argv [2]); exit (1); } /* Write the 'begin' line, giving it a mode of 0600 */ fprintf (outfile, "begin 600 %s\n", argv [1]); do { /* Read a line from input file */ linelen = fread (inbuf, 1, MAX_LINELEN, infile); /* Write the line length byte */ fputc (ENCODE_BYTE (linelen), outfile); /* Encode the line */ for (linecnt = linelen, inbytep = inbuf; linecnt > 0; linecnt -= 3, inbytep += 3) { /* Encode 3 bytes from the input buffer */ outbuf [0] = ENCODE_BYTE ((inbytep [0] & 0xFC) >> 2); outbuf [1] = ENCODE_BYTE (((inbytep [0] & 0x03) << 4) + ((inbytep [1] & 0xF0) >> 4)); outbuf [2] = ENCODE_BYTE (((inbytep [1] & 0x0F) << 2) + ((inbytep [2] & 0xC0) >> 6)); outbuf [3] = ENCODE_BYTE (inbytep [2] & 0x3F); outbuf [4] = '\0'; /* Write the 4 encoded bytes to the file */ fprintf (outfile, "%s", outbuf); } fprintf (outfile, "\n"); } while (linelen != 0); /* Write the 'end' marker */ fprintf (outfile, "end\n"); /* Tidy up and return */ fclose (infile); fclose (outfile); return 0; } ===== uudecode.c ===== /* * uudecode.c - * Simple uudecode utility * Jim Cameron, 1997 */ #include <ctype.h> #include <stdio.h> #include <stdlib.h> #include <string.h> /* We all hate magic numbers! */ #define LINE_BUF_SIZE 256 /* Decode a byte */ #define DECODE_BYTE(b) ((b == 0x60) ? 0 : b - 0x20) typedef unsigned char BYTE; int main (int argc, char *argv []) { FILE *infile = NULL; FILE *outfile = NULL; char linebuf [LINE_BUF_SIZE]; char *linep = NULL; char *tempcp = NULL; int linelen = 0; int linecnt = 0; char outfname [LINE_BUF_SIZE]; BYTE outbyte [3]; /* Check that we have the right number of arguments */ if (argc != 2) { fprintf (stderr, "Syntax: uudecode <filename>\n"); exit (1); } /* Open the input file */ infile = fopen (argv [1], "rt"); if (infile == NULL) { fprintf (stderr, "uudecode: Couldn't open file %s\n", argv [1]); exit (1); } /* uu-encoded files always have a 'begin' marker, so go and look for this */ for (;;) { /* Read a line */ if (fgets (linebuf, LINE_BUF_SIZE, infile) == NULL) { fprintf (stderr, "uudecode: Not a valid uu-encoded file\n"); exit (1); } /* See if it is the 'begin' marker */ if ((strncmp (linebuf, "begin", 5) == 0) && isspace (linebuf [5])) { break; } } /* If we have reached this point, we have found a begin marker */ linep = linebuf + 5; /* Next comes the mode, which we ignore */ while (isspace (*linep)) { linep++; } if (*linep == '\0') { fprintf (stderr, "uudecode: Not a valid uu-encoded file\n"); exit (1); } while (isdigit (*linep)) { linep++; } while (isspace (*linep)) { linep++; } if (*linep == '\0') { fprintf (stderr, "uudecode: Not a valid uu-encoded file/n"); exit (1); } /* The rest of the begin line is the output file name */ strcpy (outfname, linep); tempcp = outfname; while (!isspace (*tempcp) && (*tempcp != '\0')) { tempcp++; } *tempcp = '\0'; /* Now open the output file */ outfile = fopen (outfname, "wb"); if (outfile == NULL) { fprintf (stderr, "uudecode: Couldn't open output file %s\n", outfname); exit (1); } /* Now for the uu-decode proper */ do { if (fgets (linebuf, LINE_BUF_SIZE, infile) == NULL) { fprintf (stderr, "uudecode: Read error\n"); exit (1); } /* The first byte of the line represents the length of the DECODED line */ linelen = DECODE_BYTE (linebuf [0]); linep = linebuf + 1; for (linecnt = linelen; linecnt > 0; linecnt -= 3, linep += 4) { /* Check for premature end-of-line */ if ((linep [0] == '\0') || (linep [1] == '\0') || (linep [2] == '\0') || (linep [3] == '\0')) { fprintf (stderr, "uudecode: Error in encoded block\n"); exit (1); } /* Decode the 4-byte block */ outbyte [0] = DECODE_BYTE (linep [0]); outbyte [1] = DECODE_BYTE (linep [1]); outbyte [0] <<= 2; outbyte [0] |= (outbyte [1] >> 4) & 0x03; outbyte [1] <<= 4; outbyte [2] = DECODE_BYTE (linep [2]); outbyte [1] |= (outbyte [2] >> 2) & 0x0F; outbyte [2] <<= 6; outbyte [2] |= DECODE_BYTE (linep [3]) & 0x3F; /* Write the decoded bytes to the output file */ if (linecnt > 3) { if (fwrite (outbyte, 1, 3, outfile) != 3) { fprintf (stderr, "uudecode: Error writing to output file\n"); exit (1); } } else { if (fwrite (outbyte, 1, linecnt, outfile) != linecnt) { fprintf (stderr, "uudecode: Error writing to output file\n"); exit (1); } linecnt = 3; } } } while (linelen != 0); /* All is ok, tidy up and exit */ fclose (infile); fclose (outfile); return 0; } ===== end ===== jim -- j.cameron@physiology.ucl.ac.uk </PRE>

이거 블로그 이사할때마다 계속 옮겨다 놓는 글인데,
수시로 검색해 들어오네...

사실은 내가 수원멤 게시판에 써놨던 걸 그대로 복사한 글이 더 검색이 잘 됐었던듯;;

요즘은 형상관리고 버전관리고 나가리라..
서브버전에선 안 됐었던 것도 같고.. 알아서들 쓰삼.



CVS 코멘트를 주석에 바로 남기자.

* * *

원래 RCS 기능인데 윈도우에서도 잘 된다.

배치파일 안이라면



$Log$ 를 붙이면 커밋할 때 마다 주석이 자동으로 붙는다.

C 소스 안이라면 다음과 같이 된다.



헤더에 안 붙이고 푸터에 붙이면 읽기 좋음.

#include <unistd.h> #include <sys/stat.h> #include <fcntl.h> #include <stdlib.h> int main(void) {         char block[1024];         int in, out;         int cnt = 1024;                         in = open("file_block.in", O_RDONLY);         out = open ("file_block.out", O_CREAT | O_WRONLY);         do {                        cnt = read(in, block, 1024);                 write(out, block, cnt);         } while(cnt != 0);           close(in);         close(out);                 exit(0); }

int (*pf1)(char *); void (*pf2)(double); pf1=(int (*)(char *))pf2; //

타이머로 인터럽트 하나 잡아서 jiff 값을 1ms 정도에 한 번씩 증가시킨 후.
정한 시간 내에 수신이 발생하지 않으면 탈출하도록 한다.

펌웨어상에서 프로그래밍할 때는 흔하게 고려해야 하는 부분.


unsigned char getb(int *timeout_err) {         int start;                         start = jiff;         *timeout_err = uart_time_out;                         while (!(rUS1_SR & USART_RXRDY)) {                                 if ((jiff - start) >= *timeout_err) {                                        *timeout_err = -1;      // 타임아웃은 -1 이다.                         return 0;                        // 의미없는 리턴                 }                 continue;         }         *timeout_err = 0;                        // 타임아웃이 아니다.         return (unsigned char)rUS1_RHR; }

유형 #1.

int aaa(char *bp) {     bp++;    // -_-;     .... }

유형 2.

int aaa(const char *bp) {     bp++;    // 컴파일러가 아예 에러를 낸다. 가장 안전!     .... }

유형 3.

int aaa(const char *bp) {     char *temp_bp = (char *)bp;     temp_bp++;    // 비교적 안전~     .... }

습관이 무섭다 ㅠ.ㅠ
나는 나쁜 습관을 가지고 있다. -_-;

http://www.linuxjournal.com/node/6463


http://www.iecc.com/linker/

linux, pthread.


클래스 정의하고 객체 생성할 때마다 스레드를 펑펑 만들고 싶을 때 다음과 같이 하면 된다.



지금 목적은 객체에 입력 이벤트 감시 스레드를 어태치 하는 것이다.


1. class 선언은 다음과 같다.

class IGWindow : public IGWidget { public:     ...     static void *event_go(void *param);     ... }



2. 스레드 함수 선언은 다음과 같다.

void* IGWindow::event_go(void *param) {     static int t = 0;     int i = 0;         while(1) {         printf("thread! %x, %d, %d, %x, %x, %x, %x--\n", (int)param, i++, t++, (int)event_go, &i, &t);         sleep(1);        } }


3. 클래스 생성자에서 스레드 생성을 한다.

    pthread_create(&my_thread, NULL, event_go, (void *)(this));




4. 인스턴스 3개를 만들자 결과는 다음과 같이 된다.

thread! 313e8, 2, 6, 407a6468, 41f55e14, 407b5694, 0--
thread! 44d50, 2, 7, 407a6468, 42755e14, 407b5694, 0--
thread! 3cf30, 2, 8, 407a6468, 42f55e14, 407b5694, 0--

thread! 313e8, 3, 9, 407a6468, 41f55e14, 407b5694, 0--
thread! 44d50, 3, 10, 407a6468, 42755e14, 407b5694, 0--
thread! 3cf30, 3, 11, 407a6468, 42f55e14, 407b5694, 0--

thread! 313e8, 4, 12, 407a6468, 41f55e14, 407b5694, 0--
thread! 44d50, 4, 13, 407a6468, 42755e14, 407b5694, 0--
thread! 3cf30, 4, 14, 407a6468, 42f55e14, 407b5694, 0--


맨 앞의 주소는 스레드 함수를 생성한 인스턴스 자신의 주소다. 각각 다르다.
두 번째 값은 지역변수가. 각각 달리 잘 관리한다.
세 번째 증가하는 값은 스레드 함수내 static 정적 변수다. 같이 쓰고 있다.
네 번째 주소는 스레드 함수 자신의 주소다. 모두 같다.
다섯번째 주소는 지역변수 i의 주소다. 각각 잘 관리한다.
여섯번째 주소는 정적변수 t의 주소다. 모두 같이 쓴다.


5. 멤버 변수 가져오도록 함수를 변경해보자. (물론 생성시 인스턴스 자기 주소를 넘긴상태)


void* IGWindow::event_go(void *param) {     static int t = 0;     int i = 0;         IGWindow *pp = (IGWindow *)param;     while(1) {         printf("thread! %s--\n", pp->__src.c_str());         sleep(1);        } }


이상~

이제 pthread 공부해야지... 뭘 아는게 없네..