neodelicious (Jaewon Kim)

사정상 VBOX 에 Ubuntu 를 설치해서 사용하고 있는데,
기존에 사용하던 /home 이 HDD(SSD) 용량을 거의 다 차지하고 말았다.

Android 같은 대용량 Source 를 받고 Build 하면 금새 몇 십 GB 를 소모하는데

,
그리고 VBOX 초기 설정시 HDD 크기를 너무 작게 설정했기 때문이다.
사실 http://virtualboxes.org/images/ubuntu/ 에서 이미 Ubuntu 를 설치한 VBOX image 를 이용하면 기본 8GB 로 설정되어 있어서 금새 부족해진다.

생각해보면 /home 전용 VBOX image 를 별도로 관리하면, 이후에 VBOX master HDD image 에 문제가 생겨도 손쉽게 복구할 수 있을 것 같아서 HHD 를 추가하고 /home 을 분리하는 방법을 찾아봤다.

이미 같은 필요를 느끼는 사람이 많아서인지 ubuntu help page에 잘 설명되어 있었다.
https://help.ubuntu.com/community/Partitioning/Home/Moving

방법은 우선 VBOX 에서 HDD 를 적당히 크게 하나를 추가하고 Ubuntu 에서 format 한다.
그리고 위 ubuntu help page 처럼 /home 을 복사하고 mount point 를 변경한다.

ubuntu help page 방법의 command 만 복사하면 아래와 같다.

1. 실행후 새 HDD 의 UUID 확인
$ sudo blkid
2. fstab backup 후 fstab 임시 수정 (UUID는 1. 에서 확인한 값으로 변경, option 도 필요하면 수정)
$ sudo cp /etc/fstab /etc/fstab.$(date +%Y-%m-%d)
$ gksu gedit /etc/fstab
UUID=????????   /media/home    ext4          nodev,nosuid       0       2
3. 새 HDD mount
$ sudo mkdir /media/home
$ sudo mount -a
4. /home 복사 (참고 - .gvfs 를 복사 못 해도 warning message 출력 금지)
$ sudo rsync -aXS --exclude='/*/.gvfs' /home/. /media/home/.
$ sudo diff -r /home /media/home
5. fstab 재 수정(/home 으로 변경), /home 변경 및 재부팅
$ gksu gedit /etc/fstab
UUID=????????   /home    ext4          nodev,nosuid       0       2
$ cd / && sudo mv /home /old_home && cd / && sudo mkdir -p /home
$ sudo reboot
6. 이전 /home 삭제
$ sudo rm -r /old_home

#include <stdio.h>

struct Mystr {
 unsigned char a1 : 4;
 unsigned char a2 : 2;
 unsigned char a3 : 1;
};

int main(int argc, char *argv[])
{
 int i;
 struct Mystr mystr = { .a3=1, };

 printf("sizeof(struct Mystr) is %d\n", sizeof(struct Mystr));
 if (mystr.a3 == 1)
  printf(".a3=1 works!\n");

 return 0;
}

sizeof(struct Mystr) is 1
.a3=1 works!

*** printf() options

%hd - half decimal, 즉 short
%f - float와 double
%lf - long double
%5d - 우측 정렬, 빈칸 삽입
%+5d - 부호 표기
%-5d - 좌측 표기
%05d - 우측 표기, 좌측에 숫자'0' 삽입
%.2f - 소수점 이하 출력할 숫자의 개수 제한

0x%x 대신에 %p를 쓰면 자동으로 0x를 붙여준다.
주소 출력시 %p를 이용해 보자.

******************************************

*** 정수형과 실수형의 기본 자료형은 각각 int와 double이다.

따라서 int x = 10 에서는 형변형이 없지만
float y = 10.1 에서는 10.1을 double형으로 인식하여 이를 float로 자동 형변환 한다.

또한 다음의 경우 Error가 아니다.
static a[3];
이는 type을 안 써서 기본형인 int으로 인식하기 때문이다.

*** 기본 함수형태는 int FuncName (void) 이다.

따라서 int f1 (void) 의 경우 호출 전에 선언하지 않아도 인지한다.

******************************************

*** int main ( int argc, char * argc[], char * envp[] )

배열 envp 안에 환경 정보가 저장되어 있다.
이 배열의 마지막은 NULL이다.

******************************************

*** char * strdup (const char *)

입력 string의 메모리를 복사하는데, 또 다른 동적 메모리를 할당하여 복사한다.
추후 메모리 반환을 해줘야 한다.

