Learn C Programming

lesson ⧍ / ā§Ž ¡ C-āϰ āϏāĻ™ā§āϗ⧇ āĻĒāϰāĻŋāϚāϝāĻŧ: āĻĒā§āϰāĻĨāĻŽ program, āϚāĻŋāĻšā§āύ āϧāϰ⧇ āϧāϰ⧇

Module ā§§ ¡ C-āϰ āϏāĻ™ā§āϗ⧇ āĻĒāϰāĻŋāϚāϝāĻŧ: āĻĒā§āϰāĻĨāĻŽ program, āϚāĻŋāĻšā§āύ āϧāϰ⧇ āϧāϰ⧇

Syntax āφāϰ semantics: āϭ⧁āϞ āĻšāĻ“āϝāĻŧāĻžāϰ āĻĻ⧁āχ āϰāĻ•āĻŽ

FreeāĻĒāĻĄāĻŧāĻž

āĻāχ lesson-āĻ āϝāĻž āĻļāĻŋāĻ–āĻŦ⧇

  • Syntax error āφāϰ semantic error-āϰ āϤāĻĢāĻžāϤ āĻāĻ• āĻŦāĻžāĻ•ā§āϝ⧇ āĻŦāϞāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤
  • Compiler-āϰ āĻāĻ—āĻžāϰ⧋āϟāĻž āĻšā§‡āύāĻž message āĻĒāĻĄāĻŧ⧇ āĻŦāϞāϤ⧇ āĻĒāĻžāϰāĻŦ⧇ āφāϏāϞ⧇ āϕ⧀ āϘāĻŸā§‡āϛ⧇āĨ¤
  • Compiler āϤ⧋āĻŽāĻžāϰ program āύāĻŋāϤ⧇ āϰāĻžāϜāĻŋ āύāĻž āĻšāϞ⧇ āϏ⧇āϟāĻž āϕ⧇āύ āωāĻĒāĻ•āĻžāϰ, āĻŦā§‹āĻāĻžāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤

"āϏāĻžāχāϕ⧇āϞāϟāĻž āĻĒāĻžāĻšāĻžāĻĄāĻŧ āϖ⧇āϝāĻŧ⧇ āĻĢ⧇āϞāϞāĨ¤" āĻŦā§āϝāĻžāĻ•āϰāϪ⧇āϰ āĻĒā§āϰāϤāĻŋāϟāĻž āύāĻŋāϝāĻŧāĻŽ āĻŽāĻžāύāĻž āĻšāϝāĻŧ⧇āϛ⧇āĨ¤ āĻŦāĻžāĻ•ā§āϝāϟāĻžāϰ āϤāĻŦ⧁ āϕ⧋āύ⧋ āĻŽāĻžāύ⧇ āύ⧇āχāĨ¤

Program āĻ āĻŋāĻ• āĻāχ āĻĻ⧁āχ āϰāĻ•āĻŽā§‡āχ āϭ⧁āϞ āĻšāϝāĻŧāĨ¤ āĻšāϝāĻŧ compiler āϤ⧋āĻŽāĻžāϰ āϞ⧇āĻ–āĻž āĻĒāĻĄāĻŧāϤ⧇āχ āĻĒāĻžāϰ⧇ āύāĻž, āύāϝāĻŧ āϏ⧇ āύāĻŋāϖ⧁āρāϤāĻ­āĻžāĻŦ⧇ āĻĒāĻĄāĻŧ⧇ āĻāĻŽāύ āĻ•āĻŋāϛ⧁ āĻ•āϰ⧇ āϝ⧇āϟāĻž āϤ⧁āĻŽāĻŋ āϚāĻžāĻ“āύāĻŋāĨ¤ āĻĒā§āϰāĻĨāĻŽ āϰāĻ•āĻŽāϟāĻž āϤ⧋āĻŽāĻžāϕ⧇ āĻāĻ• āϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡ āĻĨāĻžāĻŽāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĨ¤ āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āϰāĻ•āĻŽāϟāĻž āĻāĻ• āĻŽāĻžāϏ āϞ⧁āĻ•āĻŋāϝāĻŧ⧇ āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

Maria āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰāϞ, Bob-āϰ program 5 āĻŦāĻžāχ 3 āϘāϰ⧇āϰ āϜāĻ¨ā§āϝ 8 āĻ›āĻžāĻĒāϛ⧇ āϕ⧇āύāĨ¤ Bob āĻŦāϞāϞ, compiler āϤ⧋ āϕ⧋āύ⧋ error āĻĻ⧇āϝāĻŧāύāĻŋāĨ¤ āĻ•āĻĨāĻžāϟāĻž āϏāĻ¤ā§āϝāĻŋ, āφāϰ āĻāϟāĻž āϕ⧋āύ⧋ āϝ⧁āĻ•ā§āϤāĻŋ āύāĻžāĨ¤

āϭ⧁āϞ āĻšāĻ“āϝāĻŧāĻžāϰ āĻĻ⧁āχ āϰāĻ•āĻŽ, āĻāĻ• āĻŦāĻžāĻ•ā§āϝ⧇ āĻ•āϰ⧇

Syntax āĻŽāĻžāύ⧇ āĻŦā§āϝāĻžāĻ•āϰāĻŖāĨ¤ āϚāĻŋāĻšā§āύāϗ⧁āϞ⧋āϰ āĻāχ āϏāĻžāϜāĻžāύ⧋ āϰ⧂āĻĒāϟāĻž āĻŦ⧈āϧ C āĻ•āĻŋ āύāĻžāĨ¤ Compiler āϏ⧇āϟāĻž āĻ āĻŋāĻ• āĻ•āϰ⧇, āφāϰ āϏ⧇ āĻ•āĻ–āύ⧋ āĻĻā§āĻŦāĻŋāϧāĻžāϝāĻŧ āĻĨāĻžāϕ⧇ āύāĻžāĨ¤

Semantics āĻŽāĻžāύ⧇ āĻ…āĻ°ā§āĻĨāĨ¤ āϧāϰ⧋ āĻāϟāĻž āĻŦ⧈āϧ CāĨ¤ āϤāĻžāĻšāϞ⧇ āĻāϟāĻž āφāϏāϞ⧇ āϕ⧀ āĻ•āϰāϛ⧇? āĻāϰ āωāĻ¤ā§āϤāϰ āϕ⧇āĻŦāϞ āϤ⧁āĻŽāĻŋ āĻĻāĻŋāϤ⧇ āĻĒāĻžāϰ⧋, āĻ•āĻžāϰāĻŖ āϤ⧁āĻŽāĻŋ āϕ⧀ āĻšā§‡āϝāĻŧ⧇āĻ›āĻŋāϞ⧇ āϏ⧇āϟāĻž āϕ⧇āĻŦāϞ āϤ⧁āĻŽāĻŋāχ āϜāĻžāύ⧋āĨ¤

āϤāĻžāχ syntax error āĻŽāĻžāύ⧇ āĻāĻŽāύ āĻāĻ•āϟāĻž āĻŦāĻžāĻ•ā§āϝ āϝ⧇āϟāĻž āĻŽā§‡āĻļāĻŋāύ āĻĒāĻĄāĻŧāϤ⧇āχ āĻĒāĻžāϰ⧇ āύāĻž, āφāϰ semantic error āĻŽāĻžāύ⧇ āϏ⧇ āĻĒāĻĄāĻŧ⧇ āϭ⧁āϞ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāϟāĻž āĻŦ⧁āĻā§‡ āύ⧇āϝāĻŧāĨ¤

Syntax error: āϝ⧇ āĻāĻ—āĻžāϰ⧋āϟāĻž message āϤ⧁āĻŽāĻŋ āϏāĻ¤ā§āϝāĻŋāχ āĻĻ⧇āĻ–āĻŦ⧇

āύāĻŋāĻšā§‡āϰ table-āϰ āĻĒā§āϰāϤāĻŋāϟāĻž message GCC 12-āϰ āϏāĻ¤ā§āϝāĻŋāĻ•āĻžāϰ⧇āϰ output, āĻŽāĻžāύ⧇ Playground-āϰ āĻĒ⧇āĻ›āύ⧇āϰ compiler-āϟāĻžāϰāĨ¤ āĻāϟāĻžāϕ⧇ āĻŽā§āĻ–āĻ¸ā§āĻĨ āĻ•āϰāĻžāϰ āϤāĻžāϞāĻŋāĻ•āĻž āύāĻž āϭ⧇āĻŦ⧇ āĻāĻ•āϟāĻž āϤāĻžāϞāĻŋāĻ•āĻž āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻĄāĻŧā§‹āĨ¤ āϤ⧋āĻŽāĻžāϰ message-āϰ āĻšā§‡āĻšāĻžāϰāĻžāϟāĻž āϖ⧁āρāĻœā§‡ āύāĻžāĻ“, āφāϰ āϏāĻžāϰāĻŋāϟāĻžāχ āĻŦāϞ⧇ āĻĻ⧇āĻŦ⧇ āϕ⧀ āϘāĻŸā§‡āϛ⧇āĨ¤

