এটি হল পার্লিওল কমান্ড যা আমাদের একাধিক বিনামূল্যের অনলাইন ওয়ার্কস্টেশন যেমন উবুন্টু অনলাইন, ফেডোরা অনলাইন, উইন্ডোজ অনলাইন এমুলেটর বা MAC OS অনলাইন এমুলেটর ব্যবহার করে OnWorks ফ্রি হোস্টিং প্রদানকারীতে চালানো যেতে পারে।
কার্যক্রম:
NAME এর
perliol - পার্লের স্তরগুলিতে IO বাস্তবায়নের জন্য C API।
সাইনোপিসিস
/* একটি স্তর সংজ্ঞায়িত করা ... */
# অন্তর্ভুক্ত
বর্ণনাঃ
এই নথিটি PerlIO বিমূর্ততার আচরণ এবং বাস্তবায়ন বর্ণনা করে
যখন "USE_PERLIO" সংজ্ঞায়িত করা হয় তখন পার্লাপিওতে বর্ণনা করা হয়।
ইতিহাস এবং পটভূমি
PerlIO বিমূর্ততা perl5.003_02 এ প্রবর্তন করা হয়েছিল কিন্তু শুধুমাত্র একটি হিসাবে নিস্তেজ ছিল
perl5.7.0 পর্যন্ত বিমূর্ততা। যাইহোক সেই সময়ের মধ্যে বেশ কয়েকটি পার্ল এক্সটেনশন সুইচ করা হয়েছিল
এটি ব্যবহার করার জন্য, তাই API (উৎস) সামঞ্জস্য বজায় রাখার জন্য বেশিরভাগই স্থির করা হয়।
বাস্তবায়নের লক্ষ্য হল একটি নমনীয় এবং প্ল্যাটফর্মে PerlIO API প্রদান করা
নিরপেক্ষ পদ্ধতি এটি একটি "অবজেক্ট ওরিয়েন্টেড সি, ভিটেবল সহ" পদ্ধতিরও একটি পরীক্ষা যা
পার্ল 6 এ প্রয়োগ করা যেতে পারে।
মৌলিক গঠন
PerlIO হল স্তরগুলির একটি স্ট্যাক।
স্ট্যাকের নিম্ন স্তরগুলি নিম্ন-স্তরের অপারেটিং সিস্টেম কলগুলির সাথে কাজ করে (ফাইল
C-তে বর্ণনাকারী) বাইট ইন এবং আউট করা, স্ট্যাক বাফারের উচ্চ স্তর, ফিল্টার,
এবং অন্যথায় I/O ম্যানিপুলেট করুন এবং পার্লে অক্ষর (বা বাইট) ফিরিয়ে দিন। শর্তাবলী উপরে
এবং নিচে স্ট্যাক স্তরগুলির আপেক্ষিক অবস্থান উল্লেখ করতে ব্যবহৃত হয়।
একটি স্তরে একটি "vtable" থাকে, I/O ক্রিয়াকলাপের টেবিল (C স্তরে ফাংশনের একটি টেবিল
পয়েন্টার), এবং স্ট্যাটাস পতাকা। vtable এর ফাংশন যেমন অপারেশন বাস্তবায়ন করে
"খোলা", "পড়ুন", এবং "লিখুন"।
যখন I/O, উদাহরণস্বরূপ "পড়ুন", অনুরোধ করা হয়, তখন অনুরোধটি পার্ল থেকে প্রথমে নিচে যায়
স্ট্যাক প্রতিটি স্তরের "পড়ুন" ফাংশন ব্যবহার করে, তারপর নীচের অংশ থেকে ইনপুট অনুরোধ করা হয়
অপারেটিং সিস্টেম পরিষেবা, তারপর ফলাফল স্ট্যাক আপ ফিরে, অবশেষে হচ্ছে
পার্ল ডেটা হিসাবে ব্যাখ্যা করা হয়েছে।
অনুরোধগুলি অগত্যা অপারেটিং সিস্টেমে সর্বদা সর্বদা চলে যায় না: এটাই
যেখানে পার্লিও বাফারিং কার্যকর হয়।
আপনি যখন একটি খোলা () এবং অতিরিক্ত PerlIO স্তরগুলি স্থাপন করা হবে, যে স্তরগুলি আপনি নির্দিষ্ট করুন৷
ইতিমধ্যে বিদ্যমান ডিফল্ট স্ট্যাকের উপরে "ধাক্কা" আছে উল্লেখ করুন। এটি দেখতে একটি উপায়
যে "অপারেটিং সিস্টেম বাম দিকে" এবং "পার্ল ডানদিকে"।
এই ডিফল্ট স্ট্যাকের সঠিক স্তরগুলি অনেক কিছুর উপর নির্ভর করে: আপনার অপারেটিং
সিস্টেম, পার্ল সংস্করণ, পার্ল কম্পাইল টাইম কনফিগারেশন এবং পার্ল রানটাইম কনফিগারেশন।
পার্লিও দেখুন, perlrun-এ "PERLIO" এবং আরও তথ্যের জন্য খুলুন।
বিনমোড() অনুরূপভাবে কাজ করে খোলা (): ডিফল্টরূপে নির্দিষ্ট স্তর উপরে ধাক্কা হয়
বিদ্যমান স্ট্যাকের।
যাইহোক, উল্লেখ্য যে নির্দিষ্ট স্তরগুলির জন্য "উপরে ঠেলে দেওয়া হয়" খোলা () এবং
বিনমোড(), এর মানে এই নয় যে প্রভাবগুলি "শীর্ষ" পর্যন্ত সীমাবদ্ধ: PerlIO স্তরগুলি করতে পারে৷
খুব 'সক্রিয়' হোন এবং স্ট্যাকের গভীরে স্তরগুলি পরিদর্শন ও প্রভাবিত করুন। উদাহরণ হিসেবে
"কাঁচা" নামক একটি স্তর রয়েছে যা বারবার "পপ" স্তরগুলি প্রথম পর্যন্ত না পৌঁছানো পর্যন্ত
স্তর যা নিজেকে বাইনারি ডেটা পরিচালনা করতে সক্ষম বলে ঘোষণা করেছে। "ধাক্কা" স্তর হয়
বাম-থেকে-ডান ক্রমে প্রক্রিয়া করা হয়।
sysopen() তুলনায় স্ট্যাকের নিম্ন স্তরে (আশ্চর্যজনকভাবে) পরিচালনা করে খোলা ()। জন্য
ইউনিক্স বা ইউনিক্স-এর মতো সিস্টেমে উদাহরণ sysopen() ফাইলের স্তরে সরাসরি কাজ করে
বর্ণনাকারী: পার্লিও স্তরগুলির শর্তে, এটি শুধুমাত্র "ইউনিক্স" স্তর ব্যবহার করে, যা একটি
ইউনিক্স ফাইল বর্ণনাকারীর উপরে বরং পাতলা মোড়ক।
স্তরসমূহ vs অনুশাসন
IO স্ট্রিম আচরণ পরিবর্তন করার ক্ষমতার প্রাথমিক আলোচনা শব্দটি ব্যবহার করেছে
যোগ করা সত্ত্বার জন্য "শৃঙ্খলা"। এটি এসেছে (আমি বিশ্বাস করি) এর ব্যবহার থেকে
"sfio" তে শব্দটি, যা ইউনিক্স টার্মিনালের "লাইন ডিসিপ্লিন" থেকে এটি ধার করেছে।
যাইহোক, এই নথিটি (এবং সি কোড) "স্তর" শব্দটি ব্যবহার করে।
এটি, আমি আশা করি, বাস্তবায়নের জন্য এটি একটি প্রাকৃতিক শব্দ, এবং অর্থবোধ এড়ানো উচিত
যেগুলি বরং ভিন্ন জিনিসগুলির জন্য "শৃঙ্খলা" এর পূর্বের ব্যবহারগুলিতে অন্তর্নিহিত।
উপাত্ত কাঠামো
মৌলিক তথ্য কাঠামো একটি PerlIOl:
typedef struct _PerlIO PerlIOl;
typedef struct _PerlIO_funcs PerlIO_funcs;
typedef PerlIOl *PerlIO;
struct _PerliO
{
PerlIOl * পরবর্তী; /* নিম্ন স্তর */
PerlIO_funcs * ট্যাব; /* এই স্তরের জন্য ফাংশন */
U32 পতাকা; /* রাষ্ট্রের জন্য বিভিন্ন পতাকা */
};
একটি "PerlIOl *" হল স্ট্রাকটের একটি পয়েন্টার, এবং আবেদন স্তর "PerlIO *" হল a
একটি "PerlIOl *"-এর পয়েন্টার - অর্থাত্ স্ট্রাকটের একটি পয়েন্টারে একটি পয়েন্টার। এই অনুমতি দেয়
অ্যাপ্লিকেশন স্তর "PerlIO *" স্থির থাকতে হবে যখন প্রকৃত "PerlIOl *" নীচে
পরিবর্তন (পার্লের "SV *" তুলনা করুন যা স্থির থাকে যখন এর "sv_any" ক্ষেত্র পরিবর্তিত হয়
স্কেলারের ধরন পরিবর্তিত হয়।) একটি IO স্ট্রীম তখন সাধারণভাবে একটি পয়েন্টার হিসাবে উপস্থাপিত হয়
"স্তরগুলির" এই লিঙ্কযুক্ত তালিকা।
এটি লক্ষ করা উচিত যে একটি "PerlIO *" এ দ্বৈত নির্দেশের কারণে, a
"&(perlio->পরবর্তী)" "" হল "PerlIO *", এবং তাই কিছু মাত্রায় অন্তত একটি স্তর ব্যবহার করতে পারে
নিচের পরবর্তী স্তরে "মানক" API।
একটি "স্তর" দুটি অংশ নিয়ে গঠিত:
1. "লেয়ার ক্লাস" এর ফাংশন এবং অ্যাট্রিবিউট।
2. একটি নির্দিষ্ট হ্যান্ডেলের জন্য প্রতি-ইনস্ট্যান্স ডেটা।
কার্যাবলী এবং আরোপ করা
ফাংশন এবং বৈশিষ্ট্যগুলি "PerlIOl" এর "ট্যাব" (টেবিলের জন্য) সদস্যের মাধ্যমে অ্যাক্সেস করা হয়।
ফাংশন (লেয়ার "ক্লাস" এর পদ্ধতি) স্থির, এবং দ্বারা সংজ্ঞায়িত করা হয়
"PerlIO_funcs" প্রকার। এগুলি সর্বজনীন "PerlIO_" ফাংশনগুলির মতোই বিস্তৃতভাবে একই:
struct _PerlIO_funcs
{
আকার_টি fsize;
char * নাম;
Size_t আকার;
IV ধরনের;
IV (*পুশ করা)(pTHX_ PerlIO *f,const char *মোড,SV *arg, PerlIO_funcs *ট্যাব);
IV (*পপড)(pTHX_ PerlIO *f);
PerlIO * (*খোলা)(pTHX_ PerlIO_funcs *ট্যাব,
PerlIO_list_t *স্তর, IV n,
const char *মোড,
int fd, int imode, int perm,
পার্লিও *পুরনো,
int narg, SV **args);
IV (*বিনমোড)(pTHX_ PerlIO *f);
SV * (*Getarg)(pTHX_ PerlIO *f, CLONE_PARAMS *প্যারাম, int পতাকা)
IV (*ফাইলেনো)(pTHX_ PerlIO *f);
PerlIO * (*Dup)(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int পতাকা)
/* ইউনিক্স-এর মত ফাংশন - cf sfio লাইন ডিসিপ্লিন */
SSize_t (*পড়ুন)(pTHX_ PerlIO *f, void *vbuf, Size_t গণনা);
SSize_t (*অপঠিত)(pTHX_ PerlIO *f, const void *vbuf, Size_t গণনা);
SSize_t (*লিখুন)(pTHX_ PerlIO *f, const void *vbuf, Size_t গণনা);
IV (*Seek)(pTHX_ PerlIO *f, Off_t অফসেট, int কোথা থেকে);
অফ_টি (*বলুন)(pTHX_ PerlIO *f);
IV (*বন্ধ)(pTHX_ PerlIO *f);
/* Stdio-এর মতো বাফার করা IO ফাংশন */
IV (*ফ্লাশ)(pTHX_ PerlIO *f);
IV (*ফিল)(pTHX_ PerlIO *f);
IV (*Eof)(pTHX_ PerlIO *f);
IV (*ত্রুটি)(pTHX_ PerlIO *f);
অকার্যকর (*ক্লিয়ারার)(pTHX_ PerlIO *f);
void (*Setlinebuf)(pTHX_ PerlIO *f);
/* পার্লের স্নুপিং ফাংশন */
STDCHAR * (*Get_base)(pTHX_ PerlIO *f);
আকার_টি (*Get_bufsiz)(pTHX_ PerlIO *f);
STDCHAR * (*Get_ptr)(pTHX_ PerlIO *f);
SSize_t (*Get_cnt)(pTHX_ PerlIO *f);
void (*Set_ptrcnt)(pTHX_ PerlIO *f,STDCHAR *ptr,SSize_t cnt);
};
স্ট্রাকটের প্রথম কয়েক সদস্য সামঞ্জস্য পরীক্ষা করার জন্য একটি ফাংশন টেবিলের আকার দেয়
স্তরের জন্য "নাম", প্রতি-দৃষ্টান্ত ডেটার জন্য "ম্যালোক" এর আকার এবং কিছু পতাকা
যা সম্পূর্ণরূপে ক্লাসের বৈশিষ্ট্য (যেমন এটি একটি বাফারিং স্তর কিনা), তারপর
ফাংশন অনুসরণ করুন যা চারটি মৌলিক গ্রুপে পড়ে:
1. খোলার এবং সেটআপ ফাংশন
2. মৌলিক IO অপারেশন
3. Stdio ক্লাস বাফারিং বিকল্প।
4. বাফারে পার্লের ঐতিহ্যবাহী "দ্রুত" অ্যাক্সেস সমর্থন করার ফাংশন।
একটি স্তরের সমস্ত ফাংশন বাস্তবায়ন করতে হবে না, তবে পুরো টেবিলটি হতে হবে
বর্তমান অপ্রয়োজনীয় স্লটগুলি NULL হতে পারে (যা কল করার সময় একটি ত্রুটি দেখা দেবে) অথবা
একটি "বেস ক্লাস" থেকে আচরণ "উত্তরাধিকারী" করতে স্টাব দিয়ে পূরণ করা যেতে পারে। এই "উত্তরাধিকার"
স্তরের সমস্ত দৃষ্টান্তের জন্য স্থির করা হয়, কিন্তু স্তরটি বেছে নেয় কোন স্টাবগুলিকে পপুলেট করতে হবে৷
টেবিল, সীমিত "একাধিক উত্তরাধিকার" সম্ভব।
প্রতি উদাহরণ উপাত্ত
প্রতি-দৃষ্টান্তের ডেটা মৌলিক PerlIOl কাঠামোর বাইরে মেমরিতে রাখা হয়, a তৈরি করে
পার্লিওল লেয়ারের কাঠামোর প্রথম সদস্য এইভাবে:
typedef struct
{
struct _PerlIO বেস; /* বেস "ক্লাস" তথ্য */
STDCHAR * buf; /* বাফারের শুরু */
STDCHAR * শেষ; /* বাফারের বৈধ অংশের সমাপ্তি */
STDCHAR * ptr; /* বাফারে বর্তমান অবস্থান */
অফ_টি posn; /* ফাইলে buf এর অফসেট */
আকার_টি বুফসিজ; /* বাফারের প্রকৃত আকার */
IV একশব্দ; /* জরুরী বাফার */
} পার্লিওবুফ;
এইভাবে (পার্লের স্কেলারগুলির জন্য) একটি পার্লিওবুফের একটি পয়েন্টারকে একটি পয়েন্টার হিসাবে বিবেচনা করা যেতে পারে
একটি পার্লিওলের কাছে।
স্তরসমূহ in কর্ম.
টেবিল পার্লিও ইউনিক্স
| |
+------------+ +---------+ +---------+
পার্লিও ->| |--->| পরবর্তী |--->| NULL |
+------------+ +---------+ +---------+
| | | বাফার | | fd |
+------------+ | | +---------+
| | +---------+
একটি সাধারণ ক্ষেত্রে স্তর স্কিমটি কীভাবে কাজ করে তা দেখানোর উপরের প্রচেষ্টা। অ্যাপ্লিকেশন এর
"PerlIO *" খোলা (বরাদ্দকৃত) হ্যান্ডেলগুলিকে প্রতিনিধিত্ব করে টেবিল(গুলি) এ একটি এন্ট্রি নির্দেশ করে। জন্য
উদাহরণ টেবিলের প্রথম তিনটি স্লট "stdin", "stdout" এবং "stderr" এর সাথে মিলে যায়।
পালাক্রমে টেবিলটি হ্যান্ডেলের জন্য বর্তমান "শীর্ষ" স্তর নির্দেশ করে - এই ক্ষেত্রে একটি
জেনেরিক বাফারিং লেয়ার "পারলিও" এর উদাহরণ। এই স্তরটি পরের দিকে নির্দেশ করে
স্তর নিচে - এই ক্ষেত্রে নিম্ন-স্তরের "ইউনিক্স" স্তর।
উপরেরটি মোটামুটিভাবে একটি "stdio" বাফারযুক্ত স্ট্রিমের সমতুল্য, তবে আরও অনেক কিছুর সাথে
নমনীয়তা:
· যদি ইউনিক্স লেভেল "রিড"/"লিখ"/"lseek" সকেটের জন্য উপযুক্ত না হয় তাহলে
"ইউনিক্স" স্তরটি একটি "সকেট" স্তর দিয়ে প্রতিস্থাপন করা যেতে পারে (খোলা সময়ে বা এমনকি গতিশীলভাবে)।
· বিভিন্ন হ্যান্ডেলের বিভিন্ন বাফারিং স্কিম থাকতে পারে। "শীর্ষ" স্তর হতে পারে
"mmap" লেয়ার যদি "রিড" এর চেয়ে "mmap" ব্যবহার করে ডিস্ক ফাইলগুলি পড়া দ্রুত হয়। একটি
"আনবাফারড" স্ট্রীমটি কেবল একটি বাফার স্তর না রেখে প্রয়োগ করা যেতে পারে।
· ডেটা প্রবাহিত হওয়ার সাথে সাথে এটি প্রক্রিয়া করার জন্য অতিরিক্ত স্তরগুলি সন্নিবেশ করা যেতে পারে। এই ছিল
পার্ল 5.7.0+-এ স্কিমটি অন্তর্ভুক্ত করার জন্য ড্রাইভিং প্রয়োজন - অনুমতি দেওয়ার জন্য আমাদের একটি প্রক্রিয়া প্রয়োজন
পার্লের অভ্যন্তরীণ এনকোডিংয়ের মধ্যে অনুবাদ করা ডেটা (ধারণাগতভাবে অন্তত ইউনিকোড
UTF-8 হিসাবে), এবং সিস্টেম দ্বারা ব্যবহৃত "নেটিভ" বিন্যাস। এই দ্বারা প্রদান করা হয়
":এনকোডিং(xxxx)" স্তর যা সাধারণত বাফারিং স্তরের উপরে থাকে।
· একটি স্তর যোগ করা যেতে পারে যা "\n" করে CRLF অনুবাদে। এই স্তরটি যে কোনও ক্ষেত্রে ব্যবহার করা যেতে পারে
প্ল্যাটফর্ম, শুধুমাত্র যারা সাধারণত এই ধরনের জিনিস না.
প্রতি উদাহরণ পতাকা বিট
জেনেরিক ফ্ল্যাগ বিটগুলি মোড স্ট্রিং থেকে প্রাপ্ত "O_XXXXXXX" স্টাইলের পতাকার একটি সংকর
"PerlIO_open()"-এ পাস করা হয়েছে, এবং সাধারণ বাফার স্তরগুলির জন্য স্টেট বিট।
PERLIO_F_EOF
ফাইলের শেষ।
PERLIO_F_CANWRITE
লেখার অনুমতি আছে, যেমন "w" বা "r+" বা "a" ইত্যাদি হিসাবে খোলা।
PERLIO_F_CANREAD
পড়ার অনুমতি রয়েছে যেমন খোলা "r" বা "w+" (বা এমনকি "a+" - ick)।
PERLIO_F_ERROR
একটি ত্রুটি ঘটেছে ("PerlIO_error()" এর জন্য)।
PERLIO_F_TRUNCATE
খোলা মোড দ্বারা প্রস্তাবিত ফাইল ছেঁটে দিন।
PERLIO_F_APPEND
সব লেখাই সংযুক্ত করা উচিত।
PERLIO_F_CRLF
লেয়ারটি Win32-এর মতো কাজ করছে "\n" আউটপুটের জন্য CR,LF এ ম্যাপ করা হয়েছে এবং CR,LF এর সাথে ম্যাপ করা হয়েছে
ইনপুটের জন্য "\n"। সাধারণত প্রদত্ত "crlf" স্তরটিই একমাত্র স্তর যা বিরক্ত করা প্রয়োজন
এই সম্পর্কে. "PerlIO_binmode()" স্তরগুলি যোগ/সরানোর পরিবর্তে এই পতাকার সাথে বিশৃঙ্খলা করবে
যদি "PERLIO_K_CANCRLF" বিট লেয়ার ক্লাসের জন্য সেট করা থাকে।
PERLIO_F_UTF8
এই স্তরে লেখা ডেটা UTF-8 এনকোড করা উচিত; এই স্তর দ্বারা প্রদত্ত তথ্য উচিত
UTF-8 এনকোডেড হিসাবে বিবেচিত হবে। ": utf8" ডামি লেয়ার দ্বারা যেকোনো স্তরে সেট করা যেতে পারে। এছাড়াও সেট
":এনকোডিং" স্তরে।
PERLIO_F_UNBUF
স্তরটি আনবাফার করা হয়েছে - অর্থাৎ প্রতিটি লেখার জন্য পরবর্তী স্তরে লিখতে হবে
এই স্তর।
PERLIO_F_WRBUF
এই স্তরের জন্য বাফার বর্তমানে এটিতে লেখা ডেটা ধারণ করে কিন্তু পরবর্তীতে পাঠানো হয় না
স্তর।
PERLIO_F_RDBUF
এই স্তরের জন্য বাফার বর্তমানে নীচের স্তর থেকে পড়া অব্যবহৃত ডেটা ধারণ করে৷
PERLIO_F_LINEBUF
স্তর লাইন বাফার হয়. যখনই একটি "\n" লেখার ডেটা পরবর্তী স্তরে পাঠানো উচিত
দেখা যাচ্ছে. "\n" এর বাইরের যেকোন ডেটা তারপর প্রক্রিয়া করা উচিত৷
PERLIO_F_TEMP
ফাইলটি "আনলিঙ্ক()" এড করা হয়েছে, বা "close()" এ মুছে ফেলা উচিত।
PERLIO_F_OPEN
হাতল খোলা।
PERLIO_F_FASTGETS
এই স্তরের এই উদাহরণটি "দ্রুত "গেট" ইন্টারফেস সমর্থন করে। সাধারণত সেট ভিত্তিক
ক্লাসের জন্য "PERLIO_K_FASTGETS" তে এবং ফাংশন(গুলি) এর অস্তিত্ব দ্বারা
টেবিল যাইহোক একটি শ্রেণী যা সাধারণত সেই ইন্টারফেস প্রদান করে সেটিকে এ এড়াতে হবে
নির্দিষ্ট উদাহরণস্বরূপ. "মুলতুবি" স্তরটিকে এটি করতে হবে যখন এটি a উপরে ঠেলে দেওয়া হয়
স্তর যা ইন্টারফেস সমর্থন করে না। (পার্লের "sv_gets()" আশা করে না
স্ট্রীম দ্রুত "গেট" আচরণ পরিবর্তন একটি "পেতে" সময়.)
পদ্ধতি in বিস্তারিত
fsize
আকার_টি fsize;
ফাংশন টেবিলের আকার। এটি PerlIO কোড "জানে" মানের সাথে তুলনা করা হয়
একটি সামঞ্জস্য পরীক্ষা। ভবিষ্যতের সংস্করণ may বিরুদ্ধে সংকলিত স্তর সহ্য করতে সক্ষম হবেন
হেডারগুলির একটি পুরানো সংস্করণ।
নাম
char * নাম;
লেয়ারটির নাম যার খোলা () পদ্ধতি পার্ল চালু করা উচিত খোলা ()। উদাহরণ স্বরূপ
যদি স্তরটিকে APR বলা হয়, আপনি কল করবেন:
খোলা $fh, ">:এপিআর", ...
এবং পার্ল জানে যে এটিকে আহ্বান করতে হবে PerlIOAPR_open() দ্বারা বাস্তবায়িত পদ্ধতি
এপিআর স্তর।
আয়তন
Size_t আকার;
প্রতি-ইনস্ট্যান্স ডেটা স্ট্রাকচারের আকার, যেমন:
সাইজফ(পার্লিওএপিআর)
যদি এই ক্ষেত্রটি শূন্য হয় তবে "PerlIO_pushed" কিছু ম্যালোক করে না এবং ধরে নেয়
লেয়ারের পুশড ফাংশন যেকোনো প্রয়োজনীয় লেয়ার স্ট্যাক ম্যানিপুলেশন করবে - এড়ানোর জন্য ব্যবহৃত হয়
ডামি স্তরগুলির জন্য malloc/ফ্রি ওভারহেড। যদি ক্ষেত্রটি অ-শূন্য হয় তবে এটি কমপক্ষে হতে হবে
"PerlIOl", "PerlIO_pushed" এর আকার স্তরের ডেটার জন্য মেমরি বরাদ্দ করবে
কাঠামো এবং স্ট্রীমের স্ট্যাকের সাথে নতুন স্তর লিঙ্ক করুন। (যদি লেয়ারের Pushed পদ্ধতি
একটি ত্রুটি ইঙ্গিত দেয় যে স্তরটি আবার পপ করা হয়েছে।)
রকম
IV ধরনের;
· PERLIO_K_BUFFERED
স্তর বাফার হয়.
PERLIO_K_RAW
স্তরটি বিনমোড(FH) স্ট্যাকে থাকা গ্রহণযোগ্য - যেমন এটি করে না (বা করবে
এটির মধ্য দিয়ে যাওয়া বাইটগুলিকে রূপান্তর না করার জন্য নিজেকে কনফিগার করুন।
· PERLIO_K_CANCRLF
স্তর "\n" এবং CRLF লাইন শেষের মধ্যে অনুবাদ করতে পারে।
PERLIO_K_FASTGETS
স্তর বাফার স্নুপিং অনুমতি দেয়.
· PERLIO_K_MULTIARG
স্তর যখন ব্যবহার করা হয় খোলা () স্বাভাবিকের চেয়ে বেশি যুক্তি গ্রহণ করে। অতিরিক্ত
আর্গুমেন্ট "MODE" আর্গুমেন্টের আগে না আসা উচিত। যখন এই পতাকা ব্যবহার করা হয় এটা
আর্গস যাচাই করতে স্তর পর্যন্ত।
ধাক্কা
IV (*পুশড)(pTHX_ PerlIO *f,const char *মোড, SV *arg);
একমাত্র একেবারে বাধ্যতামূলক পদ্ধতি। যখন স্তরটিকে স্ট্যাকের উপর ঠেলে দেওয়া হয় তখন বলা হয়।
"মোড" আর্গুমেন্টটি শূন্য হতে পারে যদি এটি পোস্ট-ওপেন হয়। "আর্গ" হবে অ-"NULL"
যদি একটি আর্গুমেন্ট স্ট্রিং পাস করা হয়। বেশিরভাগ ক্ষেত্রে এটি "PerlIOBase_pushed()" কল করা উচিত
যেকোনো একটি ছাড়াও "মোড" কে উপযুক্ত "PERLIO_F_XXXXX" পতাকায় রূপান্তর করতে
লেয়ার নিজেই ক্রিয়া করে। একটি স্তর একটি আর্গুমেন্ট আশা না হলে এটি প্রয়োজন
এটিতে পাস করাকে সংরক্ষণ করবেন না বা "Getarg()" প্রদান করবেন না (এটি হতে পারে
"Perl_warn" যে যুক্তিটি অপ্রত্যাশিত ছিল)।
সাফল্যে 0 ফেরত দেয়। ব্যর্থ হলে -1 রিটার্ন এবং errno সেট করা উচিত।
popped
IV (*পপড)(pTHX_ PerlIO *f);
যখন স্তরটি স্ট্যাক থেকে পপ করা হয় তখন বলা হয়। একটি স্তর সাধারণত পরে পপ করা হবে
"ক্লোজ()" বলা হয়। কিন্তু প্রোগ্রামটি বন্ধ না করে একটি স্তর পপ করা যেতে পারে
গতিশীলভাবে স্ট্রীমের স্তরগুলি পরিচালনা করা। এই ধরনের ক্ষেত্রে "Popped()" যেকোনও মুক্ত করা উচিত
সম্পদ (বাফার, অনুবাদ টেবিল, ...) সরাসরি স্তরের কাঠামোতে রাখা হয় না।
এটি থেকে পড়া এবং বাফার করা হয়েছে এমন কোনও অব্যবহৃত ডেটা "অপঠিত()" হওয়া উচিত
নীচের স্তরটি সেই স্তরে ফিরে যান, যাতে এটি এখন যা আছে তা পুনরায় সরবরাহ করা যেতে পারে
উপরে।
সাফল্য এবং ব্যর্থতার উপর 0 প্রদান করে। যদি "Popped()" ফিরে আসে সত্য তারপর perlio.c অনুমান
যে হয় স্তরটি নিজেই পপ করেছে, অথবা স্তরটি অত্যন্ত বিশেষ এবং হওয়া দরকার
অন্যান্য কারণে রাখা হয়েছে। বেশিরভাগ ক্ষেত্রে এটি ফিরে আসা উচিত মিথ্যা.
খোলা
পার্লিও * (*খোলা)(...);
"ওপেন()" পদ্ধতিতে প্রচুর আর্গুমেন্ট রয়েছে কারণ এটি পার্লের ফাংশনগুলিকে একত্রিত করে
"খোলা", "PerlIO_open", perl's "sysopen", "PerlIO_fdopen" এবং "PerlIO_reopen"। দ্য
সম্পূর্ণ প্রোটোটাইপ নিম্নরূপ:
PerlIO * (*খোলা)(pTHX_ PerlIO_funcs *ট্যাব,
PerlIO_list_t *স্তর, IV n,
const char *মোড,
int fd, int imode, int perm,
পার্লিও *পুরনো,
int narg, SV **args);
খোলার (সম্ভবত পরোক্ষভাবে) একটি স্লট বরাদ্দ করতে "PerlIO_allocate()" কল করা উচিত
টেবিল এবং কল করে খোলা ফাইলের জন্য স্তর তথ্যের সাথে এটি সংযুক্ত করুন
"পার্লিও_পুশ"। দ্য স্তর "PerlIO *" এর জন্য নির্ধারিত সমস্ত স্তরের একটি অ্যারে।
এবং কোন যুক্তি তাদের কাছে চলে গেছে, n স্তর হচ্ছে যে অ্যারের মধ্যে সূচক
ডাকা ম্যাক্রো "PerlIOArg" যুক্তির জন্য একটি (সম্ভবত "NULL") SV * প্রদান করবে
স্তর পাস.
সার্জারির মোড স্ট্রিং হল একটি ""fopen()"-এর মতো" স্ট্রিং যা রেগুলার এক্সপ্রেশনের সাথে মেলে
"/^[I#]?[rwa]\+?[bt]?$/"।
বিশেষের মাধ্যমে "stdin"."stderr" তৈরির সময় 'I' উপসর্গটি ব্যবহৃত হয়
"PerlIO_fdopen" কল; '#' উপসর্গের অর্থ হল এটি "sysopen" এবং এটি ইমোড এবং
স্থায়ী ঢেউ তোলা "PerlLIO_open3" এ পাস করা উচিত; 'r' মানে read, 'w' মানে wআচার এবং 'ক'
মানে append '+' প্রত্যয় মানে পড়া এবং লেখা/সংযোজন উভয়ই
অনুমোদিত 'b' প্রত্যয় মানে ফাইলটি বাইনারি হওয়া উচিত, এবং 't' মানে এটি পাঠ্য।
(প্রায় সব স্তরেরই বাইনারি মোডে IO করা উচিত এবং b/t বিটগুলিকে উপেক্ষা করা উচিত।
পার্থক্য পরিচালনা করতে ":crlf" স্তরটি চাপতে হবে।)
If পুরাতন "NULL" নয় তাহলে এটি একটি "PerlIO_reopen"। পার্ল নিজেই এটি ব্যবহার করে না
(এখনও?) এবং শব্দার্থবিদ্যা একটু অস্পষ্ট।
If fd নেতিবাচক নয় তাহলে এটি সংখ্যাসূচক ফাইল বর্ণনাকারী fd, যা একটি এ খোলা হবে
সরবরাহকৃত মোড স্ট্রিংয়ের সাথে সামঞ্জস্যপূর্ণ পদ্ধতি, কলটি এইভাবে সমতুল্য
"PerlIO_fdopen"। এক্ষেত্রে নার্গস শূন্য হবে।
If নার্গস শূন্যের চেয়ে বড় হলে এটি "খোলা" এ পাস করা আর্গুমেন্টের সংখ্যা দেয়
অন্যথায় এটি 1 হবে যদি উদাহরণস্বরূপ "PerlIO_open" বলা হয়। সহজ ক্ষেত্রে
SvPV_nolen(*args) হল খোলার পাথনাম।
যদি একটি স্তর "ওপেন()" সরবরাহ করে তবে এটি সাধারণত পরবর্তী স্তরের "ওপেন()" পদ্ধতিকে কল করা উচিত
নিচে (যদি থাকে) এবং তারপর নিজেকে উপরে ধাক্কা যদি এটি সফল হয়। "PerlIOBase_open" হল
ঠিক এটি করার জন্য প্রদান করা হয়েছে, তাই বেশিরভাগ ক্ষেত্রে আপনাকে নিজের লিখতে হবে না
"ওপেন()" পদ্ধতি। এই পদ্ধতি সংজ্ঞায়িত না হলে, অন্যান্য স্তর অসুবিধা হতে পারে
খোলা সময় এটি উপরে নিজেদের ঠেলাঠেলি.
যদি "PerlIO_push" সঞ্চালিত হয় এবং খোলা ব্যর্থ হয়, তাহলে এটি অবশ্যই "PerlIO_pop" হবে, যেহেতু
যদি এটি না হয়, স্তরটি সরানো হবে না এবং খারাপ সমস্যা হতে পারে।
ব্যর্থ হলে "NULL" ফেরত দেয়।
বিনমোড
IV (*বিনমোড)(pTHX_ PerlIO *f);
ঐচ্ছিক। ব্যবহার করা হয় যখন ":raw" স্তরটি পুশ করা হয় (স্পষ্টভাবে বা বিনমোড(FH) এর ফলে)।
উপস্থিত না হলে স্তর পপ করা হবে। উপস্থিত থাকলে বাইনারি হিসাবে স্তর কনফিগার করা উচিত (বা
পপ নিজেই) এবং 0 রিটার্ন করুন। যদি এটি ত্রুটির জন্য -1 রিটার্ন করে তবে "বিনমোড" লেয়ারের সাথে ব্যর্থ হবে
স্ট্যাকের উপর এখনও.
গেটার্গ
SV * (*Getarg)(pTHX_ PerlIO *f,
CLONE_PARAMS *param, int পতাকা);
ঐচ্ছিক। যদি উপস্থিত থাকে তাহলে একটি SV * ফেরত দিতে হবে যাতে পাস করা স্ট্রিং আর্গুমেন্টের প্রতিনিধিত্ব করে
স্তর যখন এটি ধাক্কা ছিল. যেমন ":এনকোডিং(ascii)" মান সহ একটি SvPV প্রদান করবে
"ascii"। (পরম এবং পতাকা বেশিরভাগ ক্ষেত্রে যুক্তি উপেক্ষা করা যেতে পারে)
"Dup" "Getarg" ব্যবহার করে আর্গুমেন্ট পুনরুদ্ধার করতে মূলত "Pushed"-এ পাস করা হয়েছে, তাই আপনি
এই ফাংশনটি অবশ্যই বাস্তবায়ন করতে হবে যদি আপনার লেয়ারে "Pushed" এর জন্য অতিরিক্ত যুক্তি থাকে এবং হবে
কখনও "Dup"ed হতে.
নথি নম্বর
IV (*ফাইলেনো)(pTHX_ PerlIO *f);
হ্যান্ডেলের জন্য ইউনিক্স/পসিক্স সাংখ্যিক ফাইল বর্ণনাকারী প্রদান করে। সাধারনত
"PerlIOBase_fileno()" (যা শুধু পরবর্তী স্তর নিচে জিজ্ঞাসা করে) এর জন্য যথেষ্ট হবে।
ত্রুটির উপর -1 রিটার্ন করে, যেখানে লেয়ারটি সম্ভব নয় এমন ক্ষেত্রে অন্তর্ভুক্ত বলে বিবেচিত হয়
এই ধরনের একটি ফাইল বর্ণনা প্রদান করুন।
DUP
PerlIO * (*Dup)(pTHX_ PerlIO *f, PerlIO *o,
CLONE_PARAMS *param, int পতাকা);
XXX: আরও নথির প্রয়োজন৷
"ক্লোন" প্রক্রিয়ার অংশ হিসাবে ব্যবহৃত হয় যখন একটি থ্রেড তৈরি হয় (যে ক্ষেত্রে প্যারাম হবে
নন-নাল হবে) এবং যখন একটি স্ট্রীম "ওপেন" এ '&' এর মাধ্যমে নকল করা হচ্ছে।
"ওপেন" এর অনুরূপ, সাফল্যে PerlIO* ফেরত দেয়, ব্যর্থ হলে "NULL" দেয়।
পড়া
SSize_t (*পড়ুন)(pTHX_ PerlIO *f, void *vbuf, Size_t গণনা);
বেসিক রিড অপারেশন।
সাধারণত "ফিল" কল করবে এবং পয়েন্টারগুলিকে ম্যানিপুলেট করবে (সম্ভবত API এর মাধ্যমে)।
"PerlIOBuf_read()" প্রাপ্ত ক্লাসগুলির জন্য উপযুক্ত হতে পারে যা "দ্রুত লাভ" প্রদান করে
পদ্ধতি।
প্রকৃত বাইট রিটার্ন করে, অথবা একটি ত্রুটিতে -1।
অপঠিত
SSize_t (*অপঠিত)(pTHX_ PerlIO *f,
const void *vbuf, Size_t গণনা);
stdio এর "ungetc()" এর একটি সুপারসেট। বাইট দেখতে ভবিষ্যতে পড়ার জন্য ব্যবস্থা করা উচিত
"vbuf"। যদি স্পষ্টতই ভাল বাস্তবায়ন না থাকে তাহলে "PerlIOBase_unread()"
কলিং স্তরের উপরে একটি "জাল" "মুলতুবি" স্তর ঠেলে ফাংশন প্রদান করে।
অপঠিত অক্ষরের সংখ্যা প্রদান করে।
লেখা
SSize_t (*লিখুন)(PerlIO *f, const void *vbuf, Size_t গণনা);
মৌলিক লেখার অপারেশন।
একটি ত্রুটির উপর লিখিত বাইট বা -1 প্রদান করে।
খোঁজ
IV (*Seek)(pTHX_ PerlIO *f, Off_t অফসেট, int কোথা থেকে);
ফাইল পয়েন্টার অবস্থান করুন। সাধারণত তার নিজস্ব "ফ্লাশ" পদ্ধতি কল করা উচিত এবং তারপর
নিচের পরবর্তী স্তরের "অনুসন্ধান" পদ্ধতি।
সাফল্যের উপর 0, ব্যর্থতার উপর -1 প্রদান করে।
বলা
অফ_টি (*বলুন)(pTHX_ PerlIO *f);
ফাইল পয়েন্টার ফেরত দিন। এড়ানোর জন্য অবস্থানের ক্যাশে ধারণা স্তরের উপর ভিত্তি করে হতে পারে
উপরি
ফাইল পয়েন্টার পেতে ব্যর্থ হলে -1 রিটার্ন করে।
ঘনিষ্ঠ
IV (*বন্ধ)(pTHX_ PerlIO *f);
প্রবাহ বন্ধ করুন। নিজেকে ফ্লাশ করতে এবং বন্ধ করতে সাধারণত "PerlIOBase_close()" কল করা উচিত
নীচের স্তরগুলি, এবং তারপরে যেকোন ডেটা স্ট্রাকচার ডিলোকেট করুন (বাফার, অনুবাদ টেবিল,
...) ডাটা স্ট্রাকচারে সরাসরি রাখা হয় না।
সাফল্যের উপর 0, ব্যর্থতার উপর -1 প্রদান করে।
ঘনিষ্ঠরূপে
IV (*ফ্লাশ)(pTHX_ PerlIO *f);
নীচের স্তরগুলির সাথে স্ট্রিমের অবস্থা সামঞ্জস্যপূর্ণ করা উচিত। অর্থাৎ যেকোনো বাফার করা লেখা
ডেটা লেখা উচিত, এবং নিম্ন স্তরের ফাইলের অবস্থান থেকে ডেটা পড়ার জন্য সামঞ্জস্য করা উচিত
নীচে কিন্তু আসলে গ্রাস করা হয় না। (সম্ভবত "অপঠিত()" এই ধরনের ডেটা নিম্নতর হওয়া উচিত
স্তর।)
সাফল্যের উপর 0, ব্যর্থতার উপর -1 প্রদান করে।
পূরণ করা
IV (*ফিল)(pTHX_ PerlIO *f);
এই স্তরটির জন্য বাফারটি নীচের স্তর থেকে (পড়ার জন্য) পূরণ করা উচিত। যখন তুমি
"সাবক্লাস" PerlIOBuf স্তর, আপনি এটি ব্যবহার করতে চান _পড়া পদ্ধতি এবং আপনার নিজস্ব সরবরাহ
পূরণ পদ্ধতি, যা PerlIOBuf এর বাফার পূরণ করে।
সাফল্যের উপর 0, ব্যর্থতার উপর -1 প্রদান করে।
ইওফ
IV (*Eof)(pTHX_ PerlIO *f);
ফাইলের শেষ সূচক রিটার্ন করুন। "PerlIOBase_eof()" সাধারণত যথেষ্ট।
ফাইলের শেষে 0, ফাইলের শেষ না হলে 1, ত্রুটিতে -1 ফেরত দেয়।
ভুল
IV (*ত্রুটি)(pTHX_ PerlIO *f);
ত্রুটি সূচক রিটার্ন. "PerlIOBase_error()" সাধারণত যথেষ্ট।
কোনো ত্রুটি থাকলে 1 ফেরত দেয় (সাধারণত যখন "PERLIO_F_ERROR" সেট করা হয়), অন্যথায় 0।
ক্লিয়ারর
অকার্যকর (*ক্লিয়ারার)(pTHX_ PerlIO *f);
ফাইলের শেষ এবং ত্রুটি সূচকগুলি পরিষ্কার করুন। সেট করতে "PerlIOBase_clearerr()" কল করা উচিত
"PERLIO_F_XXXXXX" পতাকা, যা যথেষ্ট হতে পারে৷
সেটলাইনবাফ
void (*Setlinebuf)(pTHX_ PerlIO *f);
স্ট্রীমটিকে লাইন বাফার হিসাবে চিহ্নিত করুন৷ "PerlIOBase_setlinebuf()" PERLIO_F_LINEBUF সেট করে
পতাকা এবং সাধারণত যথেষ্ট।
Get_base
STDCHAR * (*Get_base)(pTHX_ PerlIO *f);
এই লেয়ারের জন্য রিড বাফার বরাদ্দ করুন (যদি ইতিমধ্যেই না করা হয়ে থাকে) এবং পয়েন্টারটিতে ফিরে যান
এটা ব্যর্থ হলে NULL ফেরত দিন।
Get_bufsiz
আকার_টি (*Get_bufsiz)(pTHX_ PerlIO *f);
বাফারে রাখা শেষ "Fill()" বাইটের সংখ্যা ফেরত দিন।
Get_ptr
STDCHAR * (*Get_ptr)(pTHX_ PerlIO *f);
এই স্তরের বাফারের সাথে সম্পর্কিত বর্তমান পঠিত পয়েন্টারটি ফেরত দিন।
Get_cnt
SSize_t (*Get_cnt)(pTHX_ PerlIO *f);
বর্তমান বাফারে পড়তে বাকি বাইটের সংখ্যা ফেরত দিন।
সেট_ptrcnt
অকার্যকর (*Set_ptrcnt)(pTHX_ PerlIO *f,
STDCHAR *ptr, SSize_t cnt);
"ptr" এবং/অথবা "cnt" এর সাথে মেলানোর জন্য রিড পয়েন্টার এবং বাইটের গণনা সামঞ্জস্য করুন। দ্য
অ্যাপ্লিকেশন (বা উপরের স্তর) নিশ্চিত করতে হবে যে তারা সামঞ্জস্যপূর্ণ। (এর দ্বারা চেক করা অনুমোদিত
প্যারানয়েড।)
ইউটিলিটিস
পরবর্তী স্তরের জন্য জিজ্ঞাসা করতে PerlIONext(PerlIO *f) ব্যবহার করুন।
একটি PerlIO* বৈধ কিনা তা পরীক্ষা করতে PerlIOValid(PerlIO *f) ব্যবহার করুন। (এই সব সত্যিই হয়
পয়েন্টারটি নন-নাল এবং এর পিছনের পয়েন্টারটি নন-নাল তা পরীক্ষা করার জন্য।)
PerlIOBase(PerlIO *f) "বেস" পয়েন্টার প্রদান করে, বা অন্য কথায়, "PerlIOl*"
পয়েন্টার
PerlIOSelf(PerlIO* f, টাইপ) পার্লিওবেস কাস্টকে একটি টাইপে ফেরত দেয়।
Perl_PerlIO_or_Base(PerlIO* f, কলব্যাক, বেস, ব্যর্থতা, args) হয় কল করে কলব্যাক
স্তরের ফাংশন থেকে f (শুধু IO ফাংশনের নামে, যেমন "পড়ুন") সহ
দ্য args, অথবা এই ধরনের কোন কলব্যাক না থাকলে, কল করে ভিত্তি সাথে কলব্যাকের সংস্করণ
একই args, অথবা f অবৈধ হলে, EBADF-এ errno সেট করুন এবং রিটার্ন করুন ব্যর্থতা.
Perl_PerlIO_or_fail(PerlIO* f, কলব্যাক, ব্যর্থতা, args) হয় কল করে কলব্যাক এর
স্তরের ফাংশন f সাথে args, অথবা যদি এমন কোন কলব্যাক না থাকে, তাহলে errno সেট করুন
EINVAL অথবা যদি f অবৈধ হয়, EBADF এ errno সেট করুন এবং ফিরে আসুন ব্যর্থতা.
Perl_PerlIO_or_Base_void(PerlIO* f, কলব্যাক, বেস, args) হয় কল করে কলব্যাক এর
স্তরের ফাংশন f সাথে args, অথবা এই ধরনের কোন কলব্যাক না থাকলে, কল করে ভিত্তি
একই args সহ কলব্যাকের সংস্করণ, অথবা যদি f অবৈধ হয়, EBADF এ ত্রুটি সেট করুন।
Perl_PerlIO_or_fail_void(PerlIO* f, কলব্যাক, args) হয় কল করে কলব্যাক এর
স্তরের ফাংশন f সাথে args, অথবা যদি এমন কোন কলব্যাক না থাকে, তাহলে errno সেট করুন
EINVAL অথবা যদি f অবৈধ হয়, EBADF এ errno সেট করুন।
বাস্তবায়নকারী পার্লিও স্তরসমূহ
আপনি যদি বাস্তবায়নের নথিটি অস্পষ্ট বা পর্যাপ্ত না পান তবে বিদ্যমানটি দেখুন
PerlIO স্তর বাস্তবায়ন, যার মধ্যে রয়েছে:
· সি বাস্তবায়ন
সার্জারির perlio.c এবং perliol.h পার্ল কোরে "ইউনিক্স", "পারলিও", "stdio" প্রয়োগ করুন
"crlf", "utf8", "byte", "raw", "পেন্ডিং" লেয়ার এবং এছাড়াও "mmap" এবং "win32"
প্রযোজ্য হলে স্তর। ("win32" বর্তমানে অসমাপ্ত এবং অব্যবহৃত, কি তা দেখতে
Win32 এর পরিবর্তে ব্যবহার করা হয়েছে, পার্লিওতে "ফাইলহ্যান্ডেলের স্তরগুলি জিজ্ঞাসা করা" দেখুন।)
PerlIO::encoding, PerlIO::scalar, PerlIO::via পার্ল কোরে।
CPAN-এ PerlIO::gzip এবং APR::PerlIO (mod_perl 2.0)।
· পার্ল বাস্তবায়ন
PerlIO::via::CPAN-এ পার্ল কোরে এবং PerlIO::via::* উদ্ধৃত প্রিন্ট।
আপনি যদি একটি PerlIO স্তর তৈরি করেন, তাহলে আপনি অলস হতে চাইতে পারেন, অন্য কথায়, প্রয়োগ করুন
শুধুমাত্র আপনার আগ্রহের পদ্ধতি। অন্যান্য পদ্ধতি আপনি হয় সঙ্গে প্রতিস্থাপন করতে পারেন
"ফাঁকা" পদ্ধতি
PerlIOBase_noop_ok
PerlIOBase_noop_fail
(যা কিছু করে না, এবং যথাক্রমে শূন্য এবং -1 ফেরত দেয়) বা নির্দিষ্ট পদ্ধতির জন্য আপনি করতে পারেন
একটি NULL পদ্ধতি ব্যবহার করে একটি ডিফল্ট আচরণ অনুমান করুন। ওপেন পদ্ধতি সাহায্যের জন্য দেখায়
'অভিভাবক' স্তর। নিম্নলিখিত সারণী আচরণ সংক্ষিপ্ত করে:
NULL এর সাথে পদ্ধতির আচরণ
Clearerr PerlIOBase_clearerr
PerlIOBase_close বন্ধ করুন
ডুপ PerlIOBase_dup
Eof PerlIOBase_eof
ত্রুটি PerlIOBase_error
Fileno PerlIOBase_fileno
FAILURE পূরণ করুন
ফ্লাশ SUCCESS
সফলতা অর্জন করুন
Get_base FAILURE
ব্যর্থতা পান
Get_cnt FAILURE
Get_ptr FAILURE
ইনহেরিটেড খুলুন
পপড সাফল্য
ধাক্কা সাফল্য
PerlIOBase_read পড়ুন
ব্যর্থতার সন্ধান করুন
Set_cnt FAILURE
সেট_ptrcnt ব্যর্থতা
Setlinebuf PerlIOBase_setlinebuf
FAILURE বলুন
অপঠিত PerlIOBase_unread
ব্যর্থতা লিখুন
ব্যর্থতা ত্রুটি সেট করুন (ইউনিক্সিশে EINVAL, VMS-এ LIB$_INVARG) এবং
রিটার্ন -1 (সাংখ্যিক রিটার্ন মানের জন্য) বা NULL (পয়েন্টারের জন্য)
নীচের স্তর থেকে উত্তরাধিকারসূত্রে প্রাপ্ত
সাকসেস রিটার্ন 0 (সাংখ্যিক রিটার্ন মানের জন্য) বা একটি পয়েন্টার
মূল স্তরসমূহ
"perlio.c" ফাইলটি নিম্নলিখিত স্তরগুলি সরবরাহ করে:
"ইউনিক্স"
একটি মৌলিক নন-বাফার লেয়ার যা ইউনিক্স/পোসিক্সকে "রিড()", "লিখন()", "lseek()",
"close()"। কোন বাফারিং. এমনকি প্ল্যাটফর্মগুলিতেও যেগুলি O_TEXT এবং এর মধ্যে পার্থক্য করে৷
O_BINARY এই স্তরটি সর্বদা O_BINARY হয়।
"পেরলিও"
একটি খুব সম্পূর্ণ জেনেরিক বাফারিং স্তর যা সমগ্র PerlIO API প্রদান করে। এইটা
এছাড়াও অন্যান্য স্তরগুলির জন্য একটি "বেস ক্লাস" হিসাবে ব্যবহার করার উদ্দেশ্যে। (উদাহরণস্বরূপ এটি "Read()"
পদ্ধতিটি "Get_cnt()"/"Get_ptr()"/"Set_ptrcnt()" পদ্ধতির পরিপ্রেক্ষিতে প্রয়োগ করা হয়)।
"ইউনিক্স" এর উপর "পারলিও" স্ট্যাডিওর জন্য একটি সম্পূর্ণ প্রতিস্থাপন প্রদান করে যা PerlIO API এর মাধ্যমে দেখা যায়।
এটি USE_PERLIO-এর জন্য ডিফল্ট যখন সিস্টেমের stdio পার্লের "দ্রুত" অনুমতি দেয় না
অ্যাক্সেস পায়, এবং যা "O_TEXT" এবং "O_BINARY" এর মধ্যে পার্থক্য করে না।
"stdio"
একটি স্তর যা লেয়ার স্কিমের মাধ্যমে PerlIO API প্রদান করে, কিন্তু এটি প্রয়োগ করে
কলিং সিস্টেমের stdio. সিস্টেমের stdio প্রদান করলে এটি (বর্তমানে) ডিফল্ট
পার্লের "ফাস্ট গেটস" অ্যাক্সেসের অনুমতি দেওয়ার জন্য পর্যাপ্ত অ্যাক্সেস এবং যা পার্থক্য করে না
"O_TEXT" এবং "O_BINARY" এর মধ্যে৷
"crlf"
একটি স্তর একটি বেস ক্লাস হিসাবে "perlio" ব্যবহার করে প্রাপ্ত. এটি CR,LF কে Win32-এর মত "\n" প্রদান করে
অনুবাদ হয় "পারলিও" এর উপরে প্রয়োগ করা যেতে পারে বা বাফার স্তর হিসাবে পরিবেশন করা যেতে পারে।
সিস্টেম "O_TEXT" এবং এর মধ্যে পার্থক্য করলে "unix" এর উপর "crlf" ডিফল্ট হয়
"O_BINARY" খোলে। (কিছু সময়ে "unix" একটি "নেটিভ" Win32 IO স্তর দ্বারা প্রতিস্থাপিত হবে
সেই প্ল্যাটফর্মে, যেহেতু Win32-এর রিড/রাইট লেয়ারের বিভিন্ন ত্রুটি রয়েছে।) "crlf" লেয়ার
একটি স্তরের জন্য একটি যুক্তিসঙ্গত মডেল যা কিছু উপায়ে ডেটা রূপান্তরিত করে।
"mmap"
কনফিগার যদি "mmap()" ফাংশন সনাক্ত করে তবে এই স্তরটি প্রদান করা হয় ("perlio" হিসাবে একটি
"বেস") যা দ্বারা "পড়ুন" অপারেশন করে mmap()ফাইল ing. কর্মক্ষমতা উন্নতি হয়
আধুনিক সিস্টেমে প্রান্তিক, তাই এটি মূলত ধারণার প্রমাণ হিসাবে রয়েছে। এটা দেখতে
কিছু সময়ে মূল থেকে unbundled করা. "mmap" স্তরটি একটি যুক্তিসঙ্গত মডেল
একটি ন্যূনতম "উত্পন্ন" স্তরের জন্য।
"বিচারাধীন"
"পারলিও" এর একটি "অভ্যন্তরীণ" ডেরিভেটিভ যা প্রদান করতে ব্যবহার করা যেতে পারে অপঠিত() ক্রিয়া
স্তরগুলির জন্য যার কোনও বাফার নেই বা বিরক্ত করা যায় না। (মূলত এই স্তরের
"ফিল()" স্ট্যাক থেকে নিজেকে পপ করে এবং তাই নীচের স্তর থেকে পড়া আবার শুরু করে।)
"কাঁচা"
একটি ডামি লেয়ার যা লেয়ার স্ট্যাকে কখনোই বিদ্যমান থাকে না। পরিবর্তে যখন "ধাক্কা" এটা আসলে
নিজেকে অপসারণ স্ট্যাক পপ, এটি তারপর সব উপর Binmode ফাংশন টেবিল এন্ট্রি কল
স্ট্যাকের স্তরগুলি - সাধারণত এটি (PerlIOBase_binmode এর মাধ্যমে) যে কোনও স্তরকে সরিয়ে দেয়
"PERLIO_K_RAW" বিট সেট নেই। স্তরগুলি তাদের সংজ্ঞায়িত করে সেই আচরণকে সংশোধন করতে পারে
নিজস্ব বিনমোড এন্ট্রি।
"utf8"
আরেকটি ডামি লেয়ার। যখন ধাক্কা দেওয়া হয় তখন এটি নিজেই পপ করে এবং "PERLIO_F_UTF8" পতাকা সেট করে
যে স্তরটি স্ট্যাকের শীর্ষে ছিল (এবং এখন আরও একবার)।
এছাড়াও perlio.c এছাড়াও অনেকগুলি "PerlIOBase_xxxx()" ফাংশন প্রদান করে যা
ক্লাসের টেবিল স্লটে ব্যবহার করার উদ্দেশ্যে যা বিশেষ কিছু করার প্রয়োজন নেই
একটি নির্দিষ্ট পদ্ধতির জন্য।
প্রসার স্তরসমূহ
স্তরগুলি এক্সটেনশন মডিউল দ্বারা উপলব্ধ করা যেতে পারে। যখন একটি অজানা স্তর সম্মুখীন হয়
PerlIO কোড এর সমতুল্য সম্পাদন করবে:
PerlIO 'স্তর' ব্যবহার করুন;
কোথায় স্তর অজানা স্তর। PerlIO.pm তারপর চেষ্টা করবে:
PerlIO::স্তর প্রয়োজন;
যদি সেই প্রক্রিয়ার পরেও স্তরটি সংজ্ঞায়িত না হয় তবে "খোলা" ব্যর্থ হবে।
নিম্নলিখিত এক্সটেনশন স্তরগুলি পার্লের সাথে বান্ডিল করা হয়েছে:
":এনকোডিং"
এনকোডিং ব্যবহার করুন;
এই স্তর উপলব্ধ করে তোলে, যদিও PerlIO.pm "জানে" কোথায় এটি খুঁজে পেতে. এটি একটি
একটি স্তরের উদাহরণ যা একটি যুক্তি নেয় যেমন এটিকে বলা হয়:
open( $fh, "<:এনকোডিং(iso-8859-7)", $pathname );
": স্কেলার"
একটি স্কেলার থেকে ডেটা পড়া এবং ডেটা লেখার জন্য সমর্থন প্রদান করে।
খোলা ($fh, "+<:স্কলার", \$scalar);
যখন একটি হ্যান্ডেল এত খোলা হয়, তখন স্ট্রিং মান থেকে বাইট পাওয়া যায় $স্কেলার, এবং
লেখে মান পরিবর্তন. উভয় ক্ষেত্রেই অবস্থান $স্কেলার শূন্য হিসাবে শুরু হয় কিন্তু পারে
"অনুসন্ধান" এর মাধ্যমে পরিবর্তিত হবে, এবং "বলো" এর মাধ্যমে নির্ধারিত হবে।
দয়া করে নোট করুন যে কল করার সময় এই স্তরটি উহ্য থাকে৷ খোলা () এইভাবে:
খোলা ($fh, "+<", \$scalar);
": মাধ্যমে"
স্তরগুলিকে পার্ল কোড হিসাবে প্রয়োগ করার অনুমতি দেওয়ার জন্য সরবরাহ করা হয়েছে। এই ক্ষেত্রে:
PerlIO::via::StripHTML ব্যবহার করুন;
open( my $fh, "<:via(StripHTML)", "index.html" );
বিস্তারিত জানার জন্য PerlIO::via দেখুন।
করণীয়
এই নথিটি উন্নত করার জন্য যে জিনিসগুলি করা দরকার৷
ব্যাখ্যা করুন কিভাবে একটি বৈধ fh করা যায় না খোলা ()(অর্থাৎ একটি স্তর প্রয়োগ করুন)। জন্য
উদাহরণ যদি ফাইলটি পার্লের মাধ্যমে খোলা না হয়, তবে আমরা এটির মতো একটি fh ফিরে পেতে চাই
পার্ল দ্বারা খোলা হয়েছিল।
কিভাবে PerlIO_apply_layera ফিট করে, এর ডক্স কোথায়, এটি সর্বজনীন করা হয়েছিল?
বর্তমানে উদাহরণ এই মত কিছু হতে পারে:
পার্লিও *foo_to_PerlIO(pTHX_ char *মোড, ...)
{
char *মোড; /* "w", "r", ইত্যাদি */
const char *layers = ":এপিআর"; /* স্তরের নাম */
PerlIO *f = PerlIO_allocate(aTHX);
যদি (!f) {
রিটার্ন NULL;
}
PerlIO_apply_layers(aTHX_ f, মোড, স্তর);
যদি (চ) {
PerlIOAPR *st = PerlIOSelf(f, PerlIOAPR);
/* st struct পূরণ করুন, যেমন _open() */
st->ফাইল = ফাইল;
PerlIOBase(f)->পতাকা |= PERLIO_F_OPEN;
ফেরত চ;
}
রিটার্ন NULL;
}
· XXX হিসাবে চিহ্নিত স্থানে ডকুমেন্টেশন ঠিক করুন/যোগ করুন।
· স্তর দ্বারা ত্রুটি হ্যান্ডলিং নির্দিষ্ট করা হয় না. যেমন যখন $! সেট করা উচিত
স্পষ্টভাবে, যখন ত্রুটি হ্যান্ডলিং শুধুমাত্র উপরের স্তরে অর্পণ করা উচিত।
সম্ভবত ব্যবহারে কিছু ইঙ্গিত দিতে SETERRNO() অথবা যেখানে তারা পাওয়া যাবে নির্দেশক।
· আমি মনে করি এটি বোঝা সহজ করার জন্য কিছু নির্দিষ্ট উদাহরণ দেওয়া সাহায্য করবে
API অবশ্যই আমি একমত যে API সংক্ষিপ্ত হতে হবে, কিন্তু যেহেতু নেই
দ্বিতীয় দস্তাবেজ যা আরও একটি গাইড, আমি মনে করি এটি শুরু করা সহজ করে তুলবে
ডক সহ যা একটি এপিআই, তবে জিনিসগুলি যেখানে সেখানে উদাহরণ রয়েছে
অস্পষ্ট, একজন ব্যক্তির কাছে যিনি পার্লিও গুরু নন (এখনও)।
onworks.net পরিষেবা ব্যবহার করে অনলাইনে perliol ব্যবহার করুন
