0Pricing
C Academy · Pelajaran

Tokenisasi Masukan

Ubah teks menjadi token.

Tokenisasi Masukan adalah pelajaran C Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar C Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C Academy mencakup 4 pelajaran total.

Apa Itu Tokenizer?

Interpreter dimulai dengan mengubah teks mentah menjadi token—unit terkecil yang memiliki makna. Untuk string 3 + 4 * 2, tokenizer (atau lexer) menghasilkan angka dan operator.

Tahap ini menghapus spasi dan mengklasifikasikan setiap kelompok karakter, sehingga parser tidak pernah menangani byte mentah.

Tipe Token

Kita memodelkan setiap token dengan tag enum dan payload. Angka membawa nilai bilangan bulat; operator dan tanda kurung hanya memerlukan jenisnya.

Menyimpan nilai di dalam struct menghindari pemindaian ulang sumber nantinya.

typedef enum {
  TOK_NUM, TOK_PLUS, TOK_MINUS,
  TOK_STAR, TOK_SLASH,
  TOK_LPAREN, TOK_RPAREN, TOK_EOF
} TokKind;

typedef struct {
  TokKind kind;
  int value; /* used when kind == TOK_NUM */
} Token;

Posisi Pemindaian

Lexer menelusuri sumber menggunakan pointer kursor. Sebuah pembantu kecil mengintip karakter saat ini tanpa mengonsumsinya, dan mengembalikan '\0' di akhir.

Aritmetika pointer membuat pemindai tetap cepat dan sederhana.

static const char *src;

static char peek(void) {
  return *src;
}

static char advance(void) {
  return *src++;
}

Melewati Spasi Kosong

Sebelum membaca token, kita membuang spasi dan tab. isspace standar dari <ctype.h> menangani setiap karakter kosong.

Baris baru dihitung sebagai spasi kosong di sini, sehingga ekspresi dapat membentang di beberapa baris.

#include <ctype.h>

static void skip_ws(void) {
  while (isspace((unsigned char)peek()))
    advance();
}

Melakukan Lexing pada Angka

Saat kursor berada pada digit, kita mengakumulasikan digit-digit berurutan menjadi bilangan bulat. Mengalikan dengan sepuluh dan menambahkan setiap digit membangun nilai dari kiri ke kanan.

Perulangan berhenti pada karakter pertama yang bukan digit, sehingga kursor siap untuk token berikutnya.

static int lex_number(void) {
  int n = 0;
  while (isdigit((unsigned char)peek())) {
    n = n * 10 + (advance() - '0');
  }
  return n;
}

Fungsi next_token

Rutin inti melewati spasi kosong, lalu melakukan dispatch berdasarkan karakter saat ini. Digit menjadi TOK_NUM; setiap operator dipetakan ke jenisnya sendiri.

Saat mencapai NUL penghenti, fungsi menghasilkan TOK_EOF, yaitu sinyal untuk berhenti.

static Token next_token(void) {
  skip_ws();
  char c = peek();
  if (c == '\0') return (Token){TOK_EOF, 0};
  if (isdigit((unsigned char)c))
    return (Token){TOK_NUM, lex_number()};
  advance();
  switch (c) {
    case '+': return (Token){TOK_PLUS, 0};
    case '-': return (Token){TOK_MINUS, 0};
    case '*': return (Token){TOK_STAR, 0};
    case '/': return (Token){TOK_SLASH, 0};
    case '(': return (Token){TOK_LPAREN, 0};
    case ')': return (Token){TOK_RPAREN, 0};
  }
  return (Token){TOK_EOF, 0};
}

Menjalankan Lexer

Berikut program lengkap yang melakukan tokenisasi pada sebuah ekspresi dan mencetak jenis setiap token. Angka juga mencetak nilainya.

Perhatikan bahwa perulangan berakhir saat membaca TOK_EOF.

#include <stdio.h>
#include <ctype.h>