āϤ⧁āĻŽāĻŋ āϝāĻž āϞāĻŋāϖ⧇āĻ›GCC 12 āϝāĻž āĻŦāϞ⧇āφāϏāϞ⧇ āϝāĻž āϘāĻŸā§‡āϛ⧇
Statement-āϰ āĻĒāϰ⧇ ; āύ⧇āχerror: expected ';' before 'return'Statement-āϟāĻž āĻļ⧇āώāχ āĻšāϝāĻŧāύāĻŋāĨ¤ āĻĻā§‹āώāϟāĻž āϝ⧇ āϞāĻžāχāύ⧇āϰ āύāĻžāĻŽ āĻŦāϞāϛ⧇ āϤāĻžāϰ āωāĻĒāϰ⧇āϰ āϞāĻžāχāύ⧇
āĻāĻ•āϟāĻž block āĻ–ā§‹āϞāĻž āϰ⧇āϖ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻžerror: expected declaration or statement at end of inputāĻāĻ•āϟāĻž brace-āϰ āϏāĻ™ā§āĻ—ā§€ āύ⧇āχ, āφāϰ compiler āĻŸā§‡āϰ āĻĒ⧇āϝāĻŧ⧇āϛ⧇ file-āϰ āĻāĻ•āĻĻāĻŽ āĻļ⧇āώ⧇
Printf("Hi\n");warning: implicit declaration of function 'Printf', āϤāĻžāϰāĻĒāϰ undefined reference to 'Printf'C āϛ⧋āϟ āφāϰ āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ āφāϞāĻžāĻĻāĻž āĻ—ā§‹āύ⧇, āϤāĻžāχ āĻāϟāĻž āφāϞāĻžāĻĻāĻž āύāĻžāĻŽ, āφāϰ āĻ“āϟāĻž āϕ⧇āω āϞ⧇āϖ⧇āύāĻŋ
#include <stdio.h> āύ⧇āχwarning: implicit declaration of function 'printf'Compiler printf-āϰ āύāĻžāĻŽāĻ“ āĻļā§‹āύ⧇āύāĻŋ, āĻšā§‡āĻšāĻžāϰāĻžāϟāĻž āĻ…āύ⧁āĻŽāĻžāύ āĻ•āϰ⧇āϛ⧇, āφāϰ āϤāĻŦ⧁āĻ“ build āĻ•āϰ⧇āϛ⧇
int 2marks = 5;error: invalid suffix "marks" on integer constantāύāĻžāĻŽ āĻ…āĻ™ā§āĻ• āĻĻāĻŋāϝāĻŧ⧇ āĻļ⧁āϰ⧁ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻž, āϤāĻžāχ compiler 2marks-āϕ⧇ āϏāĻ‚āĻ–ā§āϝāĻž āϧāϰ⧇ āύāĻŋāϝāĻŧ⧇āϛ⧇
int total-marks = 5;error: expected '=', ',', ';', 'asm' or '__attribute__' before '-' tokenHyphen āĻšāϞ⧋ minus operatorāĨ¤ āύāĻžāĻŽā§‡ underscore āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧋
int int = 5;error: two or more data types in declaration specifiersKeyword āϏāĻ‚āϰāĻ•ā§āώāĻŋāϤ, āĻ“āϟāĻž āĻ•āĻ–āύ⧋ āύāĻžāĻŽ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻž
Declare āύāĻž āĻ•āϰāĻž āĻāĻ•āϟāĻž āύāĻžāĻŽerror: 'count' undeclared (first use in this function)āĻŦāĻžāύāĻžāύ⧇āϰ āϭ⧁āϞ, āĻ…āĻĨāĻŦāĻž āύāĻžāĻŽāϟāĻž āĻ…āĻ¨ā§āϝ āĻāĻ•āϟāĻž block-āϰ āϭ⧇āϤāϰ⧇ āĻĨāĻžāϕ⧇
#include <studio.h>fatal error: studio.h: No such file or directoryPreprocessor āϧāĻžāĻĒ 1-āĻāχ āĻĨ⧇āĻŽā§‡ āϗ⧇āϛ⧇āĨ¤ āĻ•āĻŋāϛ⧁āχ compile āĻšāϝāĻŧāύāĻŋ
/* outer /* inner */ outer */error: unknown type name 'outer'Comment-āϰ āϭ⧇āϤāϰ⧇ comment āĻŦāϏ⧇ āύāĻžāĨ¤ āĻĒā§āϰāĻĨāĻŽ */ āĻ“āϟāĻž āĻŦāĻ¨ā§āϧ āĻ•āϰ⧇āϛ⧇, āĻŦāĻžāĻ•āĻŋāϟāĻž code
if (marks = 90)Playground-āĻ āĻ•āĻŋāϛ⧁āχ āύāĻž; -Wall āĻĻāĻŋāϞ⧇ warning: suggest parentheses around assignment used as truth valueSyntax āĻŦ⧈āϧ, āĻŽāĻžāύ⧇āϟāĻž āĻĒā§āϰāĻžāϝāĻŧ āύāĻŋāĻļā§āϚāĻŋāϤāĻ­āĻžāĻŦ⧇ āϭ⧁āϞāĨ¤ āĻĒāϰ⧇āϰ āĻ…āĻ‚āĻļāϟāĻž āĻĻ⧇āĻ–ā§‹

Version-āϰ āĻāĻ•āϟāĻž āĻ•āĻĨāĻžāĨ¤ āϤāĻŋāύ āφāϰ āϚāĻžāϰ āύāĻŽā§āĻŦāϰ āϏāĻžāϰāĻŋ GCC 12-āϤ⧇ warning, āφāϰ Playground āĻ“āϟāĻžāχ āϚāĻžāϞāĻžāϝāĻŧāĨ¤ GCC 14 āĻĻ⧁āχāϟāĻžāϕ⧇āχ error āĻŦāĻžāύāĻžāϝāĻŧāĨ¤ Playground āϝ⧇ program build āĻ•āϰ⧇ āϏ⧇āϟāĻž āϤ⧋āĻŽāĻžāϰ āύāĻŋāĻœā§‡āϰ compiler āύāĻŋāϤ⧇ āύāĻž āϚāĻžāχāϞ⧇ āĻ•āĻžāϰāĻŖāϟāĻž āϏāĻžāϧāĻžāϰāĻŖāϤ āĻāϟāĻžāχāĨ¤

āϤāĻžāχ syntax error āĻ•āĻ–āύ⧋āχ āϰāĻšāĻ¸ā§āϝ āύāĻžāĨ¤ āĻāϟāĻž āĻāĻ•āϟāĻž table-āϰ āĻāĻ•āϟāĻž āĻŦāĻžāĻ•ā§āϝ, āφāϰ table-āϟāĻž āĻāĻ• āĻŽāĻžāϏ⧇āϰ āĻŽāĻ§ā§āϝ⧇āχ āϤ⧋āĻŽāĻžāϰ āĻŽā§āĻ–āĻ¸ā§āĻĨ āĻšāϝāĻŧ⧇ āϝāĻžāĻŦ⧇āĨ¤

Semantic error: compiler-āϰ āϕ⧋āύ⧋ āĻŽāϤ āύ⧇āχ

Bob-āϰ program-āϟāĻž āύāĻŋāĻšā§‡ āĻĒ⧁āϰ⧋āϟāĻž āφāϛ⧇āĨ¤ āĻāϟāĻž āĻļā§‚āĻ¨ā§āϝ warning-āĻ compile āĻšāϝāĻŧāĨ¤

#include <stdio.h>

int main(void)
{
    int length = 5;
    int width = 3;
    int area = length + width;   /* legal C, wrong meaning */

    printf("Area = %d\n", area);
    return 0;
}
Area = 8

5 āĻŦāĻžāχ 3 āϘāϰ⧇āϰ āĻ•ā§āώ⧇āĻ¤ā§āϰāĻĢāϞ 15āĨ¤ "Area" āĻļāĻŦā§āĻĻāϟāĻžāϰ āĻŽāĻžāύ⧇ compiler āϜāĻžāύ⧇ āύāĻžāĨ¤ āϏ⧇ āϜāĻžāύ⧇ āϤ⧁āĻŽāĻŋ āĻĻ⧁āχāϟāĻž integer āϝ⧋āĻ— āĻ•āϰāϤ⧇ āĻŦāϞ⧇āĻ›, āφāϰ āĻĻ⧁āχāϟāĻž integer āϝ⧋āĻ— āĻ•āϰāĻž āĻĒ⧁āϰ⧋āĻĒ⧁āϰāĻŋ āĻŦ⧈āϧāĨ¤

āĻāχ lesson āĻĨ⧇āϕ⧇ āĻāχ āĻŦāĻžāĻ•ā§āϝāϟāĻžāχ āϏāĻ™ā§āϗ⧇ āύāĻŋāϝāĻŧ⧇ āϝāĻžāĻ“āĨ¤ Compiler āϤ⧋āĻŽāĻžāϰ āĻŦā§āϝāĻžāĻ•āϰāĻŖ āĻĒāĻžāĻšāĻžāϰāĻž āĻĻ⧇āϝāĻŧāĨ¤ āĻ…āĻ°ā§āĻĨ āĻĒāĻžāĻšāĻžāϰāĻž āĻĻāĻžāĻ“ āϕ⧇āĻŦāϞ āϤ⧁āĻŽāĻŋāĨ¤

