একটি বৈধ নিয়মিত অভিব্যক্তি সনাক্ত করার জন্য একটি নিয়মিত প্রকাশ আছে?

Question

অন্য নিয়মিত অভিব্যক্তি সহ কোনও বৈধ নিয়মিত অভিব্যক্তি সনাক্ত করা সম্ভব? যদি তাই হয় তবে নীচে উদাহরণ কোড দিন।

Comments

সুতরাং আপনার সমস্যাটি একটি রেজেক্সকে বৈধতা দিচ্ছে, আপনি এটি সমাধান করার জন্য একটি রেজেেক্স বেছে নিয়েছেন। আমি ভাবছি যে রেজেক্সসের সমস্যা-সংখ্যা-বৃদ্ধিকারী সম্পত্তিটি যদি যুক্ত হয় বা গুণক হয়। এটি 2 :) এর পরিবর্তে 4 সমস্যার মতো মনে হচ্ছে

— অ্যাবেস্টো

নিয়মিত প্রকাশের জন্য অনেকগুলি স্বরলিপি রয়েছে - কিছু বৈশিষ্ট্য এবং তাদের বানান বেশিরভাগ ক্ষেত্রে সাধারণ, কিছু আলাদাভাবে বানানযুক্ত বা কেবল একটি নির্দিষ্ট স্বরলিপিতে উপলভ্য। সেগুলির বেশিরভাগ স্বরলিপি নিয়মিত ব্যাকরণ অর্থে "নিয়মিত" নয় - সুব এক্সপ্রেশনগুলির সীমাহীন বাসা বাঁধার জন্য আপনার একটি প্রসঙ্গ মুক্ত পার্সারের প্রয়োজন হবে - যদিও অনেক আধুনিক "নিয়মিত অভিব্যক্তি" স্বরলিপিগুলি মূল ফর্মাল সংজ্ঞা ছাড়িয়ে যায় এবং তাদের নিজস্ব স্বীকৃতিগুলি স্বীকৃতি দেওয়ার অনুমতি দিতে পারে। যে কোনও ক্ষেত্রে, প্রতিটি রেইজেক্সটি বৈধ হলে কেবল কেন আপনার রেজেক্স লাইব্রেরিটি জিজ্ঞাসা করবেন না?

— স্টিভ 314

@bevacqua আমাকে এক্সএমএল স্কিমাতে রেজিপ্স্পটি বৈধ করতে হবে। আমি কীভাবে এটি অন্য রেজিপক্স ছাড়া করতে পারি?

— zenden2k

আপনার ভাষাতে একটি ব্যতিক্রম-পরিচালনা ব্যবস্থাপনার অধীনে চেক করার জন্য রেজেক্স (প্যাটার্ন) কে প্রকৃতপক্ষে সংকলন / চালনা করুন। সুতরাং ভাষাটির রেজেক্স ইঞ্জিন / সংকলক নিজেই এটি পরীক্ষা করবে। (এটি সঠিক বেসিক সিনট্যাক্সটিকে ধরে নিয়েছে যাতে প্রোগ্রামটি চালিত হয়, তবে এটি আপনার ভাষার সুবিধাগুলি ব্যবহার করে রেজেক্সের স্ট্রিংকে (সম্ভবত সিনথেটিকভাবে ভুল) কোড বা এ জাতীয় মূল্যায়ন করার মাধ্যমে চেক অন্তর্ভুক্ত করা যেতে পারে।)

— zdim

এটি অজগর ব্যবহারকারীদের জন্য সঠিক উত্তর: stackoverflow.com/questions/19630994/…

— gianni

Answer 1

