Bir lexer'ın çözümleyicisine döndürdüğü belirteçlerin veri türü ne olmalıdır?

Başlıkta belirtildiği gibi, bir lexer çözümleyiciye hangi veri türünü iade etmeli / vermelidir? Vikipedi'nin sahip olduğu sözcüksel analiz makalesini okurken , şunu belirtmiştir:

Bilgisayar bilimlerinde sözcüksel analiz, bir dizi karakterin (bir bilgisayar programında veya web sayfasında olduğu gibi) bir dizi dizinin ( tanımlanmış "anlamı" olan dizeler ) dönüştürülmesi işlemidir .

Ancak, yukarıdaki ifadeye tamamen aykırı bir biçimde, Farklı bir sitede sorduğum başka bir soru ( merak ediyorsanız Kod İnceleme ) yanıtlandığında, Cevap veren kişi şunları söyledi:

Sözlük genellikle dizgiyi okur ve bunu bir sözlük akışına dönüştürür. Sözlüklerin yalnızca bir sayı akışı olması gerekir .

ve o bu görsel verdi:

nl_output => 256
output    => 257
<string>  => 258

Daha sonra makalede Flexdaha önce var olan bir sözcüden bahsetti ve onunla 'kurallar' yazmanın elle bir söz sahibi yazmaktan daha kolay olacağını söyledi. Bana bu örneği vermeye devam etti:

Space              [ \r\n\t]
QuotedString       "[^"]*"
%%
nl_output          {return 256;}
output             {return 257;}
{QuotedString}     {return 258;}
{Space}            {/* Ignore */}
.                  {error("Unmatched character");}
%%

İçgörümü daha fazla bilgi edinmek ve daha fazla bilgi edinmek için Flex ile ilgili Wikipedia makalesini okudum . Flex makalesi, tokenlerle birlikte bir dizi sözdizimi kuralını şu şekilde tanımlayabileceğinizi gösterdi:

digit         [0-9]
letter        [a-zA-Z]

%%
"+"                  { return PLUS;       }
"-"                  { return MINUS;      }
"*"                  { return TIMES;      }
"/"                  { return SLASH;      }
"("                  { return LPAREN;     }
")"                  { return RPAREN;     }
";"                  { return SEMICOLON;  }
","                  { return COMMA;      }
"."                  { return PERIOD;     }
":="                 { return BECOMES;    }
"="                  { return EQL;        }
"<>"                 { return NEQ;        }
"<"                  { return LSS;        }
">"                  { return GTR;        }
"<="                 { return LEQ;        }
">="                 { return GEQ;        }
"begin"              { return BEGINSYM;   }
"call"               { return CALLSYM;    }
"const"              { return CONSTSYM;   }
"do"                 { return DOSYM;      }
"end"                { return ENDSYM;     }
"if"                 { return IFSYM;      }
"odd"                { return ODDSYM;     }
"procedure"          { return PROCSYM;    }
"then"               { return THENSYM;    }
"var"                { return VARSYM;     }
"while"              { return WHILESYM;   }

Bana öyle geliyor ki, Flex lexer \ string tokens dizelerini döndürüyor. Ancak belirli sayılara eşit olan sabitler döndürüyor olabilir.

Lexer rakamları döndürecekti, string değişmezlerini nasıl okuyacaktı? sayı döndürmek, tek anahtar kelimeler için iyidir, ancak bir dize ile nasıl ilgilenirsiniz? Lexer, dizgiyi ikili sayılara dönüştürmek zorunda kalmazdı ve daha sonra çözümleyici, sayıları tekrar dizgeye dönüştürürdü. Lexer'in dizeleri döndürmesi ve ardından çözümleyicinin herhangi bir sayı dizgisinin değişmezlerini gerçek sayılara dönüştürmesine izin vermek çok daha mantıklı (ve daha kolay) görünüyor.

Yoksa lexer her ikisini de geri alabilir mi? İşlevleriniz için yalnızca bir dönüş türüne sahip olmanızı sağlayan c ++ dilinde basit bir sözlük yazmaya çalışıyorum . Böylece sorumu sormam için beni yönlendir.