āϤāĻžāχ āĻĒāϰāĻŋāĻˇā§āĻ•āĻžāϰ āĻāĻ•āϟāĻž build āϤ⧋āĻŽāĻžāϕ⧇ āĻŦāϞ⧇, āĻŽā§‡āĻļāĻŋāύ āϤ⧋āĻŽāĻžāϰ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāϗ⧁āϞ⧋ āĻŦ⧁āĻā§‡āϛ⧇, āφāϰ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāϗ⧁āϞ⧋ āĻ āĻŋāĻ• āĻ›āĻŋāϞ āĻ•āĻŋ āύāĻž āϤāĻž āύāĻŋāϝāĻŧ⧇ āĻ•āĻŋāϛ⧁āχ āĻŦāϞ⧇ āύāĻžāĨ¤

Assignment āφāϰ comparison: āĻāĻ• keystroke-āϰ āĻĢāĻžāρāĻĻ

C-āϤ⧇ = āĻāĻ•āϟāĻž āĻŽāĻžāύ āĻŦāϏāĻžāϝāĻŧ, āφāϰ == āĻĻ⧁āχāϟāĻž āĻŽāĻžāύ āĻŽā§‡āϞāĻžāϝāĻŧāĨ¤ āĻĻ⧁āχāϟāĻž āĻāĻ•āϟāĻž keystroke-āϰ āĻĻā§‚āϰāĻ¤ā§āĻŦ⧇, āφāϰ āĻ“āϰāĻž āωāĻ˛ā§āĻŸā§‹ āϜāĻŋāύāĻŋāϏ āĻŦā§‹āĻāĻžāϝāĻŧāĨ¤

āĻāϟāĻž āĻŦāĻŋāĻĒāĻœā§āϜāύāĻ• āĻšāĻ“āϝāĻŧāĻžāϰ āĻ•āĻžāϰāĻŖāϟāĻž āĻšāϞ⧋, = āϕ⧋āύ⧋ statement āύāĻžāĨ¤ āĻāϟāĻž āĻāĻ•āϟāĻž expression, āφāϰ expression-āϰ āĻāĻ•āϟāĻž āĻŽāĻžāύ āĻĨāĻžāϕ⧇āĨ¤ marks = 60-āϰ āĻŽāĻžāύ 60, āϤāĻžāχ āĻ“āϟāĻž āĻ›āĻžāĻĒāĻžāĻ“ āϝāĻžāϝāĻŧ, āφāϰ Example 3 āĻ āĻŋāĻ• āϏ⧇āϟāĻžāχ āĻ•āϰ⧇āĨ¤

āĻĒāϰ⧇, Module 5-āĻ, āĻāϗ⧁āϞ⧋ āϤ⧁āĻŽāĻŋ if-āϰ āϭ⧇āϤāϰ⧇ āĻŦāϏāĻžāĻŦ⧇āĨ¤ āϏ⧇āĻ–āĻžāύ⧇ āĻļā§‚āĻ¨ā§āϝ āύāĻž āĻāĻŽāύ āϝ⧇āϕ⧋āύ⧋ āĻŽāĻžāύ āϏāĻ¤ā§āϝāĻŋ āĻŦāϞ⧇ āĻ—ā§‹āύāĻž āĻšāϝāĻŧāĨ¤ āϤāĻžāχ if (marks = 90) 90 āĻŦāϏāĻžāϝāĻŧ, āĻļā§‚āĻ¨ā§āϝ āύāĻž āĻāĻŽāύ āĻāĻ•āϟāĻž āĻŽāĻžāύ āĻĻ⧇āϖ⧇, āφāϰ āĻļāĻžāĻ–āĻžāϟāĻž āϏāĻŦ āϏāĻŽāϝāĻŧ āϚāĻžāϞāĻžāϝāĻŧāĨ¤ āĻ“āχ āĻāĻ•āϟāĻž keystroke-āϰ āĻĒ⧇āĻ›āύ⧇ software-āϰ āĻĻ⧁āύāĻŋāϝāĻŧāĻž āĻŦāĻŋāĻĒ⧁āϞ āϟāĻžāĻ•āĻž āϖ⧁āχāϝāĻŧ⧇āϛ⧇āĨ¤

āĻāĻ•āϟāĻž āĻŦāĻžāρāϚāĻžāϰ āωāĻĒāĻžāϝāĻŧ āĻšāϞ⧋ āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻž āφāϗ⧇ āϞ⧇āĻ–āĻž: if (90 == marks)āĨ¤ āĻ“āĻ–āĻžāύ⧇ āĻšāĻžāϤ āĻĢāϏāϕ⧇ āĻāĻ•āϟāĻž = āϞāĻŋāĻ–āϞ⧇ compiler āϰāĻžāϜāĻŋ āĻšāĻŦ⧇ āύāĻž, āĻ•āĻžāϰāĻŖ 90 āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻžāϰ āϭ⧇āϤāϰ⧇ āĻ•āĻŋāϛ⧁ āĻŦāϏāĻžāύ⧋ āϝāĻžāϝāĻŧ āύāĻžāĨ¤ āĻāχ āĻ…āĻ­ā§āϝāĻžāϏāϟāĻžāϰ āύāĻžāĻŽ Yoda condition, āĻ•āĻžāϰāĻŖ āĻļ⧁āύāϤ⧇ āωāĻ˛ā§āĻŸā§‹ āϞāĻžāϗ⧇āĨ¤

āϤāĻžāχ == āĻāĻ•āϟāĻž āĻĒā§āϰāĻļā§āύ āĻ•āϰ⧇, = āĻāĻ•āϟāĻž āφāĻĻ⧇āĻļ āĻĻ⧇āϝāĻŧ, āφāϰ compiler āĻĻ⧁āχāϟāĻžāϤ⧇āχ āϖ⧁āĻļāĻŋāĨ¤

āĻāĻ• āϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡āϰ āϏāĻžāϰāĻžāχ āφāϰ āĻāĻ• āĻŽāĻžāϏ⧇āϰ āϏāĻžāϰāĻžāχ

Build āφāϟāϕ⧇ āϗ⧇āϞ⧇ āĻŽāύ⧇ āĻšāϝāĻŧ compiler āĻ—ā§‹āρāϝāĻŧāĻžāĻ°ā§āϤ⧁āĻŽāĻŋ āĻ•āϰāϛ⧇āĨ¤ āĻŦā§āϝāĻžāĻĒāĻžāϰāϟāĻž āωāĻ˛ā§āĻŸā§‹āĨ¤ āϏ⧇ āϝ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž error āĻ›āĻžāĻĒ⧇, āϏ⧇āϟāĻž āĻāĻŽāύ āĻāĻ•āϟāĻž bug āϝāĻžāϰ āĻĒāĻŋāϛ⧁ āϤ⧋āĻŽāĻžāϕ⧇ āφāĻ—āĻžāĻŽā§€ āϏāĻĒā§āϤāĻžāĻšā§‡ āύāĻŋāϤ⧇ āĻšāĻŦ⧇ āύāĻžāĨ¤

Syntax āφāϰ semantics-āϰ āĻŽāĻžāĻā§‡āϰ āĻĢāĻžāρāĻ•āϟāĻžāϤ⧇āχ āφāϏāϞ bug-āϰāĻž āĻĨāĻžāϕ⧇, āφāϰ āĻĻ⧁āχāϟāĻž āĻŦāĻŋāĻ–ā§āϝāĻžāϤ āϘāϟāύāĻž āĻĢāĻžāρāĻ•āϟāĻžāϰ āφāĻ•āĻžāϰ āĻĻ⧇āĻ–āĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĨ¤

2014 āϏāĻžāϞ⧇ Apple-āϰ TLS code-āĻ āĻāĻ•āϟāĻž bug āĻŦ⧇āϰ⧋āϝāĻŧ, āϝāĻžāϰ āύāĻžāĻŽ goto failāĨ¤ āĻāĻ•āϟāĻž goto fail; āϞāĻžāχāύ āĻĻ⧁āχāĻŦāĻžāϰ āϞ⧇āĻ–āĻž āĻšāϝāĻŧ⧇āĻ›āĻŋāϞāĨ¤ Syntax āĻ›āĻŋāϞ āύāĻŋāϖ⧁āρāϤ, āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āĻ•āĻĒāĻŋāϟāĻž certificate-āϰ āĻāĻ•āϟāĻž āϝāĻžāϚāĻžāχ āĻāĻĄāĻŧāĻŋāϝāĻŧ⧇ āϝ⧇āϤ, āφāϰ āϝ⧇ connection āĻŦāĻžāϤāĻŋāϞ āĻšāĻ“āϝāĻŧāĻžāϰ āĻ•āĻĨāĻž āϏ⧇āϗ⧁āϞ⧋ āĻŽā§‡āύ⧇ āύ⧇āĻ“āϝāĻŧāĻž āĻšāϤ⧋āĨ¤

