PricingLoginStart free
C Academy · Pelajaran

Menokenkan Input

Tukar teks kepada token.

Pelajaran 1 daripada 413 langkah

Menokenkan Input ialah pelajaran C Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran C Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus C Academy merangkumi sejumlah 4 pelajaran.

Apakah itu Tokenizer?

Penterjemah bermula dengan menukarkan teks mentah kepada token — unit bermakna yang paling kecil. Untuk rentetan 3 + 4 * 2, tokenizer (atau penganalisis leksikal) menghasilkan nombor dan operator.

Peringkat ini membuang ruang kosong dan mengelaskan setiap kumpulan aksara supaya penghurai tidak perlu mengendalikan bait mentah.

Jenis Token

Kami memodelkan setiap token dengan tanda enum dan muatan. Nombor membawa nilai integer; operator dan kurungan hanya memerlukan jenisnya.

Menyimpan nilai di dalam struct mengelakkan sumber diimbas semula kemudian.

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;

Kedudukan Pengimbasan

Penganalisis leksikal menelusuri sumber dengan penuding kursor. Pembantu kecil melihat aksara semasa tanpa menggunakannya, lalu mengembalikan '\0' pada penghujung.

Aritmetik penuding memastikan pengimbas pantas dan ringkas.

static const char *src;

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

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

Melangkau Ruang Kosong

Sebelum membaca token, kami membuang ruang dan tab. isspace standard daripada <ctype.h> mengendalikan setiap aksara kosong.

Aksara baris baharu dikira sebagai ruang kosong di sini, jadi ungkapan boleh merentasi beberapa baris.

#include <ctype.h>

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

Menghuraikan Nombor secara Leksikal

Apabila kursor berada pada digit, kami mengumpulkan digit berturutan menjadi integer. Mendarab dengan sepuluh dan menambah setiap digit membina nilai dari kiri ke kanan.

Gelung berhenti pada aksara bukan digit pertama, meninggalkan kursor bersedia untuk token seterusnya.

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

Fungsi next_token

Rutin teras melangkau ruang kosong, kemudian memilih tindakan berdasarkan aksara semasa. Digit menjadi TOK_NUM; setiap operator dipetakan kepada jenisnya sendiri.

Apabila mencapai NUL penamat, rutin menghasilkan TOK_EOF, iaitu isyarat 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 Penganalisis Leksikal

Berikut ialah program penuh yang menukarkan ungkapan kepada token dan mencetak setiap jenis token. Nombor turut mencetak nilainya.

Perhatikan bahawa gelung berakhir apabila 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 Pandangan Hadapan

Penghurai biasanya perlu memeriksa token yang akan datang sebelum menggunakannya. Kami menyimpan satu token dalam current global dan mengisinya semula selepas setiap padanan.

Pandangan hadapan satu token ini mencukupi untuk tatabahasa LL(1) kami.

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 Ralat Leksikal

Aksara yang tidak dikenali — misalnya $ atau @ — tidak sepatutnya hilang secara senyap. Penganalisis leksikal yang teguh melaporkan bait yang bermasalah dan membatalkan operasi.

Kegagalan pantas pada penganalisis leksikal menghalang peringkat seterusnya daripada melihat token yang rosak.

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

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

Operator Berbilang Aksara

Bahasa sebenar mempunyai token seperti == atau <=. Untuk menghuraikannya secara leksikal, kami melihat satu aksara tambahan selepas aksara pertama.

Jika bait seterusnya melengkapkan operator, kami menggunakan kedua-duanya; jika tidak, kami menghasilkan bentuk satu aksara.

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

Sebab Token Penting

Dengan meringkaskan aksara menjadi token, penghurai berfungsi dengan aliran yang bersih dan mempunyai jenis. Keutamaan operator, pengelompokan dan ralat semuanya menjadi lebih mudah untuk difahami.

Seterusnya kami memasukkan token ini ke dalam penghurai turun rekursif.

Semakan Pantas

Fikirkan token yang dihasilkan oleh penganalisis leksikal untuk simbol pengelompokan.

Jawab dalam pelajaran interaktif

Imbas Kembali

Anda telah membina penganalisis leksikal: jenis token, kursor pengimbasan, pelangkauan ruang kosong, penghuraian nombor secara leksikal dan penghantar next_token dengan pandangan hadapan satu token.

Token ini menjadi input kepada penghuraian, yang membina pepohon sintaks daripada token tersebut.

Percuma untuk bermula

Pelajari C dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
39
Pelajaran
144
Mula belajar secara percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Menokenkan Input” percuma?

Ya — teks penuh “Menokenkan Input” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus C Academy, tingkat taraf kepada CoddyKit PRO. Kursus C Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Menokenkan Input”?

Tukar teks kepada token. Anda berlatih C Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan C Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran C Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Menokenkan Input” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran C Academy ini?

Ya. Setiap pelajaran C Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Menokenkan Input
  2. Menghuraikan Ekspresi
  3. Menilai Pepohon
  4. Menambah Pemboleh Ubah
← Kembali ke C Academy