/
^                                             # start of string
(                                             # first group start
  (?:
    (?:[^?+*{}()[\]\\|]+                      # literals and ^, $
     | \\.                                    # escaped characters
     | \[ (?: \^?\\. | \^[^\\] | [^\\^] )     # character classes
          (?: [^\]\\]+ | \\. )* \]
     | \( (?:\?[:=!]|\?<[=!]|\?>)? (?1)?? \)  # parenthesis, with recursive content
     | \(\? (?:R|[+-]?\d+) \)                 # recursive matching
     )
    (?: (?:[?+*]|\{\d+(?:,\d*)?\}) [?+]? )?   # quantifiers
  | \|                                        # alternative
  )*                                          # repeat content
)                                             # end first group
$                                             # end of string
/

এটি একটি পুনরাবৃত্তিমূলক রেজেক্স এবং এটি অনেকগুলি রেইগেক্স ইঞ্জিন দ্বারা সমর্থিত নয়। পিসিআরই ভিত্তিক এটিকে সমর্থন করা উচিত।

সাদা স্থান এবং মন্তব্য ছাড়াই:

/^((?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>)?(?1)??\)|\(\?(?:R|[+-]?\d+)\))(?:(?:[?+*]|\{\d+(?:,\d*)?\})[?+]?)?|\|)*)$/

---

.NET সরাসরি পুনরাবৃত্তি সমর্থন করে না। ( (?1)এন্ড (?R)কনস্ট্রাক্টসস) পুনরাবৃত্তিটি ভারসাম্যপূর্ণ গোষ্ঠীগুলিতে রূপান্তর করতে হবে:

^                                         # start of string
(?:
  (?: [^?+*{}()[\]\\|]+                   # literals and ^, $
   | \\.                                  # escaped characters
   | \[ (?: \^?\\. | \^[^\\] | [^\\^] )   # character classes
        (?: [^\]\\]+ | \\. )* \]
   | \( (?:\?[:=!]
         | \?<[=!]
         | \?>
         | \?<[^\W\d]\w*>
         | \?'[^\W\d]\w*'
         )?                               # opening of group
     (?<N>)                               #   increment counter
   | \)                                   # closing of group
     (?<-N>)                              #   decrement counter
   )
  (?: (?:[?+*]|\{\d+(?:,\d*)?\}) [?+]? )? # quantifiers
| \|                                      # alternative
)*                                        # repeat content
$                                         # end of string
(?(N)(?!))                                # fail if counter is non-zero.

সন্নিবিষ্ট:

^(?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>|\?<[^\W\d]\w*>|\?'[^\W\d]\w*')?(?<N>)|\)(?<-N>))(?:(?:[?+*]|\{\d+(?:,\d*)?\})[?+]?)?|\|)*$(?(N)(?!))

মন্তব্য থেকে:

এই বিকল্প এবং অনুবাদগুলি বৈধ করবে?

এটি বিকল্প এবং অনুবাদগুলির কেবলমাত্র রেজেক্স অংশকে বৈধতা দেবে। s/<this part>/.../

রিজেক্সের সাথে সমস্ত বৈধ রেজেক্স ব্যাকরণগুলির সাথে মিলানো তাত্ত্বিকভাবে সম্ভব নয়।

এটি সম্ভব যদি রেজেক্স ইঞ্জিন পিসিআরই এর মতো পুনরাবৃত্তি সমর্থন করে তবে এটিকে আর নিয়মিত এক্সপ্রেশন হিসাবে বলা যায় না।

আসলে, একটি "পুনরাবৃত্ত নিয়মিত অভিব্যক্তি" কোনও নিয়মিত প্রকাশ নয়। তবে এটি একটি রেজিএক্স ইঞ্জিনগুলিতে প্রায়শই গৃহীত এক্সটেনশন ... হাস্যকরভাবে, এই বর্ধিত রেজেক্সটি প্রসারিত রেজিক্সগুলির সাথে মেলে না।

"তত্ত্বের ক্ষেত্রে তত্ত্ব ও অনুশীলন একই রকম। বাস্তবে তারা তা হয় না।" নিয়মিত ভাব প্রকাশের প্রায় সবাই জানেন যে নিয়মিত প্রকাশগুলি পুনরাবৃত্তি সমর্থন করে না। তবে পিসিআরই এবং অন্যান্য অন্যান্য বাস্তবায়নগুলি বেসিক নিয়মিত অভিব্যক্তিগুলির চেয়ে অনেক বেশি সমর্থন করে।