2008 āϏāĻžāϞ⧇ Debian-āϰ āĻāĻ•āϜāύ maintainer OpenSSL āĻĨ⧇āϕ⧇ āĻĻ⧁āχāϟāĻž āϞāĻžāχāύ āϏāϰāĻŋāϝāĻŧ⧇ āĻĻ⧇āύ, memory āĻĒāϰ⧀āĻ•ā§āώāĻžāϰ āĻāĻ•āϟāĻž warning āĻĨāĻžāĻŽāĻžāϤ⧇āĨ¤ Code āϤāĻ–āύ⧋ compile āĻšāϝāĻŧāĨ¤ āϏ⧇āχ āϏāĻ™ā§āϗ⧇ random āϏāĻ‚āĻ–ā§āϝāĻž āϤ⧈āϰāĻŋāϰ āĻ…āĻ‚āĻļāϟāĻž āĻĒāĻ™ā§āϗ⧁ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ, āφāϰ āĻĻ⧁āχ āĻŦāĻ›āϰ āϧāϰ⧇ Debian-āĻ āĻŦāĻžāύāĻžāύ⧋ āĻĒā§āϰāϤāĻŋāϟāĻž key āĻāϏ⧇āϛ⧇ āϛ⧋āĻŸā§āϟ āĻāĻ•āϟāĻž āϏ⧇āϟ āĻĨ⧇āϕ⧇āĨ¤

āϤāĻžāχ compiler āϏāĻ¸ā§āϤāĻž āϭ⧁āϞāϗ⧁āϞ⧋ āϧāϰ⧇, āφāϰ āĻĻāĻžāĻŽāĻŋ āϭ⧁āϞāϗ⧁āϞ⧋ āϏāĻŦāχ semanticāĨ¤

Message āĻĒāĻĄāĻŧāĻžāϰ āϤāĻŋāύāϟāĻž āĻ…āĻ­ā§āϝāĻžāϏ

āĻļ⧁āϧ⧁ āĻĒā§āϰāĻĨāĻŽ error-āϟāĻž āĻĒāĻĄāĻŧā§‹āĨ¤ āĻāĻ•āϟāĻž āϭ⧁āϞ āĻĨ⧇āϕ⧇ āĻĒā§āϰāĻžāϝāĻŧāχ āĻŦāĻŋāĻļāϟāĻž message āφāϏ⧇, āĻ•āĻžāϰāĻŖ āĻĒā§āϰāĻĨāĻŽ āĻ—ā§‹āϞāĻŽāĻžāϞ⧇āϰ āĻĒāϰ compiler āϤ⧋āĻŽāĻžāϰ program āϭ⧁āϞāĻ­āĻžāĻŦ⧇ āĻĒāĻĄāĻŧāϛ⧇āĨ¤ āĻĒā§āϰāĻĨāĻŽāϟāĻž āϏāĻžāϰāĻžāĻ“, āφāĻŦāĻžāϰ build āĻ•āϰ⧋āĨ¤

āϝ⧇ āϞāĻžāχāύ⧇āϰ āύāĻžāĻŽ āĻŦāϞāϛ⧇, āϤāĻžāϰ āωāĻĒāϰ⧇āϰ āϞāĻžāχāύāϟāĻž āĻĻ⧇āĻ–ā§‹āĨ¤ āĻŦāĻžāĻĻ āĻĒāĻĄāĻŧāĻž semicolon-āϰ āĻ–āĻŦāϰ āφāϏ⧇ āĻĒāϰ⧇āϰ statement āϝ⧇āĻ–āĻžāύ⧇ āĻļ⧁āϰ⧁, āϏ⧇āĻ–āĻžāύ āĻĨ⧇āϕ⧇; semicolon āϝ⧇āĻ–āĻžāύ⧇ āĻŦāϏāĻžāϰ āĻ•āĻĨāĻž āĻ›āĻŋāϞ āϏ⧇āĻ–āĻžāύ āĻĨ⧇āϕ⧇ āύāĻžāĨ¤

āĻšā§āĻŦāĻšā§ āĻļāĻŦā§āĻĻāϗ⧁āϞ⧋ āϟ⧁āϕ⧇ āύāĻžāĻ“āĨ¤ āĻ–ā§‹āρāĻœā§‹ expected declaration or statement at end of input, "āĻ…āĻĻā§āϭ⧁āϤ brace error" āύāĻžāĨ¤ āĻšā§āĻŦāĻšā§ āĻļāĻŦā§āĻĻ āĻāĻ•āϟāĻž debugging-āϰ āĻšāĻžāϤāĻŋāϝāĻŧāĻžāϰ, āφāϰ āϏ⧇āϜāĻ¨ā§āϝāχ āĻĒāϰ⧇āϰ lesson C-āϰ āĻĒā§āϰāϤāĻŋāϟāĻž āϚāĻŋāĻšā§āύ⧇āϰ āύāĻžāĻŽ āĻļ⧇āĻ–āĻžāϝāĻŧāĨ¤

āĻĒā§āϰāϤāĻŋāϟāĻž GCC message-āϰ āĻ—āĻĄāĻŧāύ

hello.c : 5 : 12 : error : expected ';' before 'return'
   |      |    |     |            |
   file   line column severity    what the compiler expected
  • file āφāϰ line āĻŦāϞ⧇ compiler āĻšāĻžāϞ āĻ›āĻžāĻĄāĻŧāĻžāϰ āϏāĻŽāϝāĻŧ āϕ⧋āĻĨāĻžāϝāĻŧ āĻ›āĻŋāϞ, āϤ⧁āĻŽāĻŋ āϕ⧋āĻĨāĻžāϝāĻŧ āϭ⧁āϞ āĻ•āϰ⧇āĻ› āϏ⧇āϟāĻž āϏāĻŦ āϏāĻŽāϝāĻŧ āύāĻžāĨ¤
  • column āĻšāϞ⧋ āĻ“āχ āϞāĻžāχāύ⧇ character-āϰ āϜāĻžāϝāĻŧāĻ—āĻž, āφāϰ āĻāϟāĻž āϏāĻžāϧāĻžāϰāĻŖāϤ āĻāĻ•āĻĻāĻŽ āĻ āĻŋāĻ•āĨ¤
  • severity āĻšāϝāĻŧ error (āĻ•āĻŋāϛ⧁āχ āϤ⧈āϰāĻŋ āĻšāϝāĻŧ āύāĻž), warning (āϤāĻŦ⧁āĻ“ āϤ⧈āϰāĻŋ āĻšāϝāĻŧ) āĻŦāĻž fatal error (āĻ“āĻ–āĻžāύ⧇āχ āĻĨ⧇āĻŽā§‡ āϗ⧇āϛ⧇)āĨ¤
  • āϤāĻžāϰ āĻĒāϰ⧇āϰ āϞ⧇āĻ–āĻžāϟāĻž āϤ⧋āĻŽāĻžāϰ āωāĻĻā§āĻĻ⧇āĻļā§āϝ āύāĻŋāϝāĻŧ⧇ compiler-āϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ­āĻžāϞ⧋ āĻ…āύ⧁āĻŽāĻžāύāĨ¤ āĻ“āϟāĻžāϕ⧇ āĻ…āύ⧁āĻŽāĻžāύ āĻšāĻŋāϏ⧇āĻŦ⧇āχ āĻĒāĻĄāĻŧā§‹āĨ¤
Example 1: āĻŦ⧈āϧ, āφāϰ āϭ⧁āϞ

āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϛ⧋āϟ semantic error āϝ⧇āϟāĻž āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻāĻ•āϟāĻž operator, āĻāĻ•āϟāĻž āϭ⧁āϞ āωāĻ¤ā§āϤāϰ, āϕ⧋āύ⧋ āύāĻžāϞāĻŋāĻļ āύ⧇āχāĨ¤

#include <stdio.h>

int main(void)
{
    int length = 5;
    int width = 3;

    printf("Area = %d\n", length + width);
    return 0;
}
Area = 8

āϚāĻžāϞāĻŋāϝāĻŧ⧇ āϏāĻ‚āĻ–ā§āϝāĻžāϗ⧁āϞ⧋ āĻŦāĻĻāϞāĻžāĻ“āĨ¤ āϝ⧋āĻ—āĻĢāϞ āφāϰ āϗ⧁āĻŖāĻĢāϞ āĻ•āĻžāĻ•āϤāĻžāϞ⧀āϝāĻŧāĻ­āĻžāĻŦ⧇ āĻŽāĻŋāϞ⧇ āϝāĻžāϝāĻŧ āĻāĻŽāύ āĻœā§‹āĻĄāĻŧāĻž āĻ›āĻžāĻĄāĻŧāĻž āĻĒā§āϰāϤāĻŋāϟāĻž āĻœā§‹āĻĄāĻŧāĻžāϰ āϜāĻ¨ā§āϝāχ āĻāϟāĻž āϭ⧁āϞāĨ¤

Compiler-āĻ āϚāĻžāϞāĻžāĻ“
Example 2: āϏ⧇āχ āĻāĻ•āχ program, āĻŽāĻžāύ⧇āϟāĻž āϏāĻžāϰāĻžāύ⧋

āĻāĻ•āϟāĻž character āĻŦāĻĻāϞāĻžāϝāĻŧāĨ¤ āϖ⧇āϝāĻŧāĻžāϞ āĻ•āϰ⧋, comment āĻāĻ–āύ āĻŦāϞ⧇ āĻĻāĻŋāĻšā§āϛ⧇ āϞāĻžāχāύāϟāĻž āϕ⧀ āĻ•āĻžāĻœā§‡, āϤāĻžāχ āĻĒāϰ⧇āϰ āĻĒāĻžāĻ āĻ• āĻœā§āϝāĻžāĻŽāĻŋāϤāĻŋ āύāĻž āĻœā§‡āύ⧇āĻ“ āĻŽāĻžāύ⧇āϟāĻž āϝāĻžāϚāĻžāχ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

