main()
{
    var i;
    var s;
    s = 0;
    i = 0; 
    while(i < 10){
	  s = s + i;
	  i = i + 1;
    }
    println("s = %d",s);
}

/*
 * tinyc.l
 */
 
/* 準備 */
%{
#include "stdio.h"
%}
 
/* 規則 */
%%
[ \t]                   { /* Skip white space */ }
[\n]                    { yylineno++; }
"while"                 { printf("%d: WHILE\n", yylineno); }
"var"                   { printf("%d: VAR\n", yylineno); }
"for"                   { printf("%d: FOR\n", yylineno); }
[0-9][0-9]*             { printf("%d: CONSTANT %d\n",   yylineno, atoi(yytext)); }
\"[^\"]*\"              { printf("%d: LITERAL %s\n",    yylineno, yytext);       }
[a-zA-Z][0-9a-zA-Z]*    { printf("%d: IDENTIFIER %s\n", yylineno, yytext);       }
.                       { /* Skip other characters */ }
%%
 
/* ユーザ関数 */
int main() {
	yylex();
}

$ flex tinyc.l
$ gcc lex.yy.c -o tinyc_scan -lfl
$ ./tinyc_scan < test.c
1: IDENTIFIER main
3: VAR
3: IDENTIFIER i
4: VAR
4: IDENTIFIER s
5: IDENTIFIER s
5: CONSTANT 0
6: IDENTIFIER i
6: CONSTANT 0
7: WHILE
7: IDENTIFIER i
7: CONSTANT 10
8: IDENTIFIER s
8: IDENTIFIER s
8: IDENTIFIER i
9: IDENTIFIER i
9: IDENTIFIER i
9: CONSTANT 1
11: IDENTIFIER println
11: LITERAL "s = %d"
11: IDENTIFIER s

/*
 * tinyc.l yacc向けに修正
 */
 
/* 準備 */
%{
#include "stdio.h"
#include "tinyc.tab.h"
%}
 
/* 規則 */
%%
[ \t]                   { /* Skip white space */ }
[\n]                    { yylineno++; }
"+"                     { return '+'; }
"-"                     { return '-'; }
"*"                     { return '*'; }
"/"                     { return '/'; }
"{"                     { return '{'; }
"}"                     { return '}'; }
"("                     { return '('; }
")"                     { return ')'; }
"while"                 { return WHILE; }
"var"                   { return VAR; }
"for"                   { return FOR; }
[0-9][0-9]*             { yylval = atoi(yytext); return CONSTANT; }
\"[^\"]*\"              { yylval = (int)strdup(yytext); return LITERAL; }
[a-zA-Z][0-9a-zA-Z]*    { yylval = (int)strdup(yytext); return IDENTIFIER; }
.                       { return yytext[0]; }
%%
 
/* ユーザ関数 */
/* mainは.yに移動 */

/*
 * tinyc.y
 */
 
/* 準備 */
%{
#include <stdio .h>
%}
 
/* トークン定義 */
%token CONSTANT LITERAL IDENTIFIER
%token VAR TYPE WHILE FOR IF
%left ';' ','
%left '< ' '>'
%right '='
%left '+' '-'
%left '*'
%token '(' ')' '{' '}'
 
%start program
 
/* 構文定義 */
%%
 
program : external_definitions
 
external_definitions:
                external_definitions external_definition
        |       external_definition
 
external_definition:
                IDENTIFIER '(' parameters ')' block
        |       VAR IDENTIFIER '=' expr ';'
 
parameters:     parameters ',' parameter
        |       parameter
 
parameter:      /* empty */
        |       TYPE IDENTIFIER
 
block:          '{' statements '}'
 
statements :    statements statement
        |       statement
 
statement :     block
        |       expr ';'
        |       IF '(' expr ')' statement
        |       WHILE '(' expr ')' statement
        |       FOR '(' expr ';' expr ';' expr ')' statement
        |       VAR IDENTIFIER ';'  { printf("@ variable declaration %s @\n", $2); }
 
exprs:          exprs ',' expr
        |       expr
 
expr:           primary_expr
        |       IDENTIFIER '=' expr
        |       expr '+' expr   |   expr '-' expr   |   expr '*' expr
        |       expr '< ' expr   |   expr '>' expr
 
primary_expr:   IDENTIFIER      |       CONSTANT        |       LITERAL
        |       '(' expr ')'
        |       IDENTIFIER '(' exprs ')' { printf("@ function call %s @\n", $1); }
 
%%
 
/* ユーザ関数 */
int yydebug;
int main() {
    //  yydebug = 1;
    yyparse();
}
</stdio>

$ bison -d tinyc.y -v
$ flex tinyc.l
$ cc -c lex.yy.c -DYYDEBUG
$ cc -c tinyc.tab.c -DYYDEBUG
$ gcc lex.yy.o tinyc.tab.o -o tinyc_parser -lfl -ly
$ ./tinyc_parser < test.c
@ variable declaration i @
@ variable declaration s @
@ function call println @

$ grep -nH -I -R search_text *

#include "stdio.h"
#include "stdlib.h"
#include "getopt.h"
 
int main(int argc, char** argv) {
    int result = 0;
 
    while ((result = getopt(argc, argv, "abcd:e:")) != -1) {
        switch (result) {
        case 'a':
        case 'b':
        case 'c':
            printf("option: %c applied\n", result);
            break;
        case 'd':
        case 'e':
            printf("option %c applied with %s\n", result, optarg);
            break;
        case ':':   // no value applied
        case '?':   // invalid option
            exit(1);
        }
    }
 
    printf("@@ param start @@\n");
    for(int i = optind; i < argc; i++) {
        printf("param: %s \n", argv[i]);
    }
}