এটি গ্রেপ কমান্ডে শেল স্ক্রিপ্টের সাহায্যে ব্যবহার করে এটি আমাকে কিছু ত্রুটি দেখায় .. গ্রেপ: Invalid Invalid এর অবৈধ সামগ্রী} আমি এমন একটি স্ক্রিপ্ট তৈরি করছি যা নিয়মিত এক্সপ্রেশন থাকা সমস্ত ফাইল সন্ধানের জন্য একটি কোড বেসকে গ্রেপ করতে পারে

এই প্যাটার্নটি পুনরাবৃত্তাকার নিয়মিত এক্সপ্রেশন নামে পরিচিত একটি এক্সটেনশন ব্যবহার করে। এটি রেগেক্সের পসিক্স গন্ধ দ্বারা সমর্থিত নয়। আপনি পিসিআরই রেজেক্স গন্ধ সক্ষম করতে -P সুইচ দিয়ে চেষ্টা করতে পারেন।

রেজেক্স নিজেই "একটি নিয়মিত ভাষা নয় এবং তাই নিয়মিত প্রকাশের মাধ্যমে পার্স করা যায় না ..."

এটি শাস্ত্রীয় নিয়মিত প্রকাশের জন্য সত্য। কিছু আধুনিক বাস্তবায়ন পুনরাবৃত্তি করার অনুমতি দেয়, যা এটিকে একটি প্রাসঙ্গিক মুক্ত ভাষায় পরিণত করে, যদিও এটি এই কাজের জন্য কিছুটা শব্দভাবাপন্ন।

আমি দেখছি আপনি কোথায় মিলছেন []()/\। এবং অন্যান্য বিশেষ রেগেক্স অক্ষর। আপনি অ-বিশেষ অক্ষরগুলি কোথায় অনুমতি দিচ্ছেন? দেখে মনে হচ্ছে এটি মিলবে ^(?:[\.]+)$, তবে নয় ^abcdefg$। এটি একটি বৈধ regex।

[^?+*{}()[\]\\|]অন্য কোনও নির্মাণের অংশ নয়, কোনও একক অক্ষরের সাথে মিলবে। (এই উভয় আক্ষরিক অন্তর্ভুক্ত a- z), এবং নির্দিষ্ট বিশেষ অক্ষর ( ^, $, .)।

Comments

এই উত্তরটি মানুষকে সম্পূর্ণ ভুল পথে প্রেরণ করে। নিয়মিত অভিব্যক্তিগুলি সনাক্ত করতে তাদের কখনই রেজিএক্স ব্যবহার করা উচিত নয়, কারণ এটি সব ক্ষেত্রেই সঠিকভাবে কাজ করতে পারে না। আমার উত্তর যুক্ত হয়েছে দেখুন।

— প্রাণবন্ত- t

.{,1}তুলনামূলক। ^((?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>)?(?1)??\)|\(\?(?:R|[+-]?\d+)\))(?:(?:[?+*]|\{\d*(?:,\d*)?\})[?+]?)?|\|)*)$ম্যাচে পরিবর্তন করুন । পরিবর্তন \d+করার জন্য\d*

— yunzen

রেজি দ্বারা বাই ডিফারেন্স হওয়া উচিত নয়, কমপক্ষে আপনার উত্তরে এর মতো কিছু বলুন, ইউর রেজেক্স ইঞ্জিন সম্ভবত "খুব শক্তিশালী" এবং সত্যই কোনও রেজেক্স ইঞ্জিন নয়।

— চার্লি পার্কার

আপনি কেবলমাত্র একটি নোট আপনি x পতাকা ভুলে গেছেন

— রেডক্লোভার