#include <stdio.h>

int main(void)
{
    int length = 5;
    int width = 3;

    /* Area of a rectangle is length times width, in square metres. */
    printf("Area = %d\n", length * width);
    return 0;
}
Area = 15

Semantic bug āϏāĻžāϰāĻžāύ⧋ āĻšāϝāĻŧ āϭ⧇āĻŦ⧇, message āĻĒāĻĄāĻŧ⧇ āύāĻžāĨ¤ āϏ⧇āϜāĻ¨ā§āϝāχ āĻ•āĻžāĻ—āĻœā§‡ program-āϰ āĻšāĻŋāϏāĻžāĻŦ āĻŽāĻŋāϞāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ–āĻž āĻāĻ•āϟāĻž āϏāĻ¤ā§āϝāĻŋāĻ•āĻžāϰ⧇āϰ āĻĻāĻ•ā§āώāϤāĻž, beginner-āϰ āϠ⧇āĻ•āύāĻž āύāĻžāĨ¤

Compiler-āĻ āϚāĻžāϞāĻžāĻ“
Example 3: = āφāϏāϞ⧇ āϤ⧋āĻŽāĻžāϕ⧇ āϕ⧀ āĻĻ⧇āϝāĻŧ

āĻāχ program āĻāĻ•āϟāĻž assignment-āϰ āĻŽāĻžāύ āφāϰ āĻāĻ•āϟāĻž comparison-āϰ āĻŽāĻžāύ āĻĒāĻžāĻļāĻžāĻĒāĻžāĻļāĻŋ āĻ›āĻžāĻĒ⧇āĨ¤ āĻĻ⧁āχāϟāĻž āφāϞāĻžāĻĻāĻž āϜāĻŋāύāĻŋāϏ, āϏ⧇āϟāĻž āĻĻ⧇āĻ–āĻžāϰ āĻāϟāĻžāχ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻĒāϰāĻŋāĻˇā§āĻ•āĻžāϰ āωāĻĒāĻžāϝāĻŧāĨ¤

#include <stdio.h>

int main(void)
{
    int marks = 90;

    printf("marks is %d\n", marks);
    printf("marks == 90 gives %d\n", marks == 90);
    printf("marks = 60 gives %d\n", marks = 60);
    printf("marks is now %d\n", marks);
    return 0;
}
marks is 90
marks == 90 gives 1
marks = 60 gives 60
marks is now 60

Comparison āϏāĻ¤ā§āϝāĻŋāϰ āϜāĻ¨ā§āϝ 1 āφāϰ āĻŽāĻŋāĻĨā§āϝāĻžāϰ āϜāĻ¨ā§āϝ 0 āĻĻ⧇āϝāĻŧāĨ¤ Assignment āϝ⧇ āĻŽāĻžāύ āĻŦāϏāĻžāϞ āϏ⧇āϟāĻžāχ āĻĻ⧇āϝāĻŧ, āφāϰ āϝāĻžāĻ“āϝāĻŧāĻžāϰ āĻĒāĻĨ⧇ variable-āϟāĻž āĻŦāĻĻāϞ⧇ āĻĻ⧇āϝāĻŧāĨ¤ āϤāĻŋāύ āύāĻŽā§āĻŦāϰ āϞāĻžāχāύ āĻĻ⧁āχāϟāĻžāχ āĻ•āϰ⧇āϛ⧇, āφāϰ āĻĢāĻžāρāĻĻāϟāĻž āĻ āĻŋāĻ• āϏ⧇āϜāĻ¨ā§āϝāχ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤

Compiler-āĻ āϚāĻžāϞāĻžāĻ“
Example 4: āϝ⧇ semantic bug āϏāĻŦāĻžāχ āϏāĻŦāĻžāϰ āφāϗ⧇ āϞ⧇āϖ⧇

Zara āĻĻ⧁āχ āĻŦāĻŋāώāϝāĻŧ⧇āϰ āύāĻŽā§āĻŦāϰ āϝ⧋āĻ— āĻ•āϰ⧇ āĻ—āĻĄāĻŧ āĻ›āĻžāĻĒāϛ⧇āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āϞāĻžāχāύ āĻŦ⧈āϧ, āĻĒā§āϰāϤāĻŋāϟāĻž āύāĻžāĻŽ āĻ¸ā§Ž, āφāϰ āωāĻ¤ā§āϤāϰāϟāĻž āϤāĻŦ⧁āĻ“ āϭ⧁āϞāĨ¤

#include <stdio.h>

int main(void)
{
    int physics = 75;
    int chemistry = 80;
    int total = physics + chemistry;
    int average = total / 2;

    printf("Total: %d\n", total);
    printf("Average: %d\n", average);
    return 0;
}
Total: 155
Average: 77

75 āφāϰ 80-āϰ āĻ—āĻĄāĻŧ 77.5āĨ¤ C-āϤ⧇ āĻāĻ•āϟāĻž āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻžāϕ⧇ āφāϰ⧇āĻ•āϟāĻž āĻĻāĻŋāϝāĻŧ⧇ āĻ­āĻžāĻ— āĻ•āϰāϞ⧇ āĻĻāĻļāĻŽāĻŋāϕ⧇āϰ āĻĒāϰ⧇āϰ āϏāĻŦāϟāĻž āĻĢ⧇āϞ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧāĨ¤ āϕ⧋āύ⧋ warning āφāϏ⧇ āύāĻž, āĻ•āĻžāϰāĻŖ āĻŦā§āϝāĻžāĻ•āϰāϪ⧇ āĻ•āĻŋāϛ⧁āχ āϭ⧁āϞ āύ⧇āχāĨ¤ āϏāĻžāϰāĻžāύ⧋āϰ āωāĻĒāĻžāϝāĻŧāϟāĻž āĻĻ⧇āϝāĻŧ Module 4āĨ¤

Compiler-āĻ āϚāĻžāϞāĻžāĻ“

āĻāϟāĻž āϕ⧋āĻĨāĻžāϝāĻŧ āĻ•āĻžāĻœā§‡ āϞāĻžāĻ—āϛ⧇

  • Apple, 2014. Apple-āϰ TLS code-āϰ goto fail bug āĻ›āĻŋāϞ āύāĻŋāϖ⧁āρāϤ syntax-āϰ āĻāĻ•āϟāĻž āĻĻ⧁āχāĻŦāĻžāϰ āϞ⧇āĻ–āĻž āϞāĻžāχāύāĨ¤ āĻ“āϟāĻž āĻāχ āϝāĻžāϚāĻžāχāϟāĻž āĻāĻĄāĻŧāĻŋāϝāĻŧ⧇ āϝ⧇āϤ, āϝ⧇ certificate-āϟāĻž āϏāĻ¤ā§āϝāĻŋāχ āĻ“āχ site-āϰ āĻ•āĻŋ āύāĻžāĨ¤
  • Debian OpenSSL, 2008. Memory checker-āϰ āĻāĻ•āϟāĻž warning āĻĨāĻžāĻŽāĻžāϤ⧇ āĻĻ⧁āχāϟāĻž āϞāĻžāχāύ āĻŽā§āϛ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧāĨ¤ Build āĻĒāϰāĻŋāĻˇā§āĻ•āĻžāϰāχ āĻĨāĻžāϕ⧇, āφāϰ random āϏāĻ‚āĻ–ā§āϝāĻž āϤ⧈āϰāĻŋāϰ āĻ…āĻ‚āĻļāϟāĻž āĻĻ⧁āχ āĻŦāĻ›āϰ āϧāϰ⧇ āφāϗ⧇āχ āφāĻ¨ā§āĻĻāĻžāϜ āĻ•āϰāĻž āϝ⧇āϤāĨ¤
  • āĻĒā§āϰāϤāĻŋāϟāĻž CI pipeline. "Build failed" āĻĻ⧇āϖ⧇ āφāϟāϕ⧇ āϝāĻžāĻ“āϝāĻŧāĻž āĻāĻ•āϟāĻž merge āĻŽāĻžāύ⧇ āĻāχ lesson-āϟāĻž āĻ•āĻžāĻœā§‡ āϚāϞāϛ⧇: āĻŽāĻžāύ⧁āώāϕ⧇ āϖ⧁āρāϜāϤ⧇ āĻšāĻ“āϝāĻŧāĻžāϰ āφāϗ⧇āχ compiler āĻāĻ•āϟāĻž syntax error āĻĢāĻŋāϰāĻŋāϝāĻŧ⧇ āĻĻāĻŋāĻšā§āϛ⧇āĨ¤
  • Static analysis. clang-tidy āφāϰ Coverity-āϰ āĻŽāϤ⧋ tool āφāϛ⧇āχ semantics āύāĻŋāϝāĻŧ⧇ āĻ…āύ⧁āĻŽāĻžāύ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ, āφāϰ āĻŦāĻĄāĻŧ project āĻĒā§āϰāϤāĻŋāϟāĻž āĻŦāĻĻāϞ⧇āϰ āωāĻĒāϰ āϏ⧇āϗ⧁āϞ⧋ āϚāĻžāϞāĻžāϝāĻŧāĨ¤ āĻ“āϰāĻž āĻĢāĻžāρāĻ•āϟāĻžāϰ āĻ•āĻŋāϛ⧁ āĻ…āĻ‚āĻļ āϧāϰ⧇, āĻĒ⧁āϰ⧋āϟāĻž āĻ•āĻ–āύ⧋ āύāĻžāĨ¤