$ ./option_test -a -bc -d val_for_d param1 param2
option: a applied
option: b applied
option: c applied
option d applied with val_for_d
@@ param start @@
param: param1
param: param2

#include "stdio.h"
#include "stdlib.h"
#include "getopt.h"
 
int main(int argc, char** argv) {
    struct option long_opts[] = {
        {"ls",      0, NULL,  0},    // ls doesn't have option value
        {"type",    1, NULL,  1},    // type has option value
        {"help",    0, NULL, 'h'},   // alias of h
        {"version", 0, NULL, 'v'},   // alias of v
        {0, 0, 0, 0}  // 最後の要素は全部0の必要があります。
    };
 
    int result = 0;
    int opt_idx = 0;
    while ((result = getopt_long(argc, argv, "hv", long_opts, &opt_idx)) != -1) {
        switch (result) {
        // for long options
        case 0:  // ls
        case 1:  // type
            printf("[%s] applied: %s\n", long_opts[opt_idx].name, optarg);
            break;
 
        // for short options
        case 'h':
            printf("help! \n");
            break;
        case 'v':
            printf("version! \n");
            break;
        case ':':
        case '?':
            exit(1);
        }
    }
 
    printf("@@ param start @@\n");
    for(int i = optind; i < argc; i++) {
        printf("param: %s \n", argv[i]);
    }
}

$ ./option_test -v --type=text --ls . hello.txt
version!
[type] applied: text
[ls] applied: (null)
@@ param start @@
param: .
param: hello.txt

#include ＜iostream＞
using namespace std;
 
int main(int argc, char** argv) {
    double small = 1e-18;
    double big   = 1;
    double added = small + big;
    cout ＜＜ added ＜＜ endl;  // 1が出力される。(small分が切り捨てられてる)
}

$ g++ -g test.cpp
$ gdb ./a.out
(gdb) x/g &small
0xbfffee88:	0x3c32725dd1d243ac
(gdb) x/g &big
0xbfffee90:	0x3ff0000000000000
(gdb) x/g &added
0xbfffee98:	0x3ff0000000000000

#include "stdio.h"
#include "string.h"
#include "stdlib.h"
#include "unistd.h"
 
int main(int argc, char* argv) {
	char* filename = "test.txt";
	FILE* fh;
	char rbuf[16], wbuf[16];	
 
	// ファイルの初期化
	if (fh = fopen(filename, "w")) {
		fclose(fh);
	}
 
	// 親プロセスと子プロセスで同時に以下のコードを走らせる
	pid_t id = fork();	
	for (int i = 0; i < 10; i++) {
		pid_t cur = getpid();
		if (fh = fopen(filename, "r+")) {
			fread(rbuf, sizeof(char), sizeof(rbuf), fh);
			fseek(fh, 0L, SEEK_SET);
			sprintf(wbuf, "%d", atoi(rbuf)+1);
			fwrite(wbuf, sizeof(char), strlen(wbuf), fh);
			printf("%d:%s\n", cur, wbuf);
			fclose(fh);			
		}
	}
}

$ g++ flock_test.cpp -o flock_test && ./flock_test
# 出力例１ プロセスAが書き込む前に、プロセスBが読み込んでいる
80293:1
80292:1
80293:2
80293:3
80293:4
80292:5
80292:6
80293:7
80292:7
80293:8
80292:8
80293:9
80292:9
80293:10
80292:10
80293:11
80292:11
80293:12
80292:12
80292:13
 
# 出力例２プロセスAの書込中に、プロセスBも書込んでいる
$ ./flock_test
80322:1
80322:2
80323:2
80323:3
80323:4
80322:3
80323:4
80322:5
80323:6
80322:7
80322:8
80322:9
80322:10
80322:11
80322:12
80323:8
80323:83    # ここで値が壊れている
80323:84
80323:85
80323:86

#include "stdio.h"
#include "string.h"
#include "stdlib.h"
#include "unistd.h"
#include "sys/file.h"
 
int main(int argc, char* argv[]) {
	char* filename = "test.txt";
	FILE* fh;
	char rbuf[16], wbuf[16];	
 
	// ファイルの初期化
	if (fh = fopen(filename, "w")) {
		fclose(fh);
	}
 
	// 親プロセスと子プロセスで同時に以下のコードを走らせる
	pid_t id = fork();	
	for (int i = 0; i < 10; i++) {
		pid_t cur = getpid();
		if (fh = fopen(filename, "r+")) {
			int fd = fileno(fh);
			if (flock(fd, LOCK_EX) == 0) {  // ロックを取得
				fread(rbuf, sizeof(char), sizeof(rbuf), fh);
				fseek(fh, 0L, SEEK_SET);
				sprintf(wbuf, "%d", atoi(rbuf)+1);
				fwrite(wbuf, sizeof(char), strlen(wbuf), fh);
				printf("%d:%s\n", cur, wbuf);
			}
			fclose(fh);
			flock(fd, LOCK_UN);			    // ロックを解放
		}
	}
}

$ g++ flock_test.cpp -o flock_test && ./flock_test
80475:1
80475:2
80475:3
80475:4
80475:5
80475:6
80475:7
80475:8
80475:9
80475:10
80476:11
80476:12
80476:13
80476:14
80476:15
80476:16
80476:17
80476:18
80476:19
80476:20

#define   LOCK_SH   1    /* shared lock */
#define   LOCK_EX   2    /* exclusive lock */
#define   LOCK_NB   4    /* don't block when locking */
#define   LOCK_UN   8    /* unlock */

#include <vector>
#include <string>
#include <iostream>
#include <sstream>
 
using namespace std;
 
int main(int argc, char* argv) {
	stringstream ss("hello std world");   // これでスペースで文字列splitできる
	string elem;
	while (ss >> elem) {
		cout < < elem << endl;
	}
 
	return 0;
}