এই বৈধতা পিসিআরই এক্সপ্রেশনগুলির জন্য তৈরি হয়েছে বলে মনে হয় তবে এটি অনেকগুলি অবৈধ পসিক্স ইআর পাস করবে। উল্লেখ্য, তারা চরিত্র শ্রেণী রেঞ্জ একটু pickier হয়, যেমন এই ere মধ্যে PCRE কিন্তু বৈধ নয়: [a-b-c]।

— পেড্রো গিমেনো

Answer 2

অসম্ভাব্য।

try..catchআপনার ভাষা যা দেয় তা এটিকে মূল্যায়ন করুন ।

Answer 3

না, আপনি যদি নিয়মিত প্রকাশের বিষয়ে কঠোরভাবে কথা বলছেন এবং কিছু নিয়মিত অভিব্যক্তি বাস্তবায়ন যা আসলে প্রাসঙ্গিক মুক্ত ব্যাকরণ হিসাবে অন্তর্ভুক্ত না করে থাকেন।

নিয়মিত এক্সপ্রেশনগুলির একটি সীমাবদ্ধতা রয়েছে যা সমস্ত এবং কেবলমাত্র রেইজেক্সের সাথে মিলে এমন একটি রেজেক্স লিখতে অসম্ভব করে তোলে। জোড়া লাগানো যেমন বন্ধনীগুলির মতো প্রয়োগগুলি আপনি মেলাতে পারবেন না। রেজেক্সেস এ জাতীয় অনেকগুলি নির্মাণ ব্যবহার করে, এর []উদাহরণ হিসাবে নেওয়া যাক । যখনই কোনও [আছে সেখানে অবশ্যই একটি মিল থাকতে হবে ]যা একটি রেইজেক্সের পক্ষে যথেষ্ট সহজ "\[.*\]"।

রেজেক্সসের পক্ষে যা অসম্ভব হয়ে পড়ে তা হ'ল তারা বাসা বাঁধতে পারে। নেস্টেড বন্ধনীগুলির সাথে মেলে এমন একটি রেজেক্স আপনি কীভাবে লিখতে পারেন? উত্তরটি হ'ল আপনি দীর্ঘকালীন দীর্ঘকালীন রেগেক্স ছাড়াই পারবেন না। ব্রুট ফোর্সের মাধ্যমে আপনি যে কোনও সংখ্যক নেস্টেড প্যারেনেসিসের সাথে মেলে ফেলতে পারেন তবে আপনি কখনও নেস্টেট ব্র্যাকেটের একটি নির্বিচারে দীর্ঘ সেটের সাথে মেলাতে পারবেন না।

এই ক্ষমতাটি প্রায়শই গণনা হিসাবে উল্লেখ করা হয়, কারণ আপনি নীড়ের গভীরতা গণনা করছেন। সংজ্ঞা অনুসারে একটি রেজেক্স গণনা করার ক্ষমতা রাখে না।

---

আমি এই সম্পর্কে " নিয়মিত এক্সপ্রেশন সীমাবদ্ধতা " লিখে শেষ করেছি ।

Answer 4

ভাল প্রশ্ন.

সত্যিকারের নিয়মিত ভাষাগুলি নির্বিচারে গভীরভাবে নেস্টেড সুগঠিত প্রথম বন্ধনী সিদ্ধান্ত নিতে পারে না। যদি আপনার বর্ণমালা থাকে '('এবং ')'লক্ষ্য নির্ধারণ করা হয় যে এরগুলির একটি স্ট্রিংয়ের সাথে সুসংগত মিলেকৃত প্রথম বন্ধনী রয়েছে কিনা। নিয়মিত প্রকাশের জন্য এটি প্রয়োজনীয় প্রয়োজনীয়তা হওয়ায় উত্তরটি হ'ল না।