āϝ⧇ āϭ⧁āϞāϗ⧁āϞ⧋ āϏāĻŦāĻžāχ āĻ•āϰ⧇

ā§§. Message āϝ⧇ āϞāĻžāχāύ⧇āϰ āύāĻžāĻŽ āĻŦāϞāϛ⧇ āϏ⧇āϟāĻžāχ āϏāĻžāϰāĻžāύ⧋āĨ¤

int marks = 90
printf("%d\n", marks);

GCC āĻŦāϞ⧇ error: expected ';' before 'printf', āφāϰ āφāϙ⧁āϞ āϤ⧋āϞ⧇ 2 āύāĻŽā§āĻŦāϰ āϞāĻžāχāύ⧇āĨ¤ 2 āύāĻŽā§āĻŦāϰ āϞāĻžāχāύ āĻ āĻŋāĻ•āχ āφāϛ⧇āĨ¤ 1 āύāĻŽā§āĻŦāϰ āϞāĻžāχāύ⧇āϰ declaration-āϟāĻž āĻļ⧇āώāχ āĻšāϝāĻŧāύāĻŋ, āφāϰ compiler āĻŸā§‡āϰ āĻĒ⧇āϝāĻŧ⧇āϛ⧇ āϤāĻ–āύ, āϝāĻ–āύ āĻāĻŽāύ āĻāĻ•āϟāĻž āĻļāĻŦā§āĻĻ āĻāϏ⧇āϛ⧇ āϝ⧇āϟāĻž āĻ“āϟāĻž āφāϰ āϚāĻžāϞāĻŋāϝāĻŧ⧇ āύāĻŋāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻžāĨ¤

⧍. Compiler āϚ⧁āĻĒ āĻŽāĻžāύ⧇āχ program āĻ āĻŋāĻ•, āĻāϟāĻž āϧāϰ⧇ āύ⧇āĻ“āϝāĻŧāĻžāĨ¤

int average = total / count;   /* count might be 0 */

āϕ⧋āύ⧋ warning-āϰ āĻ¸ā§āϤāϰ⧇āχ āϕ⧋āύ⧋ message āύ⧇āχāĨ¤ āĻļā§‚āĻ¨ā§āϝ āĻĻāĻŋāϝāĻŧ⧇ āĻ­āĻžāĻ— āĻŦā§āϝāĻžāĻ•āϰāϪ⧇āϰ āϭ⧁āϞ āύāĻž, āϤāĻžāχ compiler āĻ“āϟāĻž āĻĒāĻžāĻļ āĻ•āϰāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĨ¤ count 0 āĻšāϞ⧇ program āϚāϞāĻžāϰ āϏāĻŽāϝāĻŧ āĻŽāϰ⧇ āϝāĻžāϝāĻŧ, āφāϰ āύāĻŋāĻšā§‡āϰ āĻŽāĻžāĻĨāĻž āĻ–āĻžāϟāĻžāύ⧋āϰ āĻĒā§āϰāĻļā§āύāϟāĻž āĻ“āϟāĻžāχāĨ¤

ā§Š. == āĻŦā§‹āĻāĻžāϤ⧇ āĻšā§‡āϝāĻŧ⧇ = āϞ⧇āĻ–āĻžāĨ¤

if (marks = 90) {
    printf("Top of the class\n");
}

Playground āĻ•āĻŋāϛ⧁āχ āĻŦāϞ⧇ āύāĻž, āĻ•āĻžāϰāĻŖ āĻāϰ āĻĒāϰ⧀āĻ•ā§āώāĻžāϟāĻž -Wall-āϰ āϭ⧇āϤāϰ⧇ āĻĨāĻžāϕ⧇āĨ¤ āύāĻŋāĻœā§‡āϰ āĻŽā§‡āĻļāĻŋāύ⧇ gcc -Wall āĻĻāĻŋāϞ⧇ āφāϏ⧇ warning: suggest parentheses around assignment used as truth valueāĨ¤ Program 90 āĻŦāϏāĻžāϝāĻŧ āφāϰ āϞāĻžāχāύāϟāĻž āϏāĻŦ āϏāĻŽāϝāĻŧ āĻ›āĻžāĻĒ⧇āĨ¤

ā§Ē. Comment-āϰ āϭ⧇āϤāϰ⧇ comment āĻŦāϏāĻžāύ⧋āĨ¤

/* outer /* inner */ outer */

āϤ⧁āĻŽāĻŋ āĻĒāĻžāĻ“ error: unknown type name 'outer', āϝ⧇āϟāĻž āĻĻ⧇āϖ⧇ comment-āϰ āϏāĻ™ā§āϗ⧇ āϏāĻŽā§āĻĒāĻ°ā§āĻ•āĻšā§€āύ āĻŽāύ⧇ āĻšāϝāĻŧāĨ¤ āĻĒā§āϰāĻĨāĻŽ */ comment-āϟāĻž āĻļ⧇āώ āĻ•āϰ⧇āϛ⧇, āϤāĻžāχ āϤāĻžāϰ āĻĒāϰ⧇āϰ āĻļāĻŦā§āĻĻāϗ⧁āϞ⧋ code āĻšāϝāĻŧ⧇ āϗ⧇āϛ⧇āĨ¤ āφāϗ⧇āχ comment āφāϛ⧇ āĻāĻŽāύ āĻāĻ•āϟāĻž āĻ…āĻ‚āĻļ āĻŦāĻžāĻĻ āĻĻāĻŋāϤ⧇ āϚāĻžāχāϞ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž āϞāĻžāχāύ⧇ // āĻĻāĻžāĻ“āĨ¤

āĻŽāĻžāĻĨāĻž āĻ–āĻžāϟāĻžāĻ“

Kenji āϤāĻžāĻĄāĻŧāĻžāĻšā§āĻĄāĻŧāĻžāϝāĻŧ āĻāϟāĻž āϞāĻŋāĻ–āϞāĨ¤ āϚāĻžāϞāĻžāύ⧋āϰ āφāϗ⧇ āϤāĻŋāύāϟāĻž āĻĒā§āϰāĻļā§āύ⧇āϰ āωāĻ¤ā§āϤāϰ āĻĻāĻžāĻ“: syntax āĻ āĻŋāĻ• āφāϛ⧇ āĻ•āĻŋ āύāĻž, āĻŽāĻžāύ⧇ āĻ āĻŋāĻ• āφāϛ⧇ āĻ•āĻŋ āύāĻž, āφāϰ āĻĒāĻ°ā§āĻĻāĻžāϝāĻŧ āĻšā§āĻŦāĻšā§ āϕ⧀ āφāϏ⧇āĨ¤

#include <stdio.h>

int main(void)
{
    int total = 0;
    int count = 0;

    printf("Average = %d\n", total / count);
    return 0;
}

Compiler āĻĒ⧁āϰ⧋āĻĒ⧁āϰāĻŋ āϖ⧁āĻļāĻŋ āĻĨāĻžāĻ•āĻŦ⧇; āĻāϟāĻž syntax-āϰ āĻĒā§āϰāĻļā§āύ āύāĻžāĨ¤ āĻ­āĻžāĻŦā§‹, āĻ­āĻžāϗ⧇āϰ āĻ“āχ āĻŽā§āĻšā§‚āĻ°ā§āϤ⧇ processor-āϕ⧇ āϕ⧀ āĻ•āϰāϤ⧇ āĻŦāϞāĻž āĻšāĻšā§āϛ⧇, āφāϰ āĻ“āχ āĻŽā§āĻšā§‚āĻ°ā§āϤ⧇āϰ āφāϗ⧇ āĻ•āĻŋāϛ⧁ āĻ›āĻžāĻĒāĻž āĻšāϝāĻŧ āĻ•āĻŋ āύāĻžāĨ¤

āĻ…āύ⧁āĻļā§€āϞāύ ā§§āϏāĻšāϜ

Bob-āϰ āĻĻā§āĻŦāĻŋāϗ⧁āĻŖ āĻ•āϰāĻžāϰ program-āĻ āϤāĻŋāύāϟāĻž syntax error āφāϛ⧇, āφāϰ āφāϰ āĻ•āĻŋāϛ⧁āχ āϭ⧁āϞ āύ⧇āχāĨ¤ Compile āĻšāĻ“āϝāĻŧāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻžāϰāĻžāĻ“, āϤāĻžāϰāĻĒāϰ āĻĻ⧇āĻ–ā§‹ āωāĻ¤ā§āϤāϰāϟāĻž āĻ āĻŋāĻ• āφāϏāϛ⧇ āĻ•āĻŋ āύāĻžāĨ¤

Input. āĻāĻ• āϞāĻžāχāύ⧇ āĻāĻ•āϟāĻž integer nāĨ¤