******************************************

*** 지역변수를 stack에 저장할 때 I/O 크기에 따라 자동으로 메모리 공간을 일부러 띄운다.

char 형, short 형 변수를 각각 선언하면 stack의 높은 주소의 위치부터 차례로 이용하는데,
char 가 1byte이고 short가 2byte일 때 다음과 같은 경우가 될 수 있다.

예1)
8F - char
8E - 없음
8D - short 상위
8C - short 하위

예2) - visual C++ 6.0 실험 결과
8F - 없음
8E - 없음
8D - 없음
8C - char
8B - 없음
8A - 없음
89 - short 상위
88 - short 하위

******************************************

*** prompt 상에서 editor 실행

gedit &
-> gedit text editor 실행
kate &
-> gedit와 다른 text editor

******************************************

*** PC에서 vmware 상의 linux와 기본 OS인 winXP 사이의 ftp 파일 전송 방법
*** 주의 !!! 일부 설정 방법이 생략되어 있음

service vsftpd start
-> linux 內 ftp 서버 활성화

winXP에서 vmware 상이 linux의 IP에 대해서 ftp 연결 시도
ftp [Linux IP]
get, put 혹은 mget, mput 이용 파일 전송

******************************************

*** 틀리기 쉬운 C 문법

#define FLAG  0x02 일때
flag 변수의 bit 2가 set인지 확인하고자 한다면,
if (flag & FLAG) 를 써야 하는데,
if (flag & FLAG != 0) 로 쓰면 != 가 & 보다 우선하므로 틀린다.

val = high << 4 + low;
에서 high를 상위로 하고 low를 하위로 하는 것처럼 오인할 수 있는데,
산술연산자 + 가 먼저 실행되어 잘못된 계산을 하게 된다.

== 은 < , > 보다 우선 순위가 낮아서
n1 > n2 == n2 > n3
의 경우 == 가 나중에 되므로 주의한다.

치환연산자는 관계연산자보다 우선순위가 낮다. (사실 치환연산자는 제일 낮다.)
while ( c = getchar() != '\n' )
에서 != 를 먼저하므로 error이다.


******************************************

*** code 상에 정의되지 않은 값을 compile할 때 정의하는 방법

opPriorErr.C 파일을 cc를 이용하여 compile할 때,
'CASE' 라는 값을 '1'로 설정하려면
다음과 같이 '-D' 이후에 'CASE'를 입력한다.

cc -DCASE=1 opPriorErr.C

열심히 코딩을 잔뜩 한 후에 컴파일 하고 나서 알 수 없는 결과에 당혹해 하다가,
디버깅 모드에서 추적한 끝에 getline()함수가 말썽인을 것을 알았다.

결론적으로 getline()함수를 이용할 경우,
한  번 이용한 다음에 다시 getline()함수를 이용하기 전에 clear()함수를 호출하는 것이 좋다.
그렇지 않을 경우 두 번째 호출한 getline()함수는 buffer에 "" 즉,  '\0'만을 저장한다.

왜 그런지 알아보기 위해서 getline()에 대해서 참고 페이지를 읽어보고
fail()과 bad()으로 failbit이나 badbit가 set되어 있는지 테스트 해 보았다.
bad()에서는 clear되어 있고 fail()에서는 set되어 있는 것으로 봐서는 failbit가 set되어 있는 것이었다.
그리고 아래는 getline()에 대해서 참고자료에서 알려준 failbit에 대한 설명 중 일부이다.
failbit - This is also set if the function stops extracting
             because n-1 characters were extracted
그러니까 한 마디로 말 해서 꽉 차게 읽으면 failbit가 발생한다는 것이다.

그리고 참고자료에 getline()에 대한 설명으로 아래와 같은 글이 있었다.
The extraction also stops if the end of file is reached in the input sequence or if an error occurs during the input operation.
그러니까 입력 과정 중에 에러가 나도 멈춘다는 것이다.

여하튼 buffer가 꽉 찰 것을 예상한 다면 clear()를 통해 두 번째 getline() 이후에는
error control state 를 goodbit 로 만들어 줘야 한다.
이는 file stream 뿐만 아니라 일반 키보드 입력 stream에서도 마찬가지이다.
아무튼 getline() 쓰고 buffer에서 읽었는데, 꽉 차면 다음 번엔 꽝이닷~

