半角カタカナにどのようなものがあるかは、
シフトJISの半角カナの文字コード定義を参考にすればよいだろう。
                                           (カナは全角で記載してある) 
┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
│  │_0│_1│_2│_3│_4│_5│_6│_7│_8│_9│_A│_B│_C│_D│_E│_F│
├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
│A_│  │。│「│」│、│・│ヲ│ァ│ィ│ゥ│ェ│ォ│ャ│ュ│ョ│ッ│
├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
│B_│ー│ア│イ│ウ│エ│オ│カ│キ│ク│ケ│コ│サ│シ│ス│セ│ソ│
├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
│C_│タ│チ│ツ│テ│ト│ナ│ニ│ヌ│ネ│ノ│ハ│ヒ│フ│ヘ│ホ│マ│
├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
│D_│ミ│ム│メ│モ│ヤ│ユ│ヨ│ラ│リ│ル│レ│ロ│ワ│ン│゛│゜│
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
『。「」、・ー゛゜』あたりが半角カナ記号といったところか。

シェル内で「cd」コマンドでカレントディレクトリを移動するように記述しても
実行した結果、実行時のままのディレクトリにいるということがある。

ということで、こういう場合でも移動できるようにする方法。
┌──────────────────────────────────────┐
│. ./シェル.sh                                                               │
└──────────────────────────────────────┘
先頭に「.」をつけるとよい。

但し、これは非推奨らしくいわば裏技のようだ。

「int」型と「unsigned int」型を比較する場合に、
キャストする必要があった場合、どちらをキャストすべきか？

  (1) 「(unsigned int)int_value ==      unsigned_int_value」
  (2) 「              int_value == (int)unsigned_int_value」

  (1) 「-1」が「65535(4294967295)」とみなされる
  (2) 「65535(4294967295)」が「-1」とみなされる

どちらかというと(1)の方が(2)よりも頻度が高いだろう。
ということで、30000にも満たないループインデックスとかを
「unsigned int」型(「size_t」など)と比較する場面があった場合には
(1)より(2)の方、つまり「int」型で比較した方がよいということになる。

但し、上記は如何なる場合にも通用する訳ではないので(30000を超える場合など)
注意のこと。

構造体(普通の型でもよいが)の配列数を縛りたい場合がある。

構造体の一部としての構造体であれば、こんな感じでできる。
┌──────────────────────────────────────┐
│typedef struct {                                                            │
│    構造体  変数[配列数];                                                   │
│} 配列型;                                                                   │
└──────────────────────────────────────┘

では、上記のように項目が一つしかない場合はもっとシンプルに書けないか？
このように書くらしい。
┌──────────────────────────────────────┐
│typedef 構造体 配列型[配列数];                                              │
└──────────────────────────────────────┘

ポインタ関数配列の定義といい、なんだかわかりません。
(たぶん理にはかなってるんだろうなぁ)

C言語において、変数定義と変数宣言は違う。
  「定義」…「領域を確保する」
  「宣言」…「(存在を知らせるだけで)領域を確保しない」

externするグローバル変数は、実体がなければならない。
┌──────────────────────────────────────┐
│int グローバル変数 = 0;                                                     │
└──────────────────────────────────────┘
これが変数定義。

一方、ヘッダファイル等を通じてこれをexternすることができる。
┌──────────────────────────────────────┐
│extern int グローバル変数;                                                  │
└──────────────────────────────────────┘
これが変数宣言。
この場合、初期値を代入できないのは、定義じゃないからだ。

ちなみに、関数の処理がない方は、関数宣言となる。
┌──────────────────────────────────────┐
│static void  func(void);                                                    │
└──────────────────────────────────────┘
処理を書いている方は、関数定義となる。
┌──────────────────────────────────────┐
│static void  func(void) {                                                   │
│    // 処理;                                                                │
│}                                                                           │
└──────────────────────────────────────┘

この前、シャットダウン時のログを調べたが、スリープ時はどうか。

こちらはこんな感じだ。
┌──────────────────────────────────────┐
│システムがスリープ状態になります。                                          │
│スリープの理由: アプリケーション API                                        │
└──────────────────────────────────────┘
手動でも「アプリケーション API」扱いらしい。

リモートデスクトップで接続すると、接続先のイベントビューアに
以下のエラーが記録される場合がある。
┌──────────────────────────────────────┐
│プリンター ■■■■ に必要なドライバー ■■■■ が認識されません。          │
│管理者に問い合わせてドライバーをインストールしてから、                      │
│もう一度ログインしてください。                                              │
└──────────────────────────────────────┘

これは、自身のローカルプリンタが接続先にマッピングされるかららしい。
で、そのプリンタがないから、エラーと。。。

対策としては、以下ウインドウにて、「■プリンタ」のチェックをはずすとよい。
┌──────────────────────────────────────┐
│リモートデスクトップ接続                                                    │
├──────────────────────────────────────┤
│┌─┌─┌────────┐─┐─┐─┐                                    │
││  │  │ローカルリソース│  │  │  │                                    │
│┌───┘                └───────────────────────┐│
││┌ローカルデバイスとリソース─────────────────────┐││
│││リモートセッションで使用するデバイスとリソースを選択してください    │││
│││  □プリンタ                                                        │││
││└──────────────────────────────────┘││
│└────────────────────────────────────┘│
└──────────────────────────────────────┘