Output. āĻāĻ• āϞāĻžāχāύ: Double of n is 2n, āĻĻ⧁āχāϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž āĻŦāϏāĻžāύ⧋ āĻ…āĻŦāĻ¸ā§āĻĨāĻžāϝāĻŧāĨ¤

Constraints. 0 <= n <= 1000āĨ¤

Sample. Input 21 āĻĻāĻŋāϞ⧇ āφāϏ⧇ Double of 21 is 42āĨ¤

#include <stdio.h>

int main(void)
{
    int n
    scanf("%d", &n);
    Printf("Double of %d is %d\n", n, n * 2);
    return 0;

āύāĻŋāϝāĻŧāĻŽāĨ¤ Compiler āϝ⧇āϗ⧁āϞ⧋ āύāĻŋāϝāĻŧ⧇ āύāĻžāϞāĻŋāĻļ āĻ•āϰ⧇, āĻļ⧁āϧ⧁ āϏ⧇āϗ⧁āϞ⧋āχ āϏāĻžāϰāĻžāĻ“āĨ¤ āĻĒā§āϰāĻĨāĻŽ message āĻĒāĻĄāĻŧā§‹, āĻāĻ•āϟāĻž āϜāĻŋāύāĻŋāϏ āϏāĻžāϰāĻžāĻ“, āφāĻŦāĻžāϰ build āĻ•āϰ⧋, āφāϰ āĻ—ā§‹āύ⧋ āϤ⧋āĻŽāĻžāϰ āĻ•āϝāĻŧāϟāĻž build āϞāĻžāĻ—āϞāĨ¤

Hidden test āϏāĻš grading āĻšāϝāĻŧ āĻāχ module-āϰ Problems lesson-āĻ, fix-the-syntax āύāĻžāĻŽā§‡āĨ¤

āĻ…āύ⧁āĻļā§€āϞāύ ⧍āĻŽāĻžāĻāĻžāϰāĻŋ

āĻāϟāĻž āĻĒā§āϰāĻĨāĻŽ āĻšā§‡āĻˇā§āϟāĻžāϤ⧇āχ compile āĻšāϝāĻŧ, āφāϰ āϤāĻŦ⧁āĻ“ āϭ⧁āϞāĨ¤ Maria āϚāĻžāϝāĻŧ āĻāĻ•āϟāĻž āĻŦāĻ°ā§āĻ—āĻžāĻ•āĻžāϰ tile-āϰ āĻ•ā§āώ⧇āĻ¤ā§āϰāĻĢāϞ, āφāϰ program āĻ›āĻžāĻĒāϛ⧇ āĻ“āϟāĻžāϰ āϚāĻžāϰāĻĒāĻžāĻļ⧇āϰ āĻĻā§‚āϰāĻ¤ā§āĻŦāĨ¤

Input. āĻāĻ• āϞāĻžāχāύ⧇ āĻāĻ•āϟāĻž integer s, āĻŦāĻ°ā§āϗ⧇āϰ āĻŦāĻžāĻšā§ āϏ⧇āĻ¨ā§āϟāĻŋāĻŽāĻŋāϟāĻžāϰ⧇āĨ¤

Output. āĻāĻ• āϞāĻžāχāύ: Area is X, āϝ⧇āĻ–āĻžāύ⧇ X āĻšāϞ⧋ āĻ•ā§āώ⧇āĻ¤ā§āϰāĻĢāϞ āĻŦāĻ°ā§āĻ— āϏ⧇āĻ¨ā§āϟāĻŋāĻŽāĻŋāϟāĻžāϰ⧇āĨ¤

Constraints. 1 <= s <= 100āĨ¤

Sample. Input 4 āĻĻāĻŋāϞ⧇ āφāϏ⧇ Area is 16āĨ¤ Starter-āϟāĻžāĻ“ 16 āĻ›āĻžāĻĒ⧇, āφāϰ āĻ“āϟāĻžāχ āĻĢāĻžāρāĻĻ: 4-āχ āĻāĻ•āĻŽāĻžāĻ¤ā§āϰ āĻŦāĻžāĻšā§ āϝ⧇āĻ–āĻžāύ⧇ āĻĒāϰāĻŋāϏ⧀āĻŽāĻž āφāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰāĻĢāϞ āĻŽāĻŋāϞ⧇ āϝāĻžāϝāĻŧāĨ¤

#include <stdio.h>

int main(void)
{
    int s;
    scanf("%d", &s);

    printf("Area is %d\n", 4 * s);
    return 0;
}

āύāĻŋāĻœā§‡ āϝāĻžāϚāĻžāχ āĻ•āϰ⧋āĨ¤ āϏāĻžāϰāĻžāύ⧋āϰ āφāϗ⧇ āφāϰ āĻĒāϰ⧇ s āϏāĻŽāĻžāύ 5 āĻĻāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ–ā§‹āĨ¤ āϭ⧁āϞ āĻ•āĻžāϰāϪ⧇ āĻĒāĻžāϏ āĻ•āϰ⧇ āϝāĻžāĻ“āϝāĻŧāĻž āĻāĻ•āϟāĻž test case-āχ semantic bug-āϕ⧇ āĻŦāĻžāρāϚāĻŋāϝāĻŧ⧇ āϰāĻžāϖ⧇āĨ¤

Grading āĻšāϝāĻŧ square-area āύāĻžāĻŽā§‡āĨ¤

Compiler-āĻ āϚāĻžāϞāĻžāĻ“
āĻ…āύ⧁āĻļā§€āϞāύ ā§ŠāĻŽāĻžāĻāĻžāϰāĻŋ

āĻāĻ–āĻžāύ⧇ āĻāĻ•āϟāĻž character āϭ⧁āϞ, āφāϰ āϏ⧇āϟāĻž āĻāχ lesson-āϰāχāĨ¤ Program-āϟāĻžāϰ āωāĻ¤ā§āϤāϰ āĻĻ⧇āĻ“āϝāĻŧāĻžāϰ āĻ•āĻĨāĻž āĻāχ āĻĒā§āϰāĻļā§āύ⧇āϰ: "āĻāχ āĻĻ⧁āχāϟāĻž āύāĻŽā§āĻŦāϰ āϏāĻŽāĻžāύ āĻ•āĻŋ āύāĻž", āĻšā§āϝāĻžāρ āĻšāϞ⧇ 1 āφāϰ āύāĻž āĻšāϞ⧇ 0 āϛ⧇āĻĒ⧇āĨ¤

Input. āĻāĻ• āϞāĻžāχāύ⧇ āĻĻ⧁āχāϟāĻž integer a bāĨ¤

Output. āĻāĻ• āϞāĻžāχāύ: āϏāĻŽāĻžāύ āĻšāϞ⧇ 1, āύāχāϞ⧇ 0āĨ¤

Constraints. 0 <= a, b <= 100āĨ¤

Sample. Input 90 90 āĻĻāĻŋāϞ⧇ āφāϏ⧇ 1āĨ¤ Input 90 60 āĻĻāĻŋāϞ⧇ starter āĻĻ⧇āϝāĻŧ 60, āϝ⧇āϟāĻž āĻ…āύ⧁āĻŽā§‹āĻĻāĻŋāϤ āĻĻ⧁āχāϟāĻž āωāĻ¤ā§āϤāϰ⧇āϰ āĻāĻ•āϟāĻžāĻ“ āύāĻžāĨ¤

#include <stdio.h>

int main(void)
{
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d\n", a = b);
    return 0;
}

āύāĻŋāĻœā§‡ āϝāĻžāϚāĻžāχ āĻ•āϰ⧋āĨ¤ āϏāĻžāϰāĻžāύ⧋āϰ āĻĒāϰ input 0 0 āĻĻāĻŋāϞ⧇ āĻ…āĻŦāĻļā§āϝāχ 1 āφāϏāϤ⧇ āĻšāĻŦ⧇āĨ¤ āϏāĻžāϰāĻžāύ⧋āϰ āφāϗ⧇ āĻ“āϟāĻž 0 āĻ›āĻžāĻĒ⧇, āϝ⧇āϟāĻž āĻĻ⧇āĻ–āϤ⧇ āĻ āĻŋāĻ• āϞāĻžāϗ⧇ āφāϰ āφāϏāϞ⧇ āĻ•āĻžāĻ•āϤāĻžāϞ⧀āϝāĻŧāĨ¤

Compiler-āĻ āϚāĻžāϞāĻžāĻ“

āϝ⧇ āĻĒā§āϰāĻļā§āύāϗ⧁āϞ⧋ āϏāĻŦāĻžāϰ āĻŽāύ⧇ āφāϏ⧇

  • Compile āĻšāϞ⧇ āφāĻŽāĻžāϰ program āĻ āĻŋāĻ• āφāϛ⧇?

    āύāĻžāĨ¤ āĻŽāĻžāύ⧇ āĻŦā§āϝāĻžāĻ•āϰāĻŖāϟāĻž āĻŦ⧈āϧāĨ¤ āĻāχ lesson-āϰ Example 1 āĻĒāϰāĻŋāĻˇā§āĻ•āĻžāϰāĻ­āĻžāĻŦ⧇ compile āĻšāϝāĻŧ āφāϰ āĻĒā§āϰāϤāĻŋāĻŦāĻžāϰ āϭ⧁āϞ āωāĻ¤ā§āϤāϰ āĻĻ⧇āϝāĻŧāĨ¤ āĻŽāĻžāύ⧇ āύāĻŋāϝāĻŧ⧇ āϤ⧋āĻŽāĻžāϕ⧇ āĻļ⧁āϧ⧁ āϤ⧋āĻŽāĻžāϰ āύāĻŋāĻœā§‡āϰ test input-āχ āĻŦāϞāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

  • Compiler āĻ•āĻ–āύ⧋ semantic error āϧāϰāϤ⧇ āĻĒāĻžāϰ⧇?

    āĻŽāĻžāĻā§‡āĻŽāĻ§ā§āϝ⧇, type-āϰ āϏ⧁āĻŦāĻžāĻĻ⧇: -Wall āϧāϰ⧇ āĻĢ⧇āϞ⧇ %d-āϕ⧇ āĻāĻ•āϟāĻž string āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧ⧇āϛ⧇, āφāϰ sanitizer āϚāϞāĻžāϰ āϏāĻŽāϝāĻŧ āĻ–āĻžāϰāĻžāĻĒ memory āϛ⧋āρāϝāĻŧāĻž āϧāϰ⧇āĨ¤ āĻāĻĻ⧇āϰ āϕ⧇āωāχ āϜāĻžāύ⧇ āύāĻž āϤ⧋āĻŽāĻžāϰ program āϕ⧀ āĻ•āĻžāĻœā§‡āϰ āϜāĻ¨ā§āϝāĨ¤

  • āĻāĻ•āϟāĻž āϭ⧁āϞ āĻĨ⧇āϕ⧇ āĻŦāĻŋāĻļāϟāĻž error āφāϏ⧇ āϕ⧇āύ?

    āĻ•āĻžāϰāĻŖ āĻĒā§āϰāĻĨāĻŽ āĻ—ā§‹āϞāĻŽāĻžāϞ⧇āϰ āĻĒāϰ compiler āϤ⧋āĻŽāĻžāϰ program āϭ⧁āϞāĻ­āĻžāĻŦ⧇ āĻĒāĻĄāĻŧāϛ⧇ āφāϰ āϝāĻž āĻĒāĻžāĻšā§āϛ⧇ āĻŦāϞ⧇ āϝāĻžāĻšā§āϛ⧇āĨ¤ āĻĒā§āϰāĻĨāĻŽāϟāĻž āϏāĻžāϰāĻŋāϝāĻŧ⧇ āφāĻŦāĻžāϰ build āĻ•āϰ⧋āĨ¤ āĻŦāĻžāĻ•āĻŋāϗ⧁āϞ⧋āϰ āĻŦ⧇āĻļāĻŋāϰāĻ­āĻžāĻ— āϏāĻžāϧāĻžāϰāĻŖāϤ āωāϧāĻžāĻ“ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤

  • Warning āĻ•āĻŋ āϛ⧇āĻĄāĻŧ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻžāϰ āĻŽāϤ⧋ āϜāĻŋāύāĻŋāϏ?

    āĻ“āϟāĻžāϕ⧇ āĻāĻŽāύ āĻāĻ•āϟāĻž error āĻ­āĻžāĻŦā§‹ āϝ⧇āϟāĻž āĻāĻ–āύ⧋ āϤ⧋āĻŽāĻžāϕ⧇ āĻ•āĻžāĻŽāĻĄāĻŧāĻžāϝāĻŧāύāĻŋāĨ¤ āωāĻĒāϰ⧇āϰ table-āϰ āĻĒā§āϰāϤāĻŋāϟāĻž warning āϏāĻ¤ā§āϝāĻŋāĻ•āĻžāϰ⧇āϰ āĻ­āĻžāĻ™āĻž code āĻŦāĻ°ā§āĻŖāύāĻž āĻ•āϰ⧇, āφāϰ āĻĒ⧇āĻļāĻžāĻĻāĻžāϰ project warning-āϕ⧇ error āĻŦāĻžāύāĻŋāϝāĻŧ⧇ build āĻ•āϰ⧇āĨ¤

  • āĻāχ message-āϗ⧁āϞ⧋ āĻŽā§āĻ–āĻ¸ā§āĻĨ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇?

    āύāĻžāĨ¤ Code āϞ⧇āĻ–āĻž āĻļ⧁āϰ⧁āϰ āĻāĻ• āϏāĻĒā§āϤāĻžāĻšā§‡āϰ āĻŽāĻ§ā§āϝ⧇āχ āĻĒā§āϰāĻĨāĻŽ āĻĒāĻžāρāϚāϟāĻž āϤ⧁āĻŽāĻŋ āϚāĻŋāύ⧇ āĻĢ⧇āϞāĻŦ⧇āĨ¤ āĻ•āĻžāϜ āĻ•āϰāĻžāϰ āϏāĻŽāϝāĻŧ āĻāχ table āĻ–ā§‹āϞāĻž āϰāĻžāĻ–ā§‹, āφāϰ āĻ–ā§‹āρāϜāĻžāϰ āϏāĻŽāϝāĻŧ āĻšā§āĻŦāĻšā§ āĻļāĻŦā§āĻĻāϗ⧁āϞ⧋ āϟ⧁āϕ⧇ āĻĻāĻžāĻ“āĨ¤

āĻŽā§‚āϞ āĻ•āĻĨāĻž

  • Syntax āĻšāϞ⧋ āĻŦā§āϝāĻžāĻ•āϰāĻŖ, compiler āϝ⧇āϟāĻž āĻĻ⧇āϖ⧇; semantics āĻšāϞ⧋ āĻ…āĻ°ā§āĻĨ, āϝ⧇āϟāĻž āϕ⧇āĻŦāϞ āϤ⧁āĻŽāĻŋ āĻĻ⧇āĻ–āϤ⧇ āĻĒāĻžāϰ⧋āĨ¤
  • Syntax error āϏāĻ¸ā§āϤāĻž: āĻāĻ• āϏ⧇āϕ⧇āĻ¨ā§āĻĄ, āĻāĻ•āϟāĻž message, āĻāĻ•āϟāĻž āϏāĻžāϰāĻžāχāĨ¤
  • āĻĒāϰāĻŋāĻˇā§āĻ•āĻžāϰ build āωāĻ¤ā§āϤāϰ āĻ āĻŋāĻ• āĻ•āĻŋ āύāĻž, āϏ⧇ āύāĻŋāϝāĻŧ⧇ āĻ•āĻŋāϛ⧁āχ āĻŦāϞ⧇ āύāĻžāĨ¤
  • = āĻŽāĻžāύ āĻŦāϏāĻžāϝāĻŧ āφāϰ āϤāĻžāϰ āύāĻŋāĻœā§‡āϰ āĻāĻ•āϟāĻž āĻŽāĻžāύ āφāϛ⧇; == āĻŽā§‡āϞāĻžāϝāĻŧ āφāϰ 1 āĻŦāĻž 0 āĻĻ⧇āϝāĻŧāĨ¤
  • āĻĒā§āϰāĻĨāĻŽ message āĻĒāĻĄāĻŧā§‹, āϤāĻžāϰ āĻāĻ• āϞāĻžāχāύ āωāĻĒāϰ⧇ āϤāĻžāĻ•āĻžāĻ“, āφāϰ āĻšā§āĻŦāĻšā§ āĻļāĻŦā§āĻĻāϗ⧁āϞ⧋ āϟ⧁āϕ⧇ āύāĻžāĻ“āĨ¤
  • āĻŦāĻŋāĻ–ā§āϝāĻžāϤ bug-āϗ⧁āϞ⧋ (goto fail, Debian OpenSSL) āϏāĻŦāχ āĻĒ⧁āϰ⧋āĻĒ⧁āϰāĻŋ āĻŦ⧈āϧ C āĻ›āĻŋāϞāĨ¤

āĻĒāϰ⧇āϰ lesson-āĻ C-āϰ āĻĒā§āϰāϤāĻŋāϟāĻž āϚāĻŋāĻšā§āύ⧇āϰ āύāĻžāĻŽ āĻļāĻŋāĻ–āĻŦ⧇, āϝāĻžāϤ⧇ āĻāχ table-āϰ message-āϗ⧁āϞ⧋ āĻāĻŽāύ āĻŦāĻžāĻ•ā§āϝ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ āϝ⧇āϗ⧁āϞ⧋ āϤ⧁āĻŽāĻŋ āĻŽā§āϖ⧇ āĻĒāĻĄāĻŧāϤ⧇ āĻĒāĻžāϰ⧋āĨ¤

lesson ⧍ āĻļ⧇āώ

āĻļ⧇āώ āĻšāϞ⧇ āϚāĻŋāĻšā§āύ āĻĻāĻŋāύ, āĻ…āĻ—ā§āϰāĻ—āϤāĻŋ āφāĻĒāύāĻžāϰ āϏāĻžāĻĨ⧇ āĻĨāĻžāĻ•āĻŦ⧇āĨ¤

āĻĒāϰ⧇āϰāϟāĻž: āϚāĻŋāĻšā§āύ⧇āϰ āĻ…āĻ­āĻŋāϧāĻžāύ: C-āϰ āĻĒā§āϰāϤāĻŋāϟāĻž āϏāĻžāχāύ āϕ⧀ āĻŦāϞ⧇