তবে, যদি আপনি প্রয়োজনীয়তাটি শিথিল করেন এবং পুনরাবৃত্তি যুক্ত করেন তবে আপনি সম্ভবত এটি করতে পারেন। কারণটি হ'ল পুনরাবৃত্তি আপনাকে এই স্ট্যাকের উপর চাপ দিয়ে বর্তমান বাসা বাঁধার গভীরতা "গণনা" করতে একটি স্ট্যাক হিসাবে কাজ করতে পারে।

রাশ কক্স লিখেছেন " নিয়মিত এক্সপ্রেশন ম্যাচিং ক্যান বিম সিম্পল অ্যান্ড ফাস্ট " যা রেজেক্স ইঞ্জিন বাস্তবায়নের একটি দুর্দান্ত গ্রন্থ।

Answer 5

না, আপনি যদি নিয়মিত প্রকাশ করেন।

কারণটি হ'ল আপনি নিয়মিত ভাষার জন্য পাম্পিং লেমাকে সন্তুষ্ট করতে পারবেন না । পাম্পিং থিম রাজ্যের একটি স্ট্রিং ভাষা থেকে "L" লিখে একাত্মতার যদি একটি নম্বর "এন" যেমন যে, তিন, সাবস্ট্রিং মধ্যে স্ট্রিং বিভাজক পরে বিদ্যমান নিয়মিত যে x, y, z, যেমন যে |x|>=1 && |xy|<=N, আপনি পুনরায় রিপিট করতে পারেন yঅনেক বার হিসাবে হিসাবে আপনি চান এবং পুরো স্ট্রিং এখনও অন্তর্গত হবে L।

পাম্পিং লেমার একটি পরিণতি হ'ল ফর্মটিতে আপনার নিয়মিত স্ট্রিং থাকতে পারে না a^Nb^Mc^N, অর্থাৎ দুটি স্ট্রাস্টিং একই দৈর্ঘ্যের সাথে অন্য স্ট্রিং দ্বারা পৃথক। কোন ভাবেই আপনি এই ধরনের স্ট্রিং বিভক্ত x, yএবং z"পাম্প", আপনি পারেন না y, এর "একটি" এবং "C" একটি আলাদা নম্বর দিয়ে একটি স্ট্রিং প্রাপ্তির এইভাবে মূল ভাষা গিয়েই। উদাহরণস্বরূপ, নিয়মিত অভিব্যক্তিগুলিতে প্রথম বন্ধনীগুলির ক্ষেত্রে এটি ক্ষেত্রে।

Comments

এটি পাম্পিং লেমার খুব সুনির্দিষ্ট বিবরণ নয়। প্রথমত, এটি সম্পূর্ণ ভাষা যা নিয়মিত হতে পারে, একটি স্ট্রিং নয়। দ্বিতীয়ত, এটি নিয়মিততার জন্য পর্যাপ্ত শর্ত নয়, প্রয়োজনীয়। অবশেষে, কেবল পর্যাপ্ত দীর্ঘ স্ট্রিংগুলি পাম্পযোগ্য।

— দরিজ গ্রিনবার্গ

Answer 6

যদিও মিজারডএক্স পোস্ট করেছে যেমন একটি পুনরাবৃত্তিমূলক রেজেক্স ব্যবহার করা পুরোপুরি সম্ভব তবে এই ধরণের জিনিসগুলির জন্য এটি পার্সার অনেক বেশি কার্যকর। রেজেক্সেসগুলি মূলত নিয়মিত ভাষার সাথে ব্যবহার করার উদ্দেশ্যে তৈরি হয়েছিল, পুনরাবৃত্ত হওয়া বা ভারসাম্যহীন গ্রুপ থাকা কেবল প্যাচ।

বৈধ রেজেক্সেসকে যে ভাষাটি সংজ্ঞায়িত করে তা আসলে একটি প্রসঙ্গমুক্ত ব্যাকরণ এবং আপনার এটি পরিচালনা করার জন্য উপযুক্ত পার্সার ব্যবহার করা উচিত। সরল রেজেক্সেস (বেশিরভাগ নির্মাণ ছাড়াই) পার্স করার জন্য একটি বিশ্ববিদ্যালয় প্রকল্পের উদাহরণ এখানে। এটি জাভাসিসি ব্যবহার করে। এবং হ্যাঁ, মন্তব্যগুলি স্প্যানিশ ভাষায় রয়েছে যদিও পদ্ধতির নামগুলি বেশ স্ব-বর্ণনামূলক।