직접 참고 페이지에서 정보를 얻기 바란다.
fsream 참고 - http://www.cplusplus.com/reference/iostream/fstream/
istream::getline 참고 - http://www.cplusplus.com/reference/iostream/istream/getline.html
ios:clear() 참고  - http://www.cplusplus.com/reference/iostream/ios/clear.html

아래 코드는 이를 테스트 해보기 위해서 짠 코드이다.
ttt.txt 라는 파일을 열어서 제대로 열렸다면,
파일 끝까지 10bytes씩 읽어온다.

#include <iostream>
#include <fstream>
using namespace std;

#define MAX_BUF_SIZE 10

int main()
{
fstream fp;

fp.open("ttt.txt");    // fp.open("ttt.txt", fstream::in);  
char szBuffer[MAX_BUF_SIZE];
if (fp.is_open()) {  
do {
  fp.clear();
  fp.getline(szBuffer, MAX_BUF_SIZE);
}while(fp.gcount() == MAX_BUF_SIZE - 1);
}

fp.close();
return 0;
}

Some things every C programmer should know about C
PMK 10-16-2002


Types
-----

Every constant, object, function, and expression in C has a type.
Most generally, a type is either an unqualified type or such a type
qualified with "const", "volatile", or both qualifiers.  Unqualified
types comprise three categories:

	Object types
		Scalar
		   Arithmetic
		      Integral
		         signed/unsigned/plain
		            character types
		            short, int, long
		         bitfield
		         enumeration
		      Floating-point
		   Pointer to general type
		Aggregate
		   struct/union of object types and bitfields
		   known-size array of objects
	Incomplete types
		void
		undefined struct/union
		array of unknown size of objects
		array of incomplete type (except void)
	Function returning void or unqualified object type (except array)
		(with no arguments, with unknown or old-style arguments, or
		 with prototyped arguments of general types)

Bitfields may appear only as struct/union members, so
there are no pointers to bitfields, arrays of bitfields, or
functions taking or returning bitfields.

Some types are silently replaced.  A qualified array type becomes
an unqualified array of the qualified type, and function arguments
that are arrays or functions become pointers.


Declarator Syntax
-----------------

Binding is just like expressions: postfix before prefix.  So
parentheses are necessary in declarators only for function arguments
and for pointers to functions and arrays!

In qualified pointer types, the pointer qualifiers appear after the *.

How to easily read a declaration from left to right:
	transform function argument types from inside out first
	move the base type to the end
	add outer parentheses if there's an initial *
	change every (*...) to ... ->
		one -> for each *
		move qualifiers, so * const becomes const ->

Example: const int *(**const x [])()

	*(**const x [])() const int		base type to end
	(*(**const x [])()) const int		add outer parens
	(**const x [])() -> const int		remove outer ()
	x [] const -> -> () -> const int	remove inner ()

	array of constant pointers to pointers to functions
	returning pointers to constant ints


Types of Constants
------------------

Floating-point constants are "double" unless suffixed by 'F' or 'L'.

Integer constants take the first type that fits in one of these lists:
	with 'U':	unsigned int, unsigned long
	with 'L':	long, unsigned long
	with 'UL':	unsigned long
	decimal:	int, long, unsigned long
	octal, hex:	int, unsigned int, long, unsigned long
(So 2147483648 is long but 0x80000000-0xffffffff are unsigned int.)

Character constants are "int".
String literals are arrays of "char".

Null pointer constants:
	any zero-valued integral constant expression,
	possibly cast to (void *)


Operator Precedence and Associativity
-------------------------------------

These are the classes of operators in decreasing order of precedence.

	(x)
	postfix:	x[y], x(...), x.y, x->y, x++, x--
	prefix:		++x, --x, (type) x, sizeof x, &x, *x, +x, -x, ~x, !x
	multiplicative:	x*y, x/y, x%y
	additive:	x+y, x-y
	shift:		x<<y, x>>y
	relational:	x<y, x<=y, x>y, x>=y
	equality:	x==y, x!=y
	bitwise and:	x&y
	bitwise xor:	x^y
	bitwise or:	x|y
	logical and:	x&&y
	logical or:	x||y
	conditional:	x?y:z
	assignment:	x=y and *= /= %= += -= <<= >>= &= ^= |=
	sequence:	x,y

All binary operators are left-associative where it makes a difference,
except of course for assignment.  The conditional x?y:z operator
is the ONLY doubtful case that is right-associative!

	So	x ? y : a ? b : c
	is	x ? y : (a ? b : c)
	not	(x ? y : a) ? b : c