もしくは、rdpファイルを直接エディタで開いて以下を変更するとよい。
┌──────────────────────────────────────┐
│redirectprinters:i:1                                                        │
└──────────────────────────────────────┘
  ↓                                                                            
┌──────────────────────────────────────┐
│redirectprinters:i:0                                                        │
└──────────────────────────────────────┘

continue文は先頭に戻ると考えがちだが…。
┌──────────┐
│do {               ←─┐
│    continue;      ──┘
│} while (条件式);   │
└──────────┘

実は、末尾にジャンプして先頭に戻っているのであった。
┌──────────┐
│do {               ←──┐
│    continue;      ──┐│
│} while (条件式);  ←─┘┘
└──────────┘

なので、以下みたいな読み飛ばし条件でcontineする処理を、
普通のwhile文から流用しても、永久ループになるということではないのであった。
┌──────────────────────────────────────┐
│while (ポインタ = 次読込関数()) {                                           │
│    if (読み飛ばし条件) {                                                   │
│        continue;                                                           │
│    }                                                                       │
│}                                                                           │
├──────────────────────────────────────┤
│do {                                                                        │
│    if (読み飛ばし条件) {                                                   │
│        continue;                                                           │
│    }                                                                       │
│} while (ポインタ = 次読込関数());                                          │
└──────────────────────────────────────┘

ポインタ定義において、「*」の位置が以下の二種類のパターンがある。
┌──────────────────────────────────────┐
│char    *ptr  = NULL;                                                       │
├──────────────────────────────────────┤
│char*   ptr   = NULL;                                                       │
└──────────────────────────────────────┘
果たして、どっちがいいのであろうか？

後者を推奨する。根拠は以下の通り。

(1) 「const」との関係から
┌──────────────────────────────────────┐
│char* const   ptr   = NULL;                                                 │
└──────────────────────────────────────┘
  「ptr」が指す値を変更できないように縛るには「const char* ptr」のような
  書き方となるが、「ptr」のアドレスを変更できないように縛る場合、
  「char* const ptr」のように「const」が「*」の後ろに来る。
  これが「char *ptr」の場合だと、説明できない。

(2) 初期値の代入が意味するところから
  「*ptr = NULL」では「ptr」の指す先が「NULL」になるが
  「ptr = NULL」だと、「ptr」のアドレスが「NULL」になる。
  定義時の意味するところは後者なので「char*」＋「ptr = NULL」の方が
  わかりやすい。

(3) キャスト時の記述
  「(char *)ptr」だと「(char)」＋「*ptr」的な錯覚を与える。
  ＃ちと強引か。。。

なお、前者の場合、以下のような書き方ができるという利点があるようだが…。
┌──────────────────────────────────────┐
│char    *ptr1, *ptr2;                                                       │
└──────────────────────────────────────┘

    ┌─┬─┬─┬─┐
①＝│A │B │\0│塵│
    └─┴─┴─┴─┘
    ┌─┬─┬─┬─┐
②＝│X │Y │\0│芥│
    └─┴─┴─┴─┘
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
strcpy(①, ②); 
    ┌─┬─┬─┬─┐
①＝│X │Y │\0│塵│
    └─┴─┴─┴─┘
      ↑  ↑  ↑
    ┌─┬─┬─┬─┐
②＝│X │Y │\0│芥│  ※結合ではなく上書
    └─┴─┴─┴─┘
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
strcat(①, ②); 
    ┌───────┐
    ┌─┬─┌─┬─┬─┐
①＝│A │B │X │Y │\0│  ※この場合、規定領域をはみ出してしまった
    └─┴─└─┴─┴─┘
              ↑  ↑  ↑
            ┌─┬─┬─┬─┐
②＝        │X │Y │\0│芥│
            └─┴─┴─┴─┘
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
strncat(①, ②, 2); 
    ┌───────┐
    ┌─┬─┌─┬─┐
①＝│A │B │X │Y │  ※この場合、規定領域をはみ出さないが、終端がない
    └─┴─└─┴─┘
              ↑  ↑
            ┌─┬─┬─┬─┐
②＝        │X │Y │\0│芥│
            └─┴─┴─┴─┘
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
自製strncat2(①, ②, 4); 
                ┌─┐
                │\0│  ※最後に強制的に終端を上書する
                └─┘
    ┌──────↓┐
    ┌─┬─┌─┬─┐
①＝│A │B │X │\0│
    └─┴─└─┴─┘
              ↑  ↑
            ┌─┬─┬─┬─┐
②＝        │X │Y │\0│芥│
            └─┴─┴─┴─┘
┌──────────────────────────────────────┐
│size_t 自製strncat2(char* str1, char* str2, size_t size)                    │
│{                                                                           │
│    if ((strlen(str1) + strlen(str2)) < size) {                             │
│        strcat(str1, str2);                                                 │
│    } else {                                                                │
│        strncat(str1, str2, size - strlen(str1));                           │
│        str1[(size - 1)] = 0;                                               │
│    }                                                                       │
│    return strlen(str1);                                                    │
│}                                                                           │
└──────────────────────────────────────┘