SKIP :
{
    " "
|   "\r"
|   "\t"
|   "\n"
}
TOKEN : 
{
    < DIGITO: ["0" - "9"] >
|   < MAYUSCULA: ["A" - "Z"] >
|   < MINUSCULA: ["a" - "z"] >
|   < LAMBDA: "LAMBDA" >
|   < VACIO: "VACIO" >
}

IRegularExpression Expression() :
{
    IRegularExpression r; 
}
{
    r=Alternation() { return r; }
}

// Matchea disyunciones: ER | ER
IRegularExpression Alternation() :
{
    IRegularExpression r1 = null, r2 = null; 
}
{
    r1=Concatenation() ( "|" r2=Alternation() )?
    { 
        if (r2 == null) {
            return r1;
        } else {
            return createAlternation(r1,r2);
        } 
    }
}

// Matchea concatenaciones: ER.ER
IRegularExpression Concatenation() :
{
    IRegularExpression r1 = null, r2 = null; 
}
{
    r1=Repetition() ( "." r2=Repetition() { r1 = createConcatenation(r1,r2); } )*
    { return r1; }
}

// Matchea repeticiones: ER*
IRegularExpression Repetition() :
{
    IRegularExpression r; 
}
{
    r=Atom() ( "*" { r = createRepetition(r); } )*
    { return r; }
}

// Matchea regex atomicas: (ER), Terminal, Vacio, Lambda
IRegularExpression Atom() :
{
    String t;
    IRegularExpression r;
}
{
    ( "(" r=Expression() ")" {return r;}) 
    | t=Terminal() { return createTerminal(t); }
    | <LAMBDA> { return createLambda(); }
    | <VACIO> { return createEmpty(); }
}

// Matchea un terminal (digito o minuscula) y devuelve su valor
String Terminal() :
{
    Token t;
}
{
    ( t=<DIGITO> | t=<MINUSCULA> ) { return t.image; }
}

Answer 7

আপনি রেজেক্স জমা দিতে পারেন preg_matchযা রেজেক্সটি বৈধ না হলে মিথ্যা ফিরে আসবে। @ত্রুটি বার্তা দমন করতে ব্যবহার করতে ভুলবেন না :

@preg_match($regexToTest, '');

• রেজেক্স হলে 1 প্রদান করবে //।
• রেজেক্স ঠিক থাকলে 0 আসবে।
• অন্যথায় মিথ্যা ফিরে আসবে।

Answer 8

পল ম্যাকগুইয়ারের নীচের উদাহরণটি মূলত পাইপার্সিং উইকি থেকে প্রাপ্ত, তবে এখন কেবল ওয়েবব্যাক মেশিনের মাধ্যমে পাওয়া যায় , ম্যাচিংয়ের স্ট্রিংগুলির সেটটি ফেরত দেওয়ার উদ্দেশ্যে কিছু রেজেক্স পার্স করার ব্যাকরণ দেয় । যেমনটি, এটি সেইগুলি পুনরায় প্রত্যাখ্যান করে যার মধ্যে সীমাহীন পুনরাবৃত্তি শর্তাদি অন্তর্ভুক্ত থাকে, যেমন '+' এবং '*'। তবে এটি আপনাকে এমন একটি পার্সার কীভাবে গঠন করবে যা পুনরায় প্রক্রিয়া করবে তা সম্পর্কে ধারণা দেওয়া উচিত।

# 
# invRegex.py
#
# Copyright 2008, Paul McGuire
#
# pyparsing script to expand a regular expression into all possible matching strings
# Supports:
# - {n} and {m,n} repetition, but not unbounded + or * repetition
# - ? optional elements
# - [] character ranges
# - () grouping
# - | alternation
#
__all__ = ["count","invert"]