Sorumu bir paragrafa sıkıştırmak için: Bir sözlük yazarken ve bunun yalnızca bir veri türü (karakter dizileri veya sayılar) getirebileceğini varsayarsak , hangisi daha mantıklı bir seçim olabilir?

Genel olarak, konuşma ve ayrıştırma sırasında bir dili işliyorsanız, sözcük belirteçlerinizin bir tanımını yaparsınız, örneğin:

NUMBER ::= [0-9]+
ID     ::= [a-Z]+, except for keywords
IF     ::= 'if'
LPAREN ::= '('
RPAREN ::= ')'
COMMA  ::= ','
LBRACE ::= '{'
RBRACE ::= '}'
SEMICOLON ::= ';'
...

ve çözümleyici için bir grameriniz var:

STATEMENT ::= IF LPAREN EXPR RPAREN STATEMENT
            | LBRACE STATEMENT BRACE
            | EXPR SEMICOLON
EXPR      ::= ID
            | NUMBER
            | ID LPAREN EXPRS RPAREN
...

Lexer, girdi akışını alır ve bir simge akışı üretir. Belirteç akışı, ayrıştırıcı bir ağaç üretmek için ayrıştırıcı tarafından tüketilir. Bazı durumlarda, belirtecin türünü bilmek yeterlidir (örneğin, LPAREN, RBRACE, FOR), ancak bazı durumlarda belirteçle ilişkilendirilmiş olan gerçek değere ihtiyacınız olacaktır . Örneğin, bir kimlik belirteci ile karşılaştığınızda, hangi kimliğe başvurmaya çalıştığınızı bulmaya çalışırken kimliği oluşturan gerçek karakterleri isteyeceksiniz.

Yani, tipik olarak aşağı yukarı böyle bir şeye sahipsiniz:

enum TokenType {
  NUMBER, ID, IF, LPAREN, RPAREN, ...;
}

class Token {
  TokenType type;
  String value;
}

Böylece, bir belirteç döndüğünde, ne tür olduğunu (ayrıştırma için gerekli olan) ve oluşturduğu karakter dizisini (daha sonra dize ve sayısal hazırlayıcıları, tanımlayıcıları yorumlamak için gerekeceklerini) bilirsiniz. vb.). Çok basit bir toplama türü döndürdüğünüz için iki değer döndürdüğünüzü hissedebilirsiniz, ancak gerçekten iki bölüme de ihtiyacınız var. Sonuçta, aşağıdaki programlara farklı davranmak istersiniz:

if (2 > 0) {
  print("2 > 0");
}

if (0 > 2) {
  print("0 > 2");
}

Bunlar aynı tür token türlerini üretmektedir : IF, LPAREN, NUMBER, GREATER_THAN, NUMBER, RPAREN, LBRACE, ID, LPAREN, STRING, RPAREN, SEMICOLON, RBRACE. Bu da aynı şekilde ayrıştırmaları anlamına geliyor . Ancak, ayrıştırma ağacında bir şey yaptığınızda, ilk sayının değerinin '2' (veya '0') olmasını ve ikinci sayının değerinin '0' (veya '2) olmasını önemsersiniz. ') ve dizginin değerinin' 2> 0 '(veya' 0> 2 ') olduğunu.

Başlıkta belirtildiği gibi, bir lexer çözümleyiciyi hangi veri türüne döndürmeli / vermelidir?

Belli ki "Token". Bir lexer bir belirteç akışı üretir, bu yüzden bir belirteç akışı döndürmelidir .

Zaten var olan bir Lex olan Flex'ten bahsetti ve onunla 'kurallar' yazmanın elle bir lexer yazmaktan daha kolay olacağını söyledi.

Makine tarafından üretilen lexers, onları hızlı bir şekilde üretebilme avantajına sahiptir; bu, özellikle sözcüksel dilbilginizin çok değişeceğini düşünüyorsanız yararlıdır. Uygulama tercihlerinizde sıklıkla fazla esneklik kazanmamanın dezavantajı vardır.

Bu "basit" olup olmadığını kim umursar dedi? Lexer'ı yazmak genellikle zor kısım değildir!

Bir sözlük yazarken ve bunun yalnızca bir veri türü (karakter dizisi veya sayı) döndürebileceğini varsayarsak, hangisi daha mantıklı bir seçim olurdu?