Some syntactic equivalences:
	x->y	means	(*x).y
	x[y]	means	*(x+y)
	!x	means	x == 0

Rules applying to x.y and *x may thus apply to x->y or x[y] as well.
Note that "!!x" is equivalent to "x != 0".


Notes on Operators
------------------

Pointer arithmetic is always in units of the pointer's base
type.  This means that adding or subtracting an integer to or
from a pointer yields a pointer to another element in the
same array.

	p + 1 == &p [1]

Subtracting two pointers yields a distance that is also in
units of the pointer's base type.

These operators always return either 0 or 1:

	!x
	relations and equalities (<, <=, >, >=, ==, !=)
	x && y
	x || y

The logical operators (x && y, x || y) do not evaluate their
second operands if the first operand determines the result.


On two's-complement processors,
	-x == ~x + 1
	~x == -1 - x
	x & -(1<<y)	lowers x to a multiple of a power of two
	(1 << x) - y == y ^ ((1 << x) - 1)
	(x&y) + (x|y) == x + y == (x^y) + ((x&y) << 1)

Note that sizeof (type) requires parenthese, while sizeof expression
does not.



Lvalues
-------

An Lvalue represents the location of an object or function, and
might be the target of assignment.  An Rvalue is any other value,
such as an object's value or a constant or a function result.

Only these expressions are Lvalues:

	identifiers of objects and functions
	"string literal"
	(Lvalue)
	Lvalue.member
	*Rvalue

x.y is an Lvalue if x is, and has all the qualifiers of
the types of both x and y.  Casts are not Lvalues.
As a consequence of the syntactic equivalences noted above,
these expressions are also Lvalues:

	Rvalue->member
	Rvalue [Rvalue]


An Lvalue is modifiable if its type is none of these:
	function
	array
	incomplete
	const-qualified
	struct/union with any unmodifiable member


Implicit Promotions, Conversions, and Operations
------------------------------------------------

Lvalues (other than arrays and functions) become Rvalues of
unqualified type except in these contexts:
	sizeof
	&x
	x++, x--, ++x, --x
	x.member
	left sides of assignments (x=..., x+=..., etc.)

Lvalues of array type are converted to Rvalues of pointer type
pointing to their first members except in these contexts:
	sizeof
	&x
	"string literal" in a character array initializer

There are no Rvalues of array type in C outside sizeof.

Function designators are converted to Rvalues of pointer to
function type (except in &x which does that anyway).
So if "f" is the name of a function, all of these are synonyms,
and all have type "pointer to function":

	f
	*f
	***f
	************************************f

Integral promotions: Rvalues of these types (plain, signed,
and unsigned) become "int" or "unsigned int":
	char
	short
	bitfields of type int or smaller
	enum

The famous Usual Arithmetic Conversions:
Given two operands to a binary operator, find the first type
in this list that matches one of the operands, then convert
the other operand to that type.

	long double
	double
	float
	(apply integral promotion, then)
		unsigned long
		long + unsigned -> long or unsigned long
		long
		unsigned
		int

Function argument conversions in the absence of argument types:
	integral promotions
	float -> double

There is an implicit "x != 0" in

	if (x)
	while (x)
	do while (x)
	for (; x; )
	x && x
	x || x
	x ? y : z

An explicit "x != 0" in these contexts serves no semantic purpose.
And "x == 0" in these contexts might be better written as "!x".


Scopes, Namespaces, and Linkage
-------------------------------

Scopes:
	file
	block
	entire function body (for labels)
	prototype

Beware struct/union/enum tags in prototype scopes.

Distinct namespaces (per scope):
	struct/union/enum tags
	labels
	everything else

Storage classes determine linkage of names thus:

	if "static" {
		if file scope
			linkage is internal
		else
			no linkage
	} else if "extern" or a function {
		if a declaration is visible at file scope
			link to it
		else
			linkage is external
	} else if file scope
		linkage is external
	else
		no linkage

Object declarations with initializers and function declarations
with bodies are definitions.  Object declarations without
initializers are tentative definitions with zero fill if
they are not "extern".


Translation Steps
-----------------

A C compiler must behave as if each of these steps were completely
performed before proceeding.

	Turn end-of-line indicators into newlines and replace ??trigraphs
	Delete all backslash-newline pairs
	Form tokens and replace comments by single spaces
	Preprocessing and macro expansion
	Process \escape sequences in 'character constants' and "string literals"
	Delete white space, including newlines
	Concatenate adjacent "string literals"
	Parse and generate code
	Link