from pyparsing import (Literal, oneOf, printables, ParserElement, Combine, 
    SkipTo, operatorPrecedence, ParseFatalException, Word, nums, opAssoc,
    Suppress, ParseResults, srange)

class CharacterRangeEmitter(object):
    def __init__(self,chars):
        # remove duplicate chars in character range, but preserve original order
        seen = set()
        self.charset = "".join( seen.add(c) or c for c in chars if c not in seen )
    def __str__(self):
        return '['+self.charset+']'
    def __repr__(self):
        return '['+self.charset+']'
    def makeGenerator(self):
        def genChars():
            for s in self.charset:
                yield s
        return genChars

class OptionalEmitter(object):
    def __init__(self,expr):
        self.expr = expr
    def makeGenerator(self):
        def optionalGen():
            yield ""
            for s in self.expr.makeGenerator()():
                yield s
        return optionalGen

class DotEmitter(object):
    def makeGenerator(self):
        def dotGen():
            for c in printables:
                yield c
        return dotGen

class GroupEmitter(object):
    def __init__(self,exprs):
        self.exprs = ParseResults(exprs)
    def makeGenerator(self):
        def groupGen():
            def recurseList(elist):
                if len(elist)==1:
                    for s in elist[0].makeGenerator()():
                        yield s
                else:
                    for s in elist[0].makeGenerator()():
                        for s2 in recurseList(elist[1:]):
                            yield s + s2
            if self.exprs:
                for s in recurseList(self.exprs):
                    yield s
        return groupGen

class AlternativeEmitter(object):
    def __init__(self,exprs):
        self.exprs = exprs
    def makeGenerator(self):
        def altGen():
            for e in self.exprs:
                for s in e.makeGenerator()():
                    yield s
        return altGen

class LiteralEmitter(object):
    def __init__(self,lit):
        self.lit = lit
    def __str__(self):
        return "Lit:"+self.lit
    def __repr__(self):
        return "Lit:"+self.lit
    def makeGenerator(self):
        def litGen():
            yield self.lit
        return litGen

def handleRange(toks):
    return CharacterRangeEmitter(srange(toks[0]))

def handleRepetition(toks):
    toks=toks[0]
    if toks[1] in "*+":
        raise ParseFatalException("",0,"unbounded repetition operators not supported")
    if toks[1] == "?":
        return OptionalEmitter(toks[0])
    if "count" in toks:
        return GroupEmitter([toks[0]] * int(toks.count))
    if "minCount" in toks:
        mincount = int(toks.minCount)
        maxcount = int(toks.maxCount)
        optcount = maxcount - mincount
        if optcount:
            opt = OptionalEmitter(toks[0])
            for i in range(1,optcount):
                opt = OptionalEmitter(GroupEmitter([toks[0],opt]))
            return GroupEmitter([toks[0]] * mincount + [opt])
        else:
            return [toks[0]] * mincount

def handleLiteral(toks):
    lit = ""
    for t in toks:
        if t[0] == "\\":
            if t[1] == "t":
                lit += '\t'
            else:
                lit += t[1]
        else:
            lit += t
    return LiteralEmitter(lit)    

def handleMacro(toks):
    macroChar = toks[0][1]
    if macroChar == "d":
        return CharacterRangeEmitter("0123456789")
    elif macroChar == "w":
        return CharacterRangeEmitter(srange("[A-Za-z0-9_]"))
    elif macroChar == "s":
        return LiteralEmitter(" ")
    else:
        raise ParseFatalException("",0,"unsupported macro character (" + macroChar + ")")

def handleSequence(toks):
    return GroupEmitter(toks[0])

def handleDot():
    return CharacterRangeEmitter(printables)

def handleAlternative(toks):
    return AlternativeEmitter(toks[0])