Ne. Bir lexer genellikle bir belirteç döndüren "sonraki" bir işleme sahiptir, bu nedenle bir belirteç döndürmelidir . Belirteç, bir dize veya sayı değildir. Bu bir belirteç.

Yazdığım en son sözcü "tam bir sadakat" sözlüğü idi, bu, programda ve belirtecinin yanı sıra, programda "boşluk" ve "trivia" dediğimiz tüm boşlukların ve yorumların konumunu izleyen bir belirteç döndürdüğü anlamına geliyordu. Lexer'imde bir belirteç şöyle tanımlandı:

• Önde gelen trivia dizisi
• Bir belirteç türü
• Karakterlerde belirteç genişliği
• Sondaki önemsiz bir dizi

Diğer bilgiler şöyle tanımlandı:

• Bir trivia tür - boşluk, yeni satır, yorum vb.
• Karakterlerde trivia genişliği

Öyleyse gibi bir şeyimiz olsaydı

    foo + /* comment */
/* another comment */ bar;

belirteç türlü dört belirteçleri olarak Lex ki Identifier, Plus, Identifier, Semicolon, ve genişlikte 3, 1, 3, 1, birinci tanımlayıcı trivia oluşan öncü sahiptir Whitespace4 bir genişliğe sahip ve önemsiz şeyler arka Whitespace1. genişliği ile Plusbir öncü trivia vardır ve Bir boşluk, yorum ve yeni satırdan oluşan son bilgiler. Son tanımlayıcı, yorumda ve boşluğun önde gelen bir önemsizine sahiptir, vb.

Bu şema ile dosyadaki her karakter, sözdizimi renklendirmesi gibi şeyler için kullanışlı bir özellik olan lexer'ın çıktısında dikkate alınır.

Tabii ki, eğer triviaya ihtiyacınız yoksa, basit bir şekilde iki şeyi yapabilirsiniz: tür ve genişlik.

Belirteç ve önemsizliğin kaynak kodundaki mutlak konumlarını değil, yalnızca genişliklerini içerdiğini fark edebilirsiniz. Bu kasıtlı. Böyle bir planın avantajları vardır:

• Hafıza ve kablo formatında kompakt
• Düzenlemeler üzerinde re-lexing sağlar; lexer bir IDE içinde çalışıyorsa bu kullanışlıdır. Diğer bir deyişle, bir belirtecin içindeki bir düzenleme tespit ederseniz, düzenleme işleminden önce sözlüğünüzü birkaç belirteçe yedekler ve önceki belirteç akışıyla eşitlenene kadar yeniden yazmaya başlarsınız. Bir karakter yazdığınızda, bu karakter değiştikten sonra her belirtecin konumu değişir, ancak genellikle yalnızca bir veya iki belirteç genişlik değiştirir, böylece tüm bu durumu yeniden kullanabilirsiniz.
• Her belirtecin tam karakter ofsetleri, belirteç akışı üzerinde yinelenerek ve mevcut ofseti takip ederek kolayca elde edilebilir. Tam karakter ofsetlerine sahip olduğunuzda, gerektiğinde metni çıkarmak kolaydır.

Bu senaryoların hiçbirini umursamıyorsanız, bir belirteç, bir çeşit ve genişlik yerine bir tür ve ofset olarak gösterilebilir.

Ancak buradaki kilit paket servisi şudur: programlama, faydalı soyutlamalar yapma sanatıdır . Belirteçleri değiştiriyorsunuz, bu yüzden belirteçler üzerinde faydalı bir soyutlama yapın ve bunun altında hangi uygulama ayrıntılarının altında olduğunuzu kendiniz seçin.

Genellikle, simgeyi (veya kullanım kolaylığı için enum değerini) belirten bir sayıya ve isteğe bağlı bir değere (dizge veya muhtemelen genel / şablonlanmış değer) sahip küçük bir yapı döndürürsünüz. Başka bir yaklaşım, ekstra veri taşıması gereken elementler için türetilmiş bir tip döndürmektir. Her ikisi de hafif derecede dengesizdir ancak pratik bir soruna yeterince iyi çözümler sunar.