typedef enum { TOK_NUM, TOK_PLUS, TOK_STAR, TOK_EOF } TokKind;
typedef struct { TokKind kind; int value; } Token;

static const char *src;
static char peek(void){ return *src; }
static char advance(void){ return *src++; }

static Token next_token(void){
  while (isspace((unsigned char)peek())) advance();
  char c = peek();
  if (c=='\0') return (Token){TOK_EOF,0};
  if (isdigit((unsigned char)c)){
    int n=0; while(isdigit((unsigned char)peek())) n=n*10+(advance()-'0');
    return (Token){TOK_NUM,n};
  }
  advance();
  if (c=='+') return (Token){TOK_PLUS,0};
  return (Token){TOK_STAR,0};
}

int main(void){
  src = "12 + 3 * 4";
  Token t;
  do {
    t = next_token();
    if (t.kind==TOK_NUM) printf("NUM %d\n", t.value);
    else if (t.kind==TOK_PLUS) printf("PLUS\n");
    else if (t.kind==TOK_STAR) printf("STAR\n");
    else printf("EOF\n");
  } while (t.kind != TOK_EOF);
  return 0;
}

Satu Token untuk Lookahead

Parser biasanya perlu memeriksa token berikutnya sebelum mengonsumsinya. Kita menyimpan satu token dalam current global dan mengisinya kembali setelah setiap pencocokan.

Lookahead satu token ini cukup untuk tata bahasa LL(1) kita.

static Token current;

static void init_lexer(const char *s) {
  src = s;
  current = next_token();
}

static Token cur(void) { return current; }

static void bump(void) { current = next_token(); }

Melaporkan Kesalahan Leksikal

Karakter yang tidak dikenal—misalnya $ atau @—tidak boleh menghilang begitu saja. Lexer yang tangguh melaporkan byte yang bermasalah lalu menghentikan program.

Gagal dengan cepat di lexer mencegah tahap-tahap berikutnya melihat token sampah.

#include <stdio.h>
#include <stdlib.h>

static void lex_error(char c) {
  fprintf(stderr, "lex error: unexpected '%c'\n", c);
  exit(1);
}

Operator Multi-Karakter

Bahasa nyata memiliki token seperti == atau <=. Untuk melakukan lexing terhadapnya, kita mengintip satu karakter tambahan setelah karakter pertama.

Jika byte berikutnya melengkapi operator, kita mengonsumsi keduanya; jika tidak, kita menghasilkan bentuk satu karakter.

/* fragment: distinguish '=' from '==' */
if (peek() == '=') {
  advance();
  if (peek() == '=') { advance(); /* TOK_EQ */ }
  else { /* TOK_ASSIGN */ }
}

Mengapa Token Penting

Dengan mengubah karakter menjadi token, parser bekerja dengan aliran yang bersih dan memiliki tipe. Prioritas operator, pengelompokan, dan kesalahan semuanya menjadi lebih mudah dipahami.

Selanjutnya kita memasukkan token-token ini ke parser recursive-descent.

Pemeriksaan Singkat

Pikirkan apa yang dihasilkan lexer untuk simbol pengelompokan.

Ringkasan

Anda telah membangun lexer: tipe token, kursor pemindaian, pelewatan spasi kosong, lexing angka, dan dispatcher next_token dengan lookahead satu token.

Token-token ini menjadi input untuk parsing, yang membangun pohon sintaksis dari token-token tersebut.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Tokenisasi Masukan” gratis?

Ya — teks lengkap “Tokenisasi Masukan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus C Academy, upgrade ke CoddyKit PRO. Kursus C Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Tokenisasi Masukan”?

Ubah teks menjadi token. Kamu berlatih C Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai C Academy?

Tidak diperlukan pengalaman sebelumnya. C Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Tokenisasi Masukan” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran C Academy ini?

Ya. Setiap pelajaran C Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Tokenisasi Masukan
  2. Mengurai Ekspresi
  3. Mengevaluasi Pohon
  4. Menambahkan Variabel
← Kembali ke C Academy