_parser = None
def parser():
    global _parser
    if _parser is None:
        ParserElement.setDefaultWhitespaceChars("")
        lbrack,rbrack,lbrace,rbrace,lparen,rparen = map(Literal,"[]{}()")

        reMacro = Combine("\\" + oneOf(list("dws")))
        escapedChar = ~reMacro + Combine("\\" + oneOf(list(printables)))
        reLiteralChar = "".join(c for c in printables if c not in r"\[]{}().*?+|") + " \t"

        reRange = Combine(lbrack + SkipTo(rbrack,ignore=escapedChar) + rbrack)
        reLiteral = ( escapedChar | oneOf(list(reLiteralChar)) )
        reDot = Literal(".")
        repetition = (
            ( lbrace + Word(nums).setResultsName("count") + rbrace ) |
            ( lbrace + Word(nums).setResultsName("minCount")+","+ Word(nums).setResultsName("maxCount") + rbrace ) |
            oneOf(list("*+?")) 
            )

        reRange.setParseAction(handleRange)
        reLiteral.setParseAction(handleLiteral)
        reMacro.setParseAction(handleMacro)
        reDot.setParseAction(handleDot)

        reTerm = ( reLiteral | reRange | reMacro | reDot )
        reExpr = operatorPrecedence( reTerm,
            [
            (repetition, 1, opAssoc.LEFT, handleRepetition),
            (None, 2, opAssoc.LEFT, handleSequence),
            (Suppress('|'), 2, opAssoc.LEFT, handleAlternative),
            ]
            )
        _parser = reExpr

    return _parser

def count(gen):
    """Simple function to count the number of elements returned by a generator."""
    i = 0
    for s in gen:
        i += 1
    return i

def invert(regex):
    """Call this routine as a generator to return all the strings that
       match the input regular expression.
           for s in invert("[A-Z]{3}\d{3}"):
               print s
    """
    invReGenerator = GroupEmitter(parser().parseString(regex)).makeGenerator()
    return invReGenerator()

def main():
    tests = r"""
    [A-EA]
    [A-D]*
    [A-D]{3}
    X[A-C]{3}Y
    X[A-C]{3}\(
    X\d
    foobar\d\d
    foobar{2}
    foobar{2,9}
    fooba[rz]{2}
    (foobar){2}
    ([01]\d)|(2[0-5])
    ([01]\d\d)|(2[0-4]\d)|(25[0-5])
    [A-C]{1,2}
    [A-C]{0,3}
    [A-C]\s[A-C]\s[A-C]
    [A-C]\s?[A-C][A-C]
    [A-C]\s([A-C][A-C])
    [A-C]\s([A-C][A-C])?
    [A-C]{2}\d{2}
    @|TH[12]
    @(@|TH[12])?
    @(@|TH[12]|AL[12]|SP[123]|TB(1[0-9]?|20?|[3-9]))?
    @(@|TH[12]|AL[12]|SP[123]|TB(1[0-9]?|20?|[3-9])|OH(1[0-9]?|2[0-9]?|30?|[4-9]))?
    (([ECMP]|HA|AK)[SD]|HS)T
    [A-CV]{2}
    A[cglmrstu]|B[aehikr]?|C[adeflmorsu]?|D[bsy]|E[rsu]|F[emr]?|G[ade]|H[efgos]?|I[nr]?|Kr?|L[airu]|M[dgnot]|N[abdeiop]?|Os?|P[abdmortu]?|R[abefghnu]|S[bcegimnr]?|T[abcehilm]|Uu[bhopqst]|U|V|W|Xe|Yb?|Z[nr]
    (a|b)|(x|y)
    (a|b) (x|y)
    """.split('\n')

    for t in tests:
        t = t.strip()
        if not t: continue
        print '-'*50
        print t
        try:
            print count(invert(t))
            for s in invert(t):
                print s
        except ParseFatalException,pfe:
            print pfe.msg
            print
            continue
        print

if __name__ == "__main__":
    main()