rxgen - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

rxgen - Rx റിമോട്ട് പ്രൊസീജർ കോൾ പാക്കേജിനുള്ള സ്റ്റബ് ജനറേറ്റർ

സിനോപ്സിസ്

rxgen [-h | -c | -C | -S | -r] [-dkpR]
[-I മുതലാളി] [-P പ്രിഫിക്‌സ്] [-o ഔട്ട്ഫിൽ] [infile]

rxgen -s ഗതാഗത [-o ഔട്ട്ഫിൽ] [infile]

rxgen -l [-o ഔട്ട്ഫിൽ] [infile]

rxgen -m [-o ഔട്ട്ഫിൽ] [infile]

വിവരണം

rxgen Rx RPC പ്രോട്ടോക്കോൾ നടപ്പിലാക്കുന്നതിനായി C കോഡ് സൃഷ്ടിക്കുന്ന ഒരു ഉപകരണമാണ്; അത് ഇൻപുട്ടായി എടുക്കുന്നു
സിക്ക് സമാനമായ ഒരു ആപ്ലിക്കേഷൻ ഇന്റർഫേസിന്റെ ഒരു വിവരണം കൂടാതെ നിരവധി സെർവറുകൾ നിർമ്മിക്കുന്നു
കൂടാതെ/അല്ലെങ്കിൽ ക്ലയന്റ് സ്റ്റബ് ദിനചര്യകൾ RPC-അധിഷ്ഠിത പ്രോഗ്രാമുകളുമായി ലിങ്ക് ചെയ്യണം. ഈ അപൂർണ്ണലേഖനങ്ങൾ അനുവദിക്കുന്നു
പ്രാദേശിക നടപടിക്രമ കോളുകൾ വഴി വിദൂര നടപടിക്രമങ്ങൾ അഭ്യർത്ഥിക്കുന്നതിനുള്ള പ്രോഗ്രാമുകൾ. rxgen ഒരു വിപുലീകരണമാണ്
സൂര്യന്റെ rpcgen (പതിപ്പ് 3.9) പൂർണ്ണമായി നിലനിർത്തുന്നു rpcgen പ്രവർത്തനക്ഷമത (കുറഞ്ഞത്
പതിപ്പ്). ദയവായി റഫർ ചെയ്യുക rpcgen(1) സൂര്യന്റെ ആർപിസി നിർദ്ദിഷ്ട പതാകകളെക്കുറിച്ചുള്ള കൂടുതൽ വിശദാംശങ്ങൾക്ക്, കൂടാതെ
ഉപയോഗപ്രദമായ ഉദാഹരണങ്ങൾക്കൊപ്പം RPC ഭാഷയെ സംബന്ധിച്ച RPC പ്രോഗ്രാമിംഗ് ഗൈഡിലേക്ക്.

ഓപ്ഷനുകൾ

rxgen വിവിധ മോഡുകളിൽ പ്രവർത്തിക്കുന്നു. ജനറേറ്റുചെയ്‌ത ഔട്ട്‌പുട്ട് ഫയലുകൾ നിർമ്മിക്കാൻ കഴിയും
വ്യക്തിഗതമായി (ഇതിൽ ഒന്ന് ഉപയോഗിച്ച് -h, -c, -C, അഥവാ -S) അല്ലെങ്കിൽ കൂട്ടായി. എല്ലാ ഔട്ട്പുട്ട് ഫയലുകളും
സ്ഥിരസ്ഥിതി ഉപയോഗിക്കുമ്പോൾ (അതായത്, ഓപ്‌ഷനുകളൊന്നുമില്ല) അല്ലെങ്കിൽ ഔട്ട്‌പുട്ട് ഇതിലേക്ക് പരിമിതപ്പെടുത്തിയിരിക്കുമ്പോൾ സൃഷ്ടിക്കപ്പെടുന്നു
സെർവർ അപൂർണ്ണങ്ങൾ (-C ഒപ്പം -S) എപ്പോൾ -r പതാക ഉപയോഗിക്കുന്നു. ഇനിപ്പറയുന്ന തരങ്ങൾ വിവരിക്കുന്നു
ജനറേറ്റുചെയ്ത ഔട്ട്പുട്ട് ഫയലുകൾ (ലാളിത്യത്തിനായി, ഫയലിന്റെ പേര് പ്രധാന ഔട്ട്പുട്ട് ഫയലിന്റെ പേര് സൂചിപ്പിക്കുന്നു):

-h സ്റ്റാൻഡേർഡ് RPCL നിർവചനങ്ങളിൽ നിന്ന് (ഡിഫോൾട്ട്) C ഡാറ്റ നിർവചനങ്ങൾ (ഒരു തലക്കെട്ട് ഫയൽ) സൃഷ്ടിക്കുക
വിപുലീകരണം: ഫയലിന്റെ പേര്.h).

-c RPCL വിവരിച്ചിരിക്കുന്ന പ്രോട്ടോക്കോൾ സീരിയലൈസ് ചെയ്യുന്നതിന് ആവശ്യമായ XDR ദിനചര്യകൾ സമാഹരിക്കുക.
എല്ലാ പ്രഖ്യാപനങ്ങൾക്കുമായി XDR ദിനചര്യകൾ സൃഷ്ടിക്കുക (ഡിഫോൾട്ട് വിപുലീകരണം: ഫയലിന്റെ പേര്.xdr.c).

-C എല്ലാ ക്ലയന്റ് സൈഡ് സ്റ്റബ് ദിനചര്യകളും സൃഷ്ടിക്കുക (സ്ഥിര വിപുലീകരണം: ഫയലിന്റെ പേര്.cs.c).
ഈ ഫയലിൽ ഒരു ദിനചര്യ വിളിക്കുന്നത് ആർഗ്യുമെന്റുകൾ പാക്ക് അപ്പ് ചെയ്യാനും വഴി അയയ്ക്കാനും ഇടയാക്കും
Rx (അല്ലെങ്കിൽ R).

-S എല്ലാ സെർവർ സൈഡ് സ്റ്റബ് ദിനചര്യകളും സൃഷ്ടിക്കുക (സ്ഥിര വിപുലീകരണം: ഫയലിന്റെ പേര്.ss.c).
ആർഗ്യുമെന്റുകൾ അൺപാക്ക് ചെയ്‌തു, അനുബന്ധ സെർവർ ദിനചര്യയെ വിളിക്കുന്നു.

-r നിർമ്മിച്ച രണ്ട് ഡിഫോൾട്ട് എക്സ്റ്റൻഷൻ ഫയലുകൾ ജനറേറ്റ് ചെയ്യുക -C ഒപ്പം -S ഓപ്ഷനുകൾ.

ഇനിപ്പറയുന്ന ഓപ്ഷനുകൾ ഏത് കോമ്പിനേഷനിലും ഉപയോഗിക്കാം rxgen കോളുകൾ:

-R ഡിഫോൾട്ടായ Rx-ന് വിപരീതമായി പഴയ \R പ്രോട്ടോക്കോളിനായി കോഡ് സൃഷ്ടിക്കുക.

-k ജനറേറ്റ് ചെയ്‌ത കോഡ് എപ്പോൾ കെർണൽ ഉപയോഗിക്കാനാണ് ഉദ്ദേശിക്കുന്നതെന്ന് വ്യക്തമാക്കണം;
ടാർഗെറ്റ് ഔട്ട്പുട്ട് ആയിരിക്കുമ്പോൾ പ്രത്യേക "ഉൾക്കൊള്ളുന്നു" മറ്റ് പ്രത്യേകതകൾ നിർമ്മിക്കപ്പെടുന്നു
കേർണൽ.

-p പാക്കേജ് കോമ്പിനേഷൻ ഫ്ലാഗ്: ഒന്നിൽ ഒന്നിലധികം പാക്കേജുകൾ ഉൾപ്പെടുത്തുമ്പോൾ
സ്‌പെസിഫിക്കേഷൻ ഫയൽ, അവയ്‌ക്കെല്ലാം ഒരു എക്‌സിക്യൂട്ട് അഭ്യർത്ഥന ദിനചര്യ ഉപയോഗിക്കും a
ഈ പതാകയുടെ ഫലം. ഇതിനായി വ്യക്തിഗത എക്സിക്യൂട്ട് അഭ്യർത്ഥന സ്റ്റബുകൾ സൃഷ്ടിക്കുന്നതാണ് ഡിഫോൾട്ട്
ഓരോ പാക്കേജും.

-I മുതലാളി
സമാനമായി -I സി കംപൈലറിൽ ഫ്ലാഗ് (cc). ഈ പതാക പ്രീ-
പ്രോസസ്സർ (സിപിപി) അതിനാൽ ആ ഡയറക്ടറി മുതലാളി എന്നതിനായുള്ള സ്റ്റാൻഡേർഡ് ലുക്ക്അപ്പ് ലിസ്റ്റിന് മുമ്പായി തിരയുന്നു
#ഫയലുകൾ ഉൾപ്പെടുത്തുക. പ്രതീക്ഷിച്ചതുപോലെ, ഒന്നിലധികം -I പതാകകൾ ഒരേസമയം ഉപയോഗിക്കാം.

-P പ്രിഫിക്‌സ്
ദി പ്രിഫിക്‌സ് ഈ സ്വിച്ചിന് ശേഷമുള്ള സ്ട്രിംഗ് എല്ലാ ജനറേറ്റഡ് ഔട്ട്‌പുട്ട് ഫയലുകളിലേക്കും മുൻകൂട്ടി തയ്യാറാക്കിയിരിക്കുന്നു;
ഒന്നിലധികം റണ്ണുകൾ ഒരേ ഇന്റർഫേസിന്റെ വ്യത്യസ്ത പതിപ്പുകൾ നിർമ്മിക്കാൻ താൽപ്പര്യപ്പെടുമ്പോൾ ഉപയോഗപ്രദമാണ്
(പറയുക, കേർണൽ, നോൺ-കേർണൽ പതിപ്പുകൾ).

-d ഡീബഗ്ഗിംഗ് മോഡ്; ആവശ്യമുള്ളപ്പോൾ മാത്രം rxgen ഡീബഗ്ഗ് ചെയ്യണം (പറയുക, വഴി dbx).

-o ഔട്ട്ഫിൽ
ഔട്ട്പുട്ട് ഫയലിന്റെ പേര് വ്യക്തമാക്കുക. ഒന്നും വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് ആണ്
ഉപയോഗിച്ച (-c, -h, -C, ഒപ്പം -S മോഡുകൾ മാത്രം). ഒരു ഔട്ട്പുട്ട് ഫയൽ a-ൽ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ ശ്രദ്ധിക്കുക
മൾട്ടി-ഔട്ട്‌പുട്ട് ഫയൽ ഓപ്ഷൻ (ഡിഫോൾട്ട് അല്ലെങ്കിൽ ഓപ്‌ഷനോടുകൂടിയത് പോലെ -r), പിന്നെ ഔട്ട്ഫിൽ
സ്ഥിരസ്ഥിതിയായി സൃഷ്ടിച്ച പേര് മാറ്റിസ്ഥാപിക്കുന്നു (ഇത് കോൺഫിഗറേഷന്റെ പ്രധാനത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്
ഫയലിന്റെ പേര്).

ദി -s, -l, ഒപ്പം -m എന്നതിന് മാത്രം ഓപ്ഷനുകൾ നിലവിലുണ്ട് rpcgen പിന്തുണ. കാണുക rpcgen(1) വേണ്ടി
അവയുടെ ഉപയോഗത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ.

rxgen സിന്റാക്സ് സംഗ്രഹം

സ്പെസിഫിക്കേഷൻ ഫയൽ:

|
|
|
|
|


:

"പാക്കേജ്"

:

"പ്രിഫിക്സ്"

:

"ആരംഭ കോഡ്"

:

"സ്പ്ലിറ്റ്പ്രിഫിക്സ്" ";"

:

"IN=" "|"
"പുറത്ത് =" "|"


:

["പ്രോക്"] [ ] [ ]
["വിഭജനം" | "മൾട്ടി"]
["=" ] ";"

:

"(" ")"

:


["<" ">" | "[" "]"] | ശൂന്യം

:

"," | ശൂന്യം

:

"IN" | "ഔട്ട്" | "ഇനൗട്ട്" | ശൂന്യം

:

| ശൂന്യം

:
:
:
:
:
:
:
:
:



:
:

സൂര്യന്റെ RPCL ഭാഷാ വാക്യഘടന (കാണുക rpcgen(1))

rxgen കമാൻഡുകൾ

അഭിപ്രായങ്ങള് ഒപ്പം പ്രീപ്രൊസസ്സിംഗ്
ഇൻപുട്ട് ഇന്റർഫേസിൽ സിയിലൂടെ കടന്നുപോകുന്ന പ്രീപ്രൊസസ്സർ നിർദ്ദേശങ്ങൾ അടങ്ങിയിരിക്കാം
പ്രീപ്രൊസസ്സർ (അതായത് "cpp"). പ്രീപ്രൊസസ്സർ എല്ലാ ഇൻപുട്ട് ഫയലുകളിലും പ്രവർത്തിക്കുന്നതിന് മുമ്പുള്ളതിനാൽ
യഥാർത്ഥത്തിൽ വ്യാഖ്യാനിച്ചത് rxgen, എല്ലാം സിപിപി നിർദ്ദേശങ്ങൾ (#ഉൾപ്പെടെ, #ifdefs, #defines, മുതലായവ).
നിയമാനുസൃതവും സ്വാഗതാർഹവുമാണ് rxgen ഇൻപുട്ട് ഫയൽ. തീർച്ചയായും, ഈ പ്രീപ്രൊസസ്സർ ഒന്നുമില്ല
ജനറേറ്റുചെയ്‌ത ഏതെങ്കിലും ഫയലുകളിൽ നിർദ്ദേശങ്ങൾ ഉൾപ്പെടുത്തും. വ്യത്യാസങ്ങൾ സുഗമമാക്കുന്നതിന്
വ്യത്യസ്ത തരം ഔട്ട്പുട്ട് ഫയലുകൾക്കിടയിൽ, rxgen ചില പ്രത്യേക നിർവചിക്കുന്നു സിപിപി എന്നതിനുള്ള ചിഹ്നങ്ങൾ
ഉപയോഗിക്കുന്നത് rxgen പ്രോഗ്രാമർ. ഇവയാണ് RPC_HDR (തലക്കെട്ടിലേക്ക് കംപൈൽ ചെയ്യുമ്പോൾ നിർവചിച്ചിരിക്കുന്നത്,
ഫയലിന്റെ പേര്.h, ഫയലുകൾ), RPC_XDR (xdr-ലേക്ക് കംപൈൽ ചെയ്യുമ്പോൾ നിർവചിച്ചിരിക്കുന്നത്, ഫയലിന്റെ പേര്.xdr.c, ഫയലുകൾ),
RPC_CLIENT (ക്ലയന്റ് സ്റ്റബുകളിലേക്ക് കംപൈൽ ചെയ്യുമ്പോൾ നിർവചിച്ചിരിക്കുന്നത്, ഫയലിന്റെ പേര്.cs.c, ഫയലുകൾ), കൂടാതെ
RPC_SERVER (സെർവർ സ്റ്റബുകളിലേക്ക് കംപൈൽ ചെയ്യുമ്പോൾ നിർവചിച്ചിരിക്കുന്നത്, ഫയലിന്റെ പേര്.ss.c, ഫയലുകൾ).

ഇതുകൂടാതെ, rxgen സ്വന്തമായി ഒരു ചെറിയ പ്രീപ്രോസസിംഗ് നടത്തുന്നു. "%" ൽ തുടങ്ങുന്ന ഏതൊരു വരിയും
നേരിട്ട് ഔട്ട്പുട്ട് ഫയലിലേക്ക് കടന്നു, വ്യാഖ്യാനിക്കാതെ rxgen. കൂടുതൽ ഭാരമുള്ള കൂട്ടത്തിന്
വ്യാഖ്യാനിക്കാത്ത കോഡ് ഡംപിംഗ്, അത്തരത്തിലുള്ള എല്ലാ കോഡുകളും ഉൾപ്പെടുത്താൻ നിർദ്ദേശിക്കും
"#ഉൾപ്പെടുത്തുക" ഫയൽ തുടർന്ന് "%" എന്നതിന് മുമ്പായി പാസ്സാക്കുക. ഇൻപുട്ട് ഇന്റർഫേസിൽ എന്തെങ്കിലും അടങ്ങിയിരിക്കാം
തീർച്ചയായും അവഗണിക്കപ്പെട്ട സി-സ്റ്റൈൽ കമന്റുകൾ. വ്യാഖ്യാനം ടോക്കൺ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, അതിനാൽ
പ്രത്യേക പ്രസ്താവനകളുടെ പ്രത്യേക ലൈൻ-ഓറിയന്റേഷൻ ആവശ്യമില്ല. rxgen a
വളരെ സമ്പന്നവും സഹായകരവുമായ പിശക് റിപ്പോർട്ടുകളുടെ ഒരു കൂട്ടം, കൃത്യമായ ലൈൻ ലൊക്കേഷൻ അനുസരിച്ച് അവയെ തിരിച്ചറിയുന്നു
പിശക് തരം. കൂടാതെ, rxgen സ്റ്റാൻഡേർഡ് ഉൾപ്പടെയുള്ളവയ്ക്കായി #include ലൈനുകൾ സ്വയമേവ സൃഷ്ടിക്കും
പോലുള്ള ഫയലുകൾ rx/xdr.h ഒപ്പം rx/rx.h, ഇതിൽ നിന്ന് ജനറേറ്റ് ചെയ്ത ഹെഡ്ഡർ ഫയലിനൊപ്പം
ഇന്റർഫേസ്.

പ്രിഫിക്സിംഗ് സ്റ്റബ്ബ് നടപടിക്രമങ്ങൾ
ദി പാക്കേജ് പ്രസ്താവന പറയുന്നു rxgen ഇന്റർഫേസ് പാക്കേജിന്റെ പേര്. ഇതിനായി ഉപയോഗിക്കുന്നു
സൃഷ്‌ടിച്ച എല്ലാ അപൂർണ്ണ ദിനചര്യകളുടെയും പേരിടലും എക്‌സിക്യൂട്ട് അഭ്യർത്ഥന നടപടിക്രമവും പ്രിഫിക്‌സ് ചെയ്യുന്നു.
ഉദാഹരണത്തിന്:

പാക്കേജ് AFS_

എക്സിക്യൂട്ട് അഭ്യർത്ഥന നടപടിക്രമത്തിന് AFS_ExecuteRequest എന്ന് പേരിടാൻ കാരണമാകുന്നു (മുന്നറിയിപ്പ്: പഴയതിൽ
ExecuteRequest നാമത്തിലേക്ക് പാക്കേജിന്റെ പേരിന് ശേഷം ഒരു അധിക "_" പതിപ്പ് ചേർത്തു;
അതിനാൽ നിങ്ങൾക്ക് ഒരു ExecuteRequest ഇന്റർഫേസ് ദിനചര്യയും നൽകിയിരിക്കുന്ന അപൂർണ്ണതയും ഇല്ലെന്ന് ഉറപ്പാക്കുക
യഥാർത്ഥത്തിൽ AFS_Fetch എന്ന് പേരിടാൻ Fetch പറയുക. ഒന്നിലധികം പാക്കേജ് പ്രസ്താവനകൾ (നിലവിലെ
പരമാവധി വലിപ്പം 10) ഓരോ കോൺഫിഗറേഷനും അനുവദനീയമാണ്, കൂടാതെ ഒന്നിലധികം സെറ്റുകൾ ഉപയോഗിക്കുമ്പോൾ ഉപയോഗപ്രദവുമാണ്
ഇന്റർഫേസുകൾ നടപ്പിലാക്കുന്നു (അവസാനം ഉദാഹരണം കാണുക). അത്തരം സന്ദർഭങ്ങളിൽ, ഉപയോഗിക്കുന്നത് ശ്രദ്ധിക്കുക
The -p ഫ്ലാഗ് ഒരു ExecuteRequest നടപടിക്രമം സൃഷ്ടിക്കുന്നതിലേക്ക് നയിക്കുന്നു
ഒന്നിലധികം ഇന്റർഫേസുകൾ തിരിച്ചറിയുകയും അവയുടെ പേര് ആദ്യ പാക്കേജ് പ്രിഫിക്‌സ് ചെയ്യുകയും ചെയ്യുന്നു
പ്രസ്താവന. ഡിഫോൾട്ട് കേസിൽ, സ്വതന്ത്രമായ എക്‌സിക്യൂട്ട് റിക്വസ്റ്റ് നടപടിക്രമങ്ങൾ സൃഷ്ടിക്കപ്പെടും
വിദൂര നടപടിക്രമ കോളുകളുടെ ഓരോ പാക്കേജുചെയ്ത ഗ്രൂപ്പും.

ദി പ്രിഫിക്‌സ് വിദൂര നടപടിക്രമങ്ങളുടെ പേരുകളിലേക്കുള്ള എല്ലാ കോളുകൾക്കും മുൻകൈയെടുക്കാൻ സ്റ്റേറ്റ്‌മെന്റ് ഒരു പേര് നൽകുന്നു
ExecuteRequest അപൂർണ്ണ ദിനചര്യ. സെർവർ മറ്റുള്ളവരിലേക്ക് RPC കോളുകൾ ചെയ്യുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്
സെർവറുകൾ (ഡീബഗ്ഗിംഗ് ആവശ്യങ്ങൾക്കായി പറയുക). ഉദാഹരണത്തിന്:

പ്രിഫിക്സ് എസ്

സെർവറിൽ നിന്ന് വിളിക്കുന്ന എല്ലാ ദിനചര്യകളുടെയും പേരിന് മുമ്പായി "S" എന്ന പേര് നൽകുന്നതിന് കാരണമാകുന്നു
കുറ്റിച്ചെടികൾ. സെർവറിന് യഥാർത്ഥ പേര് വിളിക്കാനും ക്ലയന്റ് സ്റ്റബുകൾ നേടാനും കഴിയും.

rxgen നടപടിക്രമം പ്രഖ്യാപനം
ദി proc എന്നതിൽ ഏറ്റവും സാധാരണമായ (അർഥവത്തായ) പ്രസ്താവനയാണ് rxgen ഇന്റർഫേസ്. അതിന്റെ വാക്യഘടന
വിവരണം ഇതാണ്:

[പ്രോക്] [ ] [ ] ( ,..., )
[വിഭജനം | ഒന്നിലധികം] [= ] ;

എവിടെ:

· "proc" എന്നത് നടപടിക്രമ പ്രസ്താവനയുടെ ഒരു ഓപ്ഷണൽ പ്രിഫിക്സാണ്. ഇതൊരു സ്റ്റൈലിസ്റ്റിക് ഇനം മാത്രമാണ്
കൂടാതെ ആവശ്യമായ നടപടിക്രമം ഡിലിമിറ്റർ അല്ല.

· നടപടിക്രമത്തിന്റെ പേരാണ്. നടപടിക്രമത്തിന്റെ പേര് പോലും എന്നത് ശ്രദ്ധിക്കുക
ഓപ്ഷണൽ. നൽകിയിരിക്കുന്ന നടപടിക്രമത്തിന്റെ പേര് സമാനമാകുമ്പോൾ മാത്രമേ ഇത് അർത്ഥമാക്കൂ
അവസാനത്തെ പേര് പാക്കേജ് പ്രസ്താവന (അതായത്, "പാക്കേജ് RCallBack" എന്നതിന്റെ പ്രഖ്യാപനവും
"RCallBack" നടപടിക്രമം).

· , നിലവിലുണ്ടെങ്കിൽ, പകരം ആ അപൂർണ്ണതയെ വിളിക്കാൻ ExecuteRequest നടപടിക്രമം കാരണമാകുന്നു
ആ ഒപ്‌കോഡുള്ള ഒരു കോൾ ഡീകോഡ് ചെയ്യുമ്പോൾ സ്വയമേവ സൃഷ്‌ടിക്കപ്പെട്ട അപൂർണ്ണമായത്.

· ആ നടപടിക്രമത്തിനുള്ള ഒപ്‌കോഡായ ഒരു സ്ഥിരാങ്കം അല്ലെങ്കിൽ ചിഹ്നമാണ്. ഒരാൾ ഉപയോഗിച്ചേക്കാം
പ്രീപ്രൊസസ്സർ സവിശേഷതകൾ (അതായത്, #define), the കൺസ്ട്രക്റ്റർ RPC-ഭാഷാ സവിശേഷത, അല്ലെങ്കിൽ പഴയത്
ഒപ്‌കോഡുകളായി നല്ല സ്ഥിരാങ്കങ്ങൾ. ഒപ്‌കോഡുകളുടെ കൂടുതൽ മൂല്യനിർണ്ണയം/പ്രോസസ്സിംഗ് നടത്തി.
പ്രത്യേകിച്ചും, ഡ്യൂപ്ലിക്കേറ്റും നിലവിലില്ലാത്തതുമായ ഒപ്‌കോഡുകൾക്കായുള്ള പരിശോധനകൾ നടത്തുന്നു
ഒപ്‌കോഡ് സീക്വൻസുകളിൽ "ദ്വാരങ്ങൾ" (അതായത്, തുടർച്ചയായ ഒപ്‌കോഡുകളിലെ വിടവുകൾ) പരിശോധിക്കുന്നു. വേണ്ടി
ഉദാഹരണത്തിന്, ഒപ്‌കോഡുകളിൽ "ദ്വാരങ്ങൾ" നിലനിൽക്കുമ്പോൾ, ExecuteRequest എന്ന വസ്തുത ഞങ്ങൾ ഉപയോഗിക്കുന്നു
നടപടിക്രമം ഉപയോഗിക്കുന്നു കേസ് വേഗമേറിയ (ചെറിയ, കോഡ്‌വൈസ്) സൂചികയിലേക്കാൾ പ്രസ്താവന
അറേ രീതി.

കൂടാതെ, rxgen ഓരോന്നിനും മൂന്ന് വിലയേറിയ മാക്രോകൾ നിർവചിക്കുന്നു (അതായത്, ഹെഡർ ഫയലിലേക്ക് കൂട്ടിച്ചേർക്കുന്നു).
പാക്കേജ് ഗ്രൂപ്പ്: LOWEST_OPCODE, HIGHEST_OPCODE, കൂടാതെ
NUMBER_OPCODES. ഇവയ്ക്ക് ഉപകാരപ്പെട്ടേക്കാം rxgen പ്രോഗ്രാമർ. കൂടാതെ,
ശ്രദ്ധിക്കുക ഒപ്ചൊദെ പ്രസ്താവന ഒരു ഓപ്ഷണൽ സവിശേഷതയാണ്, അത് ഒഴിവാക്കാവുന്നതാണ്. ഇത്തരം
കേസുകളിൽ, ഓട്ടോമാറ്റിക് ഒപ്‌കോഡ് നമ്പറുകൾ തുടർച്ചയായി ജനറേറ്റുചെയ്യുന്നു, 0 മുതൽ ആരംഭിക്കുന്നു.

പ്രാരംഭ ഒപ്‌കോഡ് നമ്പർ ഉപയോഗിച്ച് ഒരാൾക്ക് മാറ്റാനാകും ആരംഭ കോഡ് (എയുടെ അഭാവത്തിന്
നല്ല പേര്) rxgen കമാൻഡ്. അതിന്റെ വാക്യഘടന ഇതാണ്:

ആരംഭ കോഡ്

എവിടെ ന്യായയുക്തമായിരിക്കണം! ഒരാൾക്ക് നടപടിക്രമങ്ങൾ മിക്സ് ചെയ്യാൻ കഴിയില്ല, ചിലത്
ഒപ്‌കോഡുകളും ചിലത് ഇല്ലാത്തതും, അല്ലെങ്കിൽ ന്റെ സ്പെസിഫിക്കേഷന് ശേഷം ഒപ്‌കോഡുകൾ അനുവദിക്കില്ല
ആരംഭ കോഡ് പ്രസ്താവന. rxgen ഇത്തരം കേസുകളിലെല്ലാം പരാതിപ്പെടും.

· ദി വാദം എൻട്രി നടപടിക്രമത്തിന്റെ തന്നിരിക്കുന്ന പരാമീറ്ററിനെ പ്രതിനിധീകരിക്കുന്നു. അതിന്റെ വാക്യഘടന ഇതാണ്:

[IN | അകത്ത് | പുറത്ത് | ]
[ |<>|[പരമാവധി]|[]]

തരം ഒരു പരോക്ഷ തരമാണെങ്കിൽ (അതായത്, തുടർന്ന് *), അത് പോയിന്റർ ആണെന്ന് അനുമാനിക്കപ്പെടുന്നു
ഒരു ലെവൽ പിന്തുടരുകയും ചൂണ്ടിക്കാണിച്ച ഡാറ്റ കൈമാറുകയും വേണം. ഇത് ചെയ്യണം
സാധാരണയായി എല്ലാ ഘടനകൾക്കും/അറേകൾക്കും ഔട്ട് പാരാമീറ്ററുകൾക്കും ഉപയോഗിക്കുന്നു. ശ്രദ്ധേയമായ ഒരു അപവാദം
വ്യക്തമായ അറേ/ഘടനയുടെ പരമാവധി വലിപ്പം നൽകുമ്പോൾ; അറേ-ഓഫ്-പോയിന്റർ ഇല്ലാത്തതിനാൽ
ഡിക്ലറേഷനുകൾ അനുവദനീയമാണ്, സമാനമായ പ്രഭാവം നേടാൻ ഒരാൾ ടൈപ്പ്ഡെഫുകൾ ഉപയോഗിക്കണം. ദി
പരാമീറ്ററുകൾ ഇൻപുട്ട് പാരാമീറ്ററുകൾ (IN-ന് മുമ്പുള്ളത്), ഔട്ട്പുട്ട് പാരാമീറ്ററുകൾ (മുമ്പുള്ളത്
OUT), അല്ലെങ്കിൽ ഇൻപുട്ട്/ഔട്ട്‌പുട്ട് പാരാമീറ്ററുകൾ (INOUT-ന് മുമ്പുള്ളത്). വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, പിന്നെ
നടപടിക്രമത്തിൽ മുമ്പത്തെ പാരാമീറ്ററിന്റെ ദിശ ഉപയോഗിക്കുന്നു. (ശ്രദ്ധിക്കുക: ആദ്യത്തേത്
പരാമീറ്ററിന് മുമ്പായി ദിശാസൂചന പ്രിമിറ്റീവ് ആയിരിക്കണം!)

ഫയൽ കൈമാറ്റം അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും കാര്യങ്ങൾ ചെയ്യുന്ന അപൂർണ്ണമായ ദിനചര്യകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു ഹാക്ക് ആണ് "സ്പ്ലിറ്റ്"
മുമ്പ് വിവരങ്ങൾ കൈമാറേണ്ട മറ്റ് പ്രവർത്തനം (ഉദാ, ഒരു ഫയലിന്റെ ദൈർഘ്യം).
കോൾ അതിന്റെ ഔട്ട്പുട്ട് പാരാമീറ്ററുകൾ നൽകുന്നു. പ്രത്യേക ഹസ്തദാനം കാരണം
വിദൂര ഫയൽ കൈമാറ്റം ചെയ്യുമ്പോൾ, ഞങ്ങൾ നിലവിൽ അത്തരം കോളുകളെ രണ്ടായി വിഭജിക്കുന്നു
ക്ലയന്റ് സൈഡ് അപൂർണ്ണ ദിനചര്യകൾ. ആദ്യത്തേത് ("ആരംഭിക്കുക" എന്നതിന്റെ സ്ഥിരസ്ഥിതി പ്രിഫിക്‌സിനൊപ്പം) ഉപയോഗിക്കുന്നു
എല്ലാ IN, INOUT പാരാമീറ്ററുകളും സെർവർ വശത്തേക്ക് കൈമാറുക. രണ്ടാമത്തേത് (സ്ഥിരസ്ഥിതിയോടെ
സെർവറിൽ നിന്ന് INOUT, OUT പാരാമീറ്ററുകൾ തിരികെ ലഭിക്കാൻ "End" എന്ന പ്രിഫിക്സ്) ഉപയോഗിക്കുന്നു.
രണ്ട് കോളുകൾക്കിടയിൽ, ഉപയോക്താവ് ഫയലിനായി ഉചിതമായ കോളുകൾ ചെയ്യേണ്ടതാണ്
കൈമാറ്റം. ഉദാഹരണത്തിന്, AFS_ പാക്കേജിലെ ഇനിപ്പറയുന്ന നടപടിക്രമ പ്രഖ്യാപനം

Fetch (IN a, b,INOUT c, OUT d) split = FETCHOPCODE;

ഏകദേശം രണ്ട് സ്വതന്ത്ര ക്ലയന്റ് സ്റ്റബ് ദിനചര്യകൾ സൃഷ്ടിക്കും:

BeginAFS_Fetch (IN a, b, c)

ഒപ്പം

EndAFS_Fetch(OUT c, d)

ദി splitprefix രണ്ടും ഉപയോഗിക്കുന്ന ഡിഫോൾട്ട് പ്രിഫിക്‌സ് പേരുകൾ മാറ്റാൻ സ്റ്റേറ്റ്‌മെന്റ് ഉപയോഗിക്കുന്നു
ഫയൽ കൈമാറ്റവുമായി ബന്ധപ്പെട്ട നടപടിക്രമങ്ങൾ കൈകാര്യം ചെയ്യുമ്പോൾ ക്ലയന്റ് സൈഡ് സ്റ്റബ് ജനറേറ്റഡ് ദിനചര്യകൾ
വിളിക്കുന്നു. ഉദാഹരണത്തിന്:

splitprefix IN=Before_ OUT=After_

ഫയൽ കൈമാറ്റവുമായി ബന്ധപ്പെട്ട ദിനചര്യയ്‌ക്കായി രണ്ട് ക്ലയന്റ് സ്റ്റബുകളുടെ പേര് നൽകുന്നതിന് കാരണമാകും
കൊണ്ടുവരിക(), ആകാൻ മുമ്പ്_AFS_Fetch() ഒപ്പം After_AFS_Fetch(), യഥാക്രമം.

· "മൾട്ടി" ഓപ്ഷൻ മുകളിൽ വിവരിച്ച "സ്പ്ലിറ്റ്" ഫീച്ചറിന് ഏതാണ്ട് സമാനമാണ്. ഒരേയൊരു
രണ്ട് ക്ലയന്റ് സ്റ്റബുകൾക്കൊപ്പം, സ്റ്റാൻഡേർഡ് എന്നതാണ് ശ്രദ്ധേയമായ വ്യത്യാസം
ക്ലയന്റ് സ്റ്റബും ജനറേറ്റ് ചെയ്യപ്പെടുന്നു. മൾട്ടി-ആർഎക്സ് കോളുകൾ കൈകാര്യം ചെയ്യുക എന്നതാണ് ഉദ്ദേശം എന്നതിനാൽ, ഞങ്ങൾ
മൾട്ടി-Rx കോൾ ഇല്ലാത്ത സന്ദർഭങ്ങളിൽ മുഴുവൻ സ്റ്റാൻഡേർഡ് പ്രൊസീജർ സ്റ്റബ്ബും ആവശ്യമാണ്
നടപടിക്രമം നടപ്പിലാക്കുന്നു. "മൾട്ടി" ഓപ്ഷന്റെ ഒരു പാർശ്വഫലമാണ് a യുടെ ജനറേഷൻ
പ്രത്യേക മാക്രോ (അതായത്, "multi__ "ഇത് "ആരംഭം" എന്ന വാദങ്ങളായി തിരികെ പോകുന്നു
ഹെഡർ ഔട്ട്‌പുട്ട് ഫയലിലെ "എൻഡ്" സ്റ്റബുകളും. ഈ മാക്രോ നേരിട്ട് Rx കോഡ് ഉപയോഗിക്കുന്നു
ഈ നടപടിക്രമത്തിന്റെ ഒരു മൾട്ടി-ആർഎക്സ് കോൾ നടത്തുമ്പോൾ.

കാലഹരണപ്പെട്ടു rxgen സവിശേഷതകൾ
ഇനിപ്പറയുന്ന rxgen കമാൻഡുകൾ ഇപ്പോഴും പ്രാബല്യത്തിൽ ഉണ്ടെങ്കിലും, അവ ഉടൻ തന്നെ നീക്കം ചെയ്യപ്പെടും
മെച്ചപ്പെട്ട ബദലുകൾ ഉണ്ട്. അവ ഉപയോഗിക്കരുത്!

ദി പ്രത്യേക പ്രസ്താവനയുടെ ചില അപര്യാപ്തതകൾ കൈകാര്യം ചെയ്യാൻ ഉപയോഗിക്കുന്ന ഒരു താൽക്കാലിക ഹാക്ക് ആണ്
ചില ഉപയോക്തൃ ഇഷ്‌ടാനുസൃത പ്രഖ്യാപനങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള സ്റ്റാൻഡേർഡ് xdr ദിനചര്യകൾ. പ്രത്യേകിച്ച്, ഇത്
ഒരു പ്രഖ്യാപനത്തിന്റെ ഭാഗമായി വ്യക്തമാക്കിയ ഒരു സ്ട്രിംഗ് പോയിന്ററിന് ബാധകമാണ്. ഉദാഹരണത്തിന്,

പ്രത്യേക ഘടന BBS SeqBody;

പറയുന്നു rxgen ഉപയോക്താവ് നിർവചിച്ച BBS xdr ദിനചര്യയിലെ "SeqBody" എന്ന എൻട്രി ഒരു സ്ട്രിംഗ് ആണ് (ശ്രദ്ധിക്കുക
ഓരോ ഘടനയിലും ഒന്നിലധികം സ്ട്രിംഗുകൾ "പ്രത്യേക" ആകാം -- ഒന്നിലധികം സ്ട്രിംഗുകൾ വേർതിരിച്ചിരിക്കുന്നു
കോമകൾ); അങ്ങനെ അത് സെർവർ ജനറേറ്റുചെയ്ത സ്ഥലത്തെ ശരിയായി അനുവദിക്കുകയും ഡീ-അലോക്കേറ്റ് ചെയ്യുകയും ചെയ്യും
ഈ ഘടന ഒരു IN അല്ലെങ്കിൽ INOUT പാരാമീറ്ററായി ഉൾക്കൊള്ളുന്ന അപൂർണ്ണലേഖനങ്ങൾ.

ഒരു മികച്ച ബദൽ പ്രത്യേക ആകുന്നു ഇഷ്ടാനുസൃതമാക്കിയത് പ്രസ്താവന, അത് ലളിതമായി ആണ്
"ഇഷ്‌ടാനുസൃതമാക്കിയ" ടോക്കൺ തുടർന്ന് RPCL അടിസ്ഥാനമാക്കിയുള്ള ഒരു ഘടനയുടെ പതിവ് പ്രഖ്യാപനം
നിയമങ്ങൾ. ഈ സാഹചര്യത്തിൽ, ജനറേറ്റ് ചെയ്ത ഹെഡർ ഫയലിൽ ഡിക്ലറേഷൻ ഉൾപ്പെടുത്തും (-h
ഓപ്ഷൻ) എന്നാൽ ഈ ഘടനയ്ക്കായി xdr ദിനചര്യയൊന്നും സൃഷ്ടിക്കില്ല -- ഉപയോക്താവ് വിതരണം ചെയ്യും
ഈ. ഘടന ആയിരിക്കുമ്പോൾ ഈ ഘടനയിലെ എല്ലാ പോയിന്റർ എൻട്രികളും ഓർമ്മിക്കപ്പെടും
സെർവർ സ്റ്റബിൽ IN അല്ലെങ്കിൽ INOUT ആയി ഉപയോഗിക്കുന്നു, കോർ ലീക്കുകളൊന്നും സംഭവിക്കില്ല. ഉദാഹരണത്തിന്,
പരിഗണിക്കുക

ഇഷ്ടാനുസൃതമാക്കിയ ഘടന CBS {
നീണ്ട സെക്ലെൻ;
char *SeqBody;
}

DECODE xdr opcode സമയത്ത് ഉപയോക്താവ് "xdr_CBS" ദിനചര്യ നൽകും,
"SeqBody" സ്ട്രിംഗിന് അനുയോജ്യമായ സ്ഥലം അനുവദിച്ചിരിക്കുന്നു. അതുപോലെ, ആ ഇടം സ്വതന്ത്രമാകുന്നു
സൗജന്യ xdr opcode സമയത്ത്.

ശ്രദ്ധിക്കുക: പഴയ രീതിയിലുള്ള "അറേ പാരാമീറ്റർ സ്പെസിഫിക്കേഷനുകൾ" ഇനി പിന്തുണയ്ക്കില്ല.

ഉദാഹരണങ്ങൾ

നിലവിലെ RPC ഭാഷയിൽ ചില ആവശ്യകതകൾ ലഭ്യമല്ലെങ്കിൽ, ഒരാൾക്ക് കഴിയും
ആ ഡാറ്റ തരങ്ങൾ നിർവചിക്കാതെ വിട്ടുകൊണ്ട് ചില XDR ദിനചര്യകൾ ഇഷ്ടാനുസൃതമാക്കുക. ഓരോ ഡാറ്റ തരത്തിനും
അത് നിർവചിക്കപ്പെട്ടിട്ടില്ല, "xdr_" എന്ന പേരിൽ ഒരു ദിനചര്യ നിലവിലുണ്ടെന്ന് അനുമാനിക്കാം.
അതിലേക്ക്. തിരഞ്ഞെടുത്ത ഒരു കൂട്ടം rxgen സവിശേഷതകൾ ചുവടെ അവതരിപ്പിച്ചിരിക്കുന്നു, എന്നാൽ കൂടുതൽ സമഗ്രമായതിന്
ഒന്ന് (യൂണിയനുകൾ, സങ്കീർണ്ണമായ ഉദാഹരണങ്ങൾ മുതലായവ) ദയവായി കാണുക rpcgen പ്രോഗ്രാമിംഗ് വഴികാട്ടി ഒപ്പം
ബാഹ്യമായ ഡാറ്റ പ്രാതിനിധ്യം: സൂര്യൻ സാങ്കേതികമായ കുറിപ്പുകൾ.

ടൈപ്പ്ഡെഫുകൾ
ആർ‌പി‌സി ടൈപ്പ്‌ഡെഫ് സ്റ്റേറ്റ്‌മെന്റ് സി ടൈപ്പ്ഡെഫിന് സമാനമാണ് (അതായത് "ടൈപ്പ്ഡെഫ് ").
സ്ഥിരസ്ഥിതിയായി, മിക്ക ഉപയോക്തൃ പ്രഖ്യാപനങ്ങളും (അതായത്, ഘടനകൾ, യൂണിയനുകൾ മുതലായവ) സ്വയമേവയാണ്
ടൈപ്പ് ചെയ്തത് rxgen. ഇത് പാഴ്‌സിംഗ് ലളിതമാക്കുന്നതിനാൽ, അതിന്റെ ഉപയോഗം ശുപാർശ ചെയ്യുന്നത് rxgen
സ്ക്രിപ്റ്റുകൾ.

സ്ട്രിംഗ്സ്
C "char *" സ്ട്രിംഗ് കൺവെൻഷൻ ഒരു തരത്തിൽ അവ്യക്തമാണ്, കാരണം ഇത് സാധാരണയായി ഉദ്ദേശിക്കുന്നത്
പ്രതീകങ്ങളുടെ അസാധുവായ ഒരു സ്ട്രിംഗ് അർത്ഥമാക്കുന്നു, എന്നാൽ ഇത് a യിലേക്കുള്ള ഒരു പോയിന്ററിനെ പ്രതിനിധീകരിക്കുന്നു
ഒറ്റ പ്രതീകം, പ്രതീകങ്ങളുടെ ഒരു നിരയിലേക്കുള്ള ഒരു പോയിന്റർ മുതലായവ. RPC ഭാഷയിൽ, ഒരു ശൂന്യം-
അവസാനിപ്പിച്ച സ്ട്രിംഗിനെ സംശയരഹിതമായി "സ്ട്രിംഗ്" എന്ന് വിളിക്കുന്നു. ഉദാഹരണങ്ങൾ,

സ്ട്രിംഗ് ബിഗ് നെയിം<>;
സ്ട്രിംഗ് പേര് ;
ടൈപ്പ്ഡെഫ് സ്ട്രിംഗ് വോളിന്റെ പേര് ;

സ്‌ട്രിംഗിന്റെ പരമാവധി വലുപ്പം ഏകപക്ഷീയമാകാം (മുകളിലുള്ള "ബിഗ്‌നെയിം" പോലെ) അല്ലെങ്കിൽ,
വെയിലത്ത്, അല്ലെങ്കിൽ ആംഗിൾ ബ്രാക്കറ്റുകളിൽ വ്യക്തമാക്കിയിരിക്കുന്നു (അതായത് "പേര്", "വോളിന്റെ പേര്" മുകളിൽ). ഇൻ
പരിശീലിക്കുക, ഇന്റർഫേസുകളിൽ എപ്പോഴും ബൗണ്ടഡ് സ്ട്രിംഗുകൾ മാത്രമേ ഉപയോഗിക്കാവൂ. ഒരു സാമ്പിൾ കോളിംഗ് പ്രോക്
മുകളിലുള്ള പ്രഖ്യാപനങ്ങൾ ഉപയോഗിക്കുന്നത് ഇതായിരിക്കും:

GetEntryByName (വോൾനാമത്തിൽ പേര്,
ഔട്ട് സ്ട്രക്റ്റ് vldbentry *എൻട്രി) = VL_GETENTRYBYNAME;

അല്ലെങ്കിൽ, തീർച്ചയായും,

GetEntryByName (ഇൻ സ്ട്രിംഗ് വോളിന്റെ പേര് ,
ഔട്ട് സ്ട്രക്റ്റ് vldbentry *എൻട്രി) = VL_GETENTRYBYNAME;

സ്ട്രിംഗ് പാരാമീറ്ററുകൾ എപ്പോൾ ആയിരിക്കണമെന്ന് ഉപയോക്താവ് മനസ്സിലാക്കേണ്ടത് വളരെ പ്രധാനമാണ്
അവന്റെ/അവളുടെ ക്ലയന്റ് കൂടാതെ/അല്ലെങ്കിൽ സെർവർ പ്രോഗ്രാമുകൾ അനുവദിക്കുകയും കൂടാതെ/അല്ലെങ്കിൽ സ്വതന്ത്രമാക്കുകയും ചെയ്യുന്നു. ഒരു ചെറിയ വിശകലനം
സ്ട്രിംഗ് പാരാമീറ്ററുകൾ കൈകാര്യം ചെയ്യുന്നത് പിന്തുടരുന്നു (ഇത് കൈകാര്യം ചെയ്യുന്നതിനും സമാനമായ ഒരു രീതിയാണ് ഉപയോഗിക്കുന്നത് എന്നത് ശ്രദ്ധിക്കുക
വേരിയബിൾ ലെങ്ത് അറേകൾ പിന്നീട് കാണിക്കും:

· ക്ലയന്റ് ഭാഗത്ത്: IN, INOUT സ്ട്രിംഗ് പാരാമീറ്ററുകൾ പ്രോഗ്രാമറുടെ ഉത്തരവാദിത്തമാണ്
കൂടാതെ rpc-യെ വിളിക്കുന്നതിന് മുമ്പ് (സ്റ്റാറ്റിക് അല്ലെങ്കിൽ malloc വഴി) അനുവദിക്കുകയും സ്വതന്ത്രമാക്കുകയും വേണം (എങ്കിൽ
malloc ഉപയോഗിച്ചു) ഉപയോക്താവിന്റെ ക്ലയന്റ് പ്രോഗ്രാമിൽ rpc-യുടെ മടങ്ങിവരവിന് ശേഷം; തീർച്ചയായും, വേണ്ടി
INOUT പാരാമീറ്ററുകൾ, മടക്കി നൽകിയ സ്‌ട്രിംഗ് മാലോ ചെയ്‌ത ഇൻപുട്ട് സ്‌ട്രിംഗിനെക്കാൾ വലുതായിരിക്കരുത്.

OUT സ്ട്രിംഗ് പാരാമീറ്ററുകൾ സ്വയമേവ തെറ്റായി മാറുന്നു (റിട്ടേണിന്റെ ദൈർഘ്യത്തെ അടിസ്ഥാനമാക്കി
സ്ട്രിംഗ് അല്ലാതെ maxsize അല്ല) വഴി rxgen ക്ലയന്റ് അപൂർണ്ണങ്ങൾ (ഇൻ ഫയലിന്റെ പേര്.cs.c) ആയിരിക്കണം
ക്ലയന്റ് പ്രോഗ്രാം സ്വതന്ത്രമാക്കി; ഇത് ഉപയോക്താവിനെ സംബന്ധിച്ചിടത്തോളം ആശയക്കുഴപ്പമുണ്ടാക്കിയേക്കാം
അവൻ/അവൾ അനുവദിക്കാത്ത എന്തെങ്കിലും സ്വതന്ത്രമാക്കേണ്ടതുണ്ട്.}

· സെർവർ വശത്ത്: IN, INOUT സ്ട്രിംഗ് പാരാമീറ്ററുകൾ സ്വയമേവ തെറ്റായി മാറുന്നു (അടിസ്ഥാനത്തിൽ
ഇൻകമിംഗ് സ്ട്രിംഗുകളുടെ വലിപ്പം) rxgen സെർവർ സ്റ്റബുകൾ പ്രകാരം (ഇൻ ഫയലിന്റെ പേര്.ss.c) അവർക്ക് മുമ്പ്
ഉപയോക്താവിന്റെ സെർവർ നടപടിക്രമത്തിലേക്ക് കൈമാറുന്നു; സ്ഥലം സ്വയമേവ സ്വതന്ത്രമാകുന്നതിന് തൊട്ടുമുമ്പ്
rxgen സെർവർ സ്റ്റബ് തിരികെ നൽകുന്നു; അതിനാൽ ഉപയോക്താവ് IN-നായി പ്രത്യേകമായി ഒന്നും ചെയ്യേണ്ടതില്ല
കൂടാതെ INOUT സ്ട്രിംഗ് പാരാമീറ്ററുകൾ.

ഉപയോക്താവിന്റെ സെർവർ നടപടിക്രമം (അതായത് നൾ പോയിന്റർ) വഴി ഔട്ട് സ്ട്രിംഗ് പാരാമീറ്ററുകൾ മാലോ ചെയ്യപ്പെടണം
rxgen സെർവർ സ്റ്റബ് വഴി അതിലേക്ക് കൈമാറുന്നു) കൂടാതെ ഇത് അവസാനം സ്വയമേവ സ്വതന്ത്രമാക്കപ്പെടും
The rxgen സെർവർ അപൂർണ്ണം. ക്ലയന്റ് വശത്തെ പോലെ, OUT പാരാമീറ്ററുകൾ ഒരു പരിധിവരെ
അനാചാരം (അതായത്, സെർവർ പതിവ് ഒരു സ്ട്രിംഗ് ഒരിക്കലും സ്വതന്ത്രമാക്കാതെ തന്നെ അത് മാല്ലോക്ക് ചെയ്യണം;
ഇത് ചെയ്യുന്നത് rxgen സെർവർ അപൂർണ്ണം).

INOUT, OUT സ്ട്രിംഗ് പാരാമീറ്ററുകൾക്കായി, ക്ലയന്റിലും സെർവർ വശങ്ങളിലും അവയുടെ
ആർഗ്യുമെന്റുകൾ സൂചികകളുടെ പ്രതീകമായിരിക്കണം (അതായത് char **).

പോയിന്ററുകൾ
RPC-യിലെ പോയിന്റർ ഡിക്ലറേഷനുകളും C-യിൽ ഉള്ളത് പോലെയാണ് (അതായത് "struct
single_vldbentry *vldblist;"). തീർച്ചയായും, നെറ്റ്‌വർക്കിലൂടെ ഒരാൾക്ക് പോയിന്ററുകൾ അയയ്ക്കാൻ കഴിയില്ല, പക്ഷേ
ലിസ്റ്റുകളും ട്രീകളും പോലുള്ള ആവർത്തന ഡാറ്റ തരങ്ങൾ അയയ്ക്കുന്നതിന് ഒരാൾക്ക് XDR പോയിന്ററുകൾ ഉപയോഗിക്കാം (an
ലിങ്ക് ചെയ്‌ത പട്ടികയുടെ ഉദാഹരണം ഉടൻ കാണിക്കും).

അറേ
സ്ഥിരമായ അറേകൾ സാധാരണ സി അറേ ഡിക്ലറേഷനുകൾ പോലെയാണ് (അതായത് "സ്‌ട്രക്റ്റ് അപ്‌ഡേറ്റ് എൻട്രി
എൻട്രികൾ[20]") യാതൊരു പാർശ്വഫല പ്രശ്നങ്ങളും ഇല്ലാതെ rxgen. വേരിയബിൾ-ലെങ്ത് അറേകൾ ഉള്ളതിനാൽ
C-യിൽ വ്യക്തമായ വാക്യഘടനയില്ല, അതിന് ആംഗിൾ-ബ്രാക്കറ്റുകൾ ഉപയോഗിക്കുന്നു കൂടാതെ അറേ ഡിക്ലറേഷനുകളും
യഥാർത്ഥത്തിൽ "struct" ആയി സമാഹരിച്ചിരിക്കുന്നു. ഉദാഹരണത്തിന്, ഇതുപോലുള്ള പ്രഖ്യാപനങ്ങൾ:

കോൺസ്റ്റ് MAXBULKSIZE = 10000;
const MAXENTRIES = 100;
അതാര്യമായ ബൾക്ക് ; /* പരമാവധി 10000 ഇനങ്ങൾ */
int ഹോസ്റ്റുകൾ<>; /* എത്ര ഇനങ്ങൾ */
typedef vldbentry blkentries<100>; /* അഭികാമ്യമായ അറേ decl */

ഇനിപ്പറയുന്ന ഘടനകളായി സമാഹരിച്ചിരിക്കുന്നു:

നിർമ്മിക്കുക {
u_int bulk_len; /* ഇനങ്ങളുടെ എണ്ണം */
ചാർ *ബൾക്ക്_വൽ; /* അറേയിലേക്കുള്ള പോയിന്റർ */
} ബൾക്ക്;

"ബൾക്ക്" അറേയ്‌ക്കും അതുപോലെ "blkentries<100>" അറേയ്‌ക്കും,

നിർമ്മിക്കുക {
u_int blkentries_len; /* നിരയിലുള്ള ഇനങ്ങളുടെ എണ്ണം */
vldbentry *blkentries_val; /* അറേയിലേക്കുള്ള പോയിന്റർ */
} ബ്ലെൻട്രികൾ;

അതിനാൽ, "മാന്ത്രികമായി" സൃഷ്ടിച്ച ഘടനാപരമായ എൻട്രികളെക്കുറിച്ച് ഉപയോക്താവ് അറിഞ്ഞിരിക്കണം
അറേയിലെ ഇനങ്ങളുടെ എണ്ണം ( _len) കൂടാതെ അറേയിലേക്കുള്ള പോയിന്ററും
( _val) എന്നതിൽ നിന്ന് ചില എൻട്രികൾ പൂരിപ്പിക്കേണ്ടതുണ്ട്
ക്ലയന്റ്/സെർവർ പ്രോഗ്രാമുകൾ. ഒരു സാമ്പിൾ പ്രോക് ഇതായിരിക്കും:

typedef vldbentry blkentries ;
proc GetBlk (OUT blkentries *vlentries) = VL_GETBLK;

അല്ലെങ്കിൽ, കൂടുതൽ നേരിട്ട്,

GetBlk(OUT vldbentry vlentries ) = VL_GETBLK;

ഏറ്റവും പുതിയ രീതി ആണെങ്കിലും ആദ്യം ഉപയോഗിക്കേണ്ടതില്ല എന്നതിനാൽ ശ്രദ്ധിക്കുക
ടൈപ്പ്ഡെഫ് സ്റ്റേറ്റ്മെന്റ് (ഒപ്പം, പ്രോഗ്രാമർമാർ ടൈപ്പ്ഡെഫുകൾ ഒഴിവാക്കാൻ ഇഷ്ടപ്പെടുന്നു), ഒരാൾ ചെയ്യണം
അത് തിരിച്ചറിയുക rxgen ഘടന വികാസവും xdr സൃഷ്ടിയും പരോക്ഷമായി ചെയ്യുന്നു; അതുകൊണ്ടു
"vldbentries_val", "vldbentries_len" എന്നീ ഫീൽഡുകളെക്കുറിച്ച് ഉപയോക്താവ് മുമ്പത്തെപ്പോലെ അറിഞ്ഞിരിക്കണം
(ഇനിപ്പറയുന്ന ഉദാഹരണങ്ങൾ കാണുക).

അറേ ഉദാഹരണം I (കുറഞ്ഞത് അഭികാമ്യം)

ഇന്റർഫേസ് കോൺഫിഗറേഷനിലെ നടപടിക്രമ പ്രഖ്യാപനം:

proc ListAttributes (IN vldblistbyattributes *ആട്രിബ്യൂട്ടുകൾ,
INOUT blkentries *vldbentries) = VL_LISTATTRIBUTES;

സാമ്പിൾ ക്ലയന്റ് കോഡ്:

blkentries എൻട്രികൾ, *pnt;
entries.blkentries_len = 10; /* പരമാവധി # റിട്ടേൺ എൻട്രികൾ */
entries.blkentries_val = (vldbentry *)malloc(LEN);
/* ഇത് സജ്ജീകരിച്ചിരിക്കണം */

കോഡ് = VL_ListAttributes(&ആട്രിബ്യൂട്ടുകൾ, & എൻട്രികൾ);
എങ്കിൽ (!കോഡ്) {
pnt = entries.blkentries_val;
ഇതിനായി (i=0; i < entries.blkentries_len; i++, pnt++)
display_vldbentry(pnt);
/* അനുവദിച്ച സ്ഥലം നിങ്ങൾ സ്വതന്ത്രമാക്കുന്നുവെന്ന് ഉറപ്പാക്കുക */
സ്വതന്ത്ര((char *)entries.blkentries_val);
}

സാമ്പിൾ സെർവർ കോഡ്:

VL_ListAttributes(ആട്രിബ്യൂട്ടുകൾ, എൻട്രികൾ)
{
vldbentry *singleentry = എൻട്രികൾ->blkentries_val;
എൻട്രികൾ->blkentries_len = 0;

അതേസമയം (copy_to_vldbentry(&vlentry, singleentry))
singleentry++, vldbentries->entries_len++;
}

വേരിയബിൾ-സൈസ് അറേകൾക്കുള്ള ഈ രീതി നന്നായി പ്രവർത്തിക്കുന്നുണ്ടെങ്കിലും, ചില പ്രധാന പോരായ്മകളുണ്ട്.
നമുക്ക് ആവശ്യമുള്ളതിനാൽ അറേ പാരാമീറ്റർ (അതായത് മുകളിലെ vldbentries) INOUT ആയി പ്രഖ്യാപിക്കണം
പ്രതീക്ഷിക്കുന്ന റിട്ടേൺ അറേയുടെ പരമാവധി ദൈർഘ്യം കടന്നുപോകുക; കൂടുതൽ പ്രധാനമായി, ഒരു വലിയ (അതിനെ ആശ്രയിച്ച്
ജങ്ക് കോഡിന്റെ "_len") മൂല്യം സെർവറിലേക്ക് മാറ്റാൻ പോകുന്നു
അറേയുടെ IN(ഔട്ട്) പാർശ്വഫലത്തിന്റെ. എങ്കിൽ ഇത് എളുപ്പവും സൗകര്യപ്രദവുമായ മാർഗ്ഗമാണ്
തിരിച്ചുവന്ന അറേയുടെ വലിപ്പം ആരംഭം മുതലേ പ്രവചിക്കാം, വലിപ്പം വളരെ ഉയർന്നതായിരിക്കുമ്പോൾ. ഈ
തെറ്റായ ഉപയോഗത്തിന്റെ (ദുരുപയോഗം) ഒരു ഉദാഹരണമായി ഈ രീതി ഉൾപ്പെടുത്തിയിട്ടുണ്ട് rxgen ഉണ്ടാകരുത്
ഉപയോഗിച്ചു.

അറേ ഉദാഹരണം II (ആവശ്യമുള്ളത് രീതി)

ഇന്റർഫേസ് കോൺഫിഗറേഷനിലെ നടപടിക്രമ പ്രഖ്യാപനം (മുകളിലുള്ള ഉദാഹരണം ഉപയോഗിച്ച്):

proc ListAttributes (IN vldblistbyattributes *ആട്രിബ്യൂട്ടുകൾ,
ഔട്ട് ബ്ലെൻട്രികൾ *vldbentries) = VL_LISTATTRIBUTES;

സാമ്പിൾ ക്ലയന്റ് കോഡ്:

blkentries എൻട്രികൾ, *pnt;

കോഡ് = VL_ListAttributes(&ആട്രിബ്യൂട്ടുകൾ, & എൻട്രികൾ);
എങ്കിൽ (!കോഡ്) {
pnt = entries.blkentries_val;
ഇതിനായി (i=0; i < entries.blkentries_len; i++, pnt++)
display_vldbentry(pnt);
/* അനുവദിച്ച സ്ഥലം നിങ്ങൾ സ്വതന്ത്രമാക്കുന്നുവെന്ന് ഉറപ്പാക്കുക (rxgen വഴി) */
സ്വതന്ത്ര((char *)entries.blkentries_val);
}

സാമ്പിൾ സെർവർ കോഡ്:

VL_ListAttributes(ആട്രിബ്യൂട്ടുകൾ, എൻട്രികൾ)
{
vldbentry *Singleentry;
എൻട്രികൾ->blkentries_len = 0;
singleentry = entries->blkentries_val
= (vldbentry *)malloc(MAXENTRIES * sizeof(vldbentry));

അതേസമയം (copy_to_vldbentry(&vlentry, singleentry))
singleentry++, vldbentries->entries_len++;
}

ഒരു ഔട്ട്പുട്ട് പാരാമീറ്ററായി വേരിയബിൾ-സൈസ് അറേകൾ ഉപയോഗിക്കുന്നതിനുള്ള ഏറ്റവും മികച്ച (ഏറ്റവും ലളിതമായ) മാർഗമാണിത്.
ഇത് സെർവർ സൈഡ് സ്റ്റബിന്റെ ഉത്തരവാദിത്തമാണ് malloc () മതിയായ ഇടം
സ്വയമേവ സ്വതന്ത്രമാക്കുന്നു rxgen അപൂർണ്ണം; ക്ലയന്റ് വശം അനുവദിച്ച സ്ഥലം സ്വതന്ത്രമാക്കണം
The rxgen- കോളിംഗ് അപൂർണ്ണം.

അറേ ഉദാഹരണം III (ലിങ്ക്ഡ് ലിസ്റ്റുകൾ)

ഇനിപ്പറയുന്ന 3 പ്രഖ്യാപനങ്ങൾ പരിഗണിക്കുമ്പോൾ (ചില ഒപ്റ്റിമൈസേഷനുകൾ പ്രയോഗിക്കാമായിരുന്നു).
കോൺഫിഗറേഷൻ ഫയൽ:

ടൈപ്പ്ഡെഫ് സ്ട്രക്റ്റ് സിംഗിൾ_വ്ൽഡ്ബെൻട്രി *വിഎൽഡിബ്ലിസ്റ്റ്;
struct single_vldbentry {
vldbentry vlentry;
vldblist next_vldb;
};

struct vldb_list {
vldblist നോഡ്;
};

കൂടാതെ rxgen നടപടിക്രമ പ്രഖ്യാപനവും:

ലിങ്ക്ഡ്‌ലിസ്റ്റ് (IN vldblistbyattributes *ആട്രിബ്യൂട്ടുകൾ,
OUT vldb_list *linkedentries) = VL_LINKEDLIST;

സാമ്പിൾ ക്ലയന്റ് കോഡ്:

vldb_list linkedvldbs;
vldblist vllist, vllist1;

bzero (&linkedvldbs, sizeof(vldb_list));
കോഡ് = VL_LinkedList(&ആട്രിബ്യൂട്ടുകൾ, &nentries, &linkedvldbs);
എങ്കിൽ (!കോഡ്) {
printf("ഞങ്ങൾക്ക് %d vldb എൻട്രികൾ ലഭിച്ചു\n", nentries);
ഇതിനായി (vllist = linkedvldbs.node; vllist; vllist = vllist1) {
vllist1 = vllist->next_vldb;
display_entry (&vllist->vlentry);
free((char *)vllist);
}
}

സാമ്പിൾ സെർവർ കോഡ്:

VL_LinkedList(rxcall, attributes, nentries, linkedvldbs);
{
vldblist vllist, *vllistptr = &linkedvldbs->നോഡ്;
അതേസമയം (...) {
vllist = *vllistptr
= (single_vldbentry *)malloc (sizeof (single_vldbentry));
copy_to_vldbentry(&tentry, &vllist->vlentry);
എൻട്രികൾ++;
vllistptr = &vllist->next_vldb;
};
*vllistptr = NULL;
}

ഒരു ലിങ്ക് ചെയ്‌ത ലിസ്‌റ്റ് ഉപയോഗിക്കുന്നത് നിരവധി ഗുണങ്ങൾ നൽകുന്നു: സെർവറിലേക്ക് ഒന്നും കൈമാറില്ല (പാരാമീറ്റർ
ഔട്ട് ആണ്), അധിക ഓവർഹെഡ് ഉൾപ്പെട്ടിട്ടില്ല, കൂടാതെ വിളിക്കുന്നയാൾ വ്യക്തമായി പറയേണ്ടതില്ല
അനിയന്ത്രിതമായ റിട്ടേൺ വലുപ്പത്തിനായി തയ്യാറെടുക്കുക. ഒരു പോരായ്മ വിളിക്കുന്നയാൾക്ക് ഉണ്ട് എന്നതാണ്
യുടെ ഉത്തരവാദിത്തം malloc () (സെർവറിൽ) കൂടാതെ ഓരോ എൻട്രിയുടെയും (ടു
അനാവശ്യ കോർ-ലീക്കുകൾ ഒഴിവാക്കുക). മറ്റൊരു പോരായ്മ, ഇതൊരു ആവർത്തന കോളായതിനാൽ, സി
ലിസ്റ്റിലെ നോഡുകളുടെ എണ്ണവുമായി ബന്ധപ്പെട്ട് സ്റ്റാക്ക് രേഖീയമായി വളരും (അതിനാൽ ഇത് നല്ലതാണ്
വലിയ അളവിലുള്ള ഡാറ്റ തിരികെ പ്രതീക്ഷിക്കുന്നുവെങ്കിൽ Rx LWP സ്റ്റാക്ക് വർദ്ധിപ്പിക്കുക -- ഡിഫോൾട്ട് സ്റ്റാക്ക് സൈസ്
4K ആണ്). ഗുണങ്ങൾ ഇവിടെ ദോഷങ്ങളേക്കാൾ കൂടുതലായിരിക്കണം.

മുകളിലുള്ള മൂന്ന് അറേ ഉദാഹരണങ്ങളുടെ അഭിപ്രായങ്ങൾ ശ്രദ്ധിക്കേണ്ടത് പ്രധാനമാണ്
വിശേഷിച്ചും ഉപയോക്താവ് എപ്പോഴാണ് ഇതിനായി സ്ഥലം അനുവദിക്കേണ്ടത്/സ്വതന്ത്രമാക്കേണ്ടത് എന്നതിനെ കുറിച്ചുള്ള അവലംബങ്ങൾ
വേരിയബിൾ നീളം അറേകൾ. ഈ മെക്കാനിസം സ്ട്രിംഗുകൾ കൈകാര്യം ചെയ്യുന്നതുമായി വളരെ സാമ്യമുള്ളതാണ്
മുകളിലുള്ള സ്ട്രിംഗുകളുടെ വിഭാഗം അവലോകനം ചെയ്യേണ്ടതായി വന്നേക്കാം; ലിങ്ക് ചെയ്ത ലിസ്റ്റുകൾ കൈകാര്യം ചെയ്യുന്നത് ശ്രദ്ധിക്കുക
കുറച്ച് വ്യത്യസ്തമായി...

കലര്പ്പായ ഉദാഹരണങ്ങൾ
പൊതുവായ ചിലത് കാണിക്കുന്ന ഒരു റാൻഡം ഇന്റർഫേസ് ഫയലിന്റെ ഒരു സംക്ഷിപ്ത പതിപ്പ് ചുവടെയുണ്ട്
കേസുകൾ.

/* R.xg സ്ക്രിപ്റ്റ് ഇന്റർഫേസ് ഉപയോഗിക്കുന്ന എല്ലാ ഘടനകളുടെയും പ്രഖ്യാപനം */

ഘടന AFSFid {
ഒപ്പിടാത്ത നീണ്ട വോളിയം;
ഒപ്പിടാത്ത നീളമുള്ള Vnode;
ഒപ്പിടാത്ത നീണ്ട തനത്;
};

ടൈപ്പ്ഡെഫ് നീളമുള്ള വൈസ്ഡാറ്റടൈപ്പ്;

/* TEST എന്നത് "HEADER" എന്നതിന് തുല്യമായിരിക്കുമെന്നത് ശ്രദ്ധിക്കുക
തലക്കെട്ടിന്റെ പ്രോസസ്സിംഗ്, *.h, ഫയൽ */

#ifdef RPC_HDR
#ടെസ്റ്റ് "ഹെഡർ" നിർവചിക്കുക
# കൂടാതെ
#ടെസ്റ്റ് "വിശ്രമം" നിർവ്വചിക്കുക
#അവസാനം

/* ഇതാണ് സ്റ്റാൻഡേർഡ് *.xg സ്പെസിഫിക്കേഷൻ ഫയൽ */

പാക്കേജ് AFS_
splitprefix IN=BEFORE_ OUT=AFTER_;
പ്രിഫിക്സ് ടെസ്റ്റ്

proc നീക്കം ചെയ്യുക(IN struct AFSFid *Did, IN string volname<64>,
ഔട്ട് സ്ട്രക്റ്റ് AFSStatus *സ്റ്റാറ്റസ്) = AFS_REMOVE;

DisconnectFS AUX_disconnectFS() = AFS_DISCONNECTFS;

proc GetVolumeInfo(ഇൻ സ്ട്രിംഗ് വിഡി,
ഔട്ട് സ്ട്രക്റ്റ് വോളിയം ഇൻഫോ *വിവരം) = AFS_GETVOLUMEINFO;

/* നിങ്ങൾക്ക് ഒരു കോൺഫിഗറേഷനിൽ കൂടുതൽ ഇന്റർഫേസ് ഉണ്ടായിരിക്കാം */

പാക്കേജ് VOTE_

/* "മൾട്ടി" ഫീച്ചർ ഉപയോഗിക്കുന്നു; അങ്ങനെ VOTE_Beacon നെ വിളിക്കാം
മൾട്ടി-ആർഎക്സ് കോൾ അല്ലെങ്കിൽ ഒരു സാധാരണ കോളായി */

ബീക്കൺ (നീണ്ട അവസ്ഥയിൽ, നീണ്ട വോട്ട് ആരംഭം,
net_version *പതിപ്പ്, net_tid *tid)
മൾട്ടി = VOTE_BEACON;

പാക്കേജ് DISK_

/* "സ്പ്ലിറ്റ്" സവിശേഷത ഉപയോഗിച്ച് */

SendFile (നീളമുള്ള ഫയലിൽ, നീണ്ട ഓഫ്‌സെറ്റ്,
നീളം, net_version *പതിപ്പ്)
വിഭജനം = DISK_SENDFILE;

ഔട്ട്പുട്ട് of an യഥാർത്ഥ ഇന്റർഫേസ് കോൺഫിഗറേഷൻ
സൃഷ്ടിച്ച യഥാർത്ഥ ഔട്ട്പുട്ടിൽ ചിലത് ഞങ്ങൾ പ്രദർശിപ്പിക്കും rxgen ഒരു ചുരുക്കി പിന്തുടർന്ന്
യഥാർത്ഥ ഇന്റർഫേസ് കോൺഫിഗറേഷൻ.

കോൺഫിഗറേഷൻ ഫയല്

ഇന്റർഫേസ് കോൺഫിഗറേഷൻ ഫയലിന്റെ ഉള്ളടക്കം (vldbint.xg):

പാക്കേജ് VL_
#include "vl_opcodes.h" /* ഒപ്‌കോഡുകൾ ഇവിടെ ഉൾപ്പെടുത്തിയിട്ടുണ്ട് */
% #"vl_opcodes.h" /* നേരിട്ട് മറ്റ് സ്ഥലങ്ങളിലേക്ക് */

/* മറ്റ് പാക്കേജുകളെ ബാധിക്കുന്ന പാരാമീറ്ററുകളുടെ നിലവിലെ പരിമിതികൾ
(അതായത് വോളിയം) */

കോൺസ്റ്റ് MAXNAMELEN = 65;
const MAXNSERVERS = 8;
const MAXTYPES = 3;

/* ഒരു വ്യക്തിഗത vldb എൻട്രിയുടെ ബാഹ്യ (ദൃശ്യമായ) പ്രാതിനിധ്യം */

സ്ട്രക്റ്റ് vldbentry {
പ്രതീക നാമം[MAXNAMELEN];
നീണ്ട വോള്യം തരം;
നീണ്ട എൻസെർവറുകൾ;
നീണ്ട സെർവർ നമ്പർ[MAXNSERVERS];
നീണ്ട സെർവർ പാർട്ടീഷൻ[MAXNSERVERS];
നീണ്ട സെർവർ ഫ്ലാഗുകൾ[MAXNSERVERS];
u_long volumeId[MAXTYPES];
നീണ്ട പതാകകൾ;
};

ടൈപ്പ്ഡെഫ് സ്ട്രക്റ്റ് സിംഗിൾ_വ്ൽഡ്ബെൻട്രി *വിഎൽഡിബ്ലിസ്റ്റ്;
struct single_vldbentry {
vldbentry VldbEntry;
vldblist next_vldb;
};

struct vldb_list {
vldblist നോഡ്;
};

/* vldb ഇന്റർഫേസ് കോളുകൾ */

CreateEntry (നീണ്ട ശാശ്വതത്തിൽ,
vldbentry *newentry) = VLCREATEENTRY;

GetEntryByName (സ്‌ട്രിംഗ് വോളിയം നാമത്തിൽ ,
ഔട്ട് vldbentry *പ്രവേശനം) = VLGETENTRYBYNAME;

GetNewVolumeId (നീണ്ട ബംപ്‌കൗണ്ടിൽ,
ദൈർഘ്യമേറിയ *ന്യൂവോലൂമിഡ്) = VLGETNEWVOLUMEID;

റീപ്ലേസ് എൻട്രി (നീണ്ട വോളിഡിൽ,
നീണ്ട വോൾട്ടൈപ്പ്,
vldbentry *newentry,
നീണ്ട റിലീസ് ടൈപ്പ്) മൾട്ടി = VLREPLACEENTRY;

ലിസ്റ്റ് ആട്രിബ്യൂട്ടുകൾ (IN VldbListByAttributes *ആട്രിബ്യൂട്ടുകൾ,
ഔട്ട് ലോംഗ് *എൻട്രികൾ,
ഔട്ട് vldbentry ബൾക്കന്ററികൾ )
= VLLISTATTRIBUTES;

LinkedList (IN VldbListByAttributes *ആട്രിബ്യൂട്ടുകൾ,
ഔട്ട് ലോംഗ് *എൻട്രികൾ,
OUT vldb_list *linkedentries) = VLLINKEDLIST;

R സൃഷ്ടിച്ച കോഡ് മുതൽ ഞങ്ങൾ Rx ജനറേറ്റഡ് കോഡിൽ മാത്രം ശ്രദ്ധ കേന്ദ്രീകരിക്കും (-R ഓപ്ഷൻ)
താമസിയാതെ കാലഹരണപ്പെടും. ഉള്ളിലെ Rx-മായി ബന്ധപ്പെട്ട കോളുകളെക്കുറിച്ചുള്ള വിശദമായ വിവരണത്തിന്
സൃഷ്ടിച്ച അപൂർണ്ണലേഖനങ്ങൾ (അതായത്, rx_NewCall(), rx_EndCall()), എന്താണ് സംഭവിക്കുന്നത് എന്നതിനെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾ സഹിതം
ചില കോളുകൾക്കുള്ളിൽ (ഇത് പോലെ xdrrx_create()) ദയവായി Rx ഡോക്യുമെന്റേഷൻ പരിശോധിക്കുക. ടൈപ്പിംഗ്
"rxgen vldbint.xg" നാല് ഫയലുകൾ സൃഷ്ടിക്കുന്നതിന് കാരണമാകും: vldbint.h, vldbint.xdr.c,
vldbint.cs.c ഒപ്പം vldbint.ss.c. ഈ ഫയലുകളെ അടുത്തറിയാൻ താഴെ കൊടുക്കുന്നു.

ഹെഡ്ഡർ ഫയല് (vldbint.h)

/* മെഷീൻ ജനറേറ്റഡ് ഫയൽ -- എഡിറ്റ് ചെയ്യരുത് */

# "vl_opcodes.h" /* നേരിട്ട് മറ്റ് സ്ഥലങ്ങളിലേക്ക് */ ഉൾപ്പെടുത്തുക
#MAXNAMELEN 65 നിർവ്വചിക്കുക
#നിർവ്വചിക്കുക MAXNSERVERS 8
#നിർവ്വചിക്കുക MAXTYPES 3

സ്ട്രക്റ്റ് vldbentry {
പ്രതീക നാമം[MAXNAMELEN];
നീണ്ട വോള്യം തരം;
നീണ്ട എൻസെർവറുകൾ;
നീണ്ട സെർവർ നമ്പർ[MAXNSERVERS];
നീണ്ട സെർവർ പാർട്ടീഷൻ[MAXNSERVERS];
നീണ്ട സെർവർ ഫ്ലാഗുകൾ[MAXNSERVERS];
u_long volumeId[MAXTYPES];
നീണ്ട പതാകകൾ;
};
ടൈപ്പ്ഡെഫ് സ്ട്രക്റ്റ് vldbentry vldbentry;
bool_t xdr_vldbentry();

ടൈപ്പ്ഡെഫ് സ്ട്രക്റ്റ് സിംഗിൾ_വ്ൽഡ്ബെൻട്രി *വിഎൽഡിബ്ലിസ്റ്റ്;
bool_t xdr_vldblist();

struct single_vldbentry {
vldbentry VldbEntry;
vldblist next_vldb;
};
ടൈപ്പ്ഡെഫ് സ്ട്രക്റ്റ് സിംഗിൾ_വ്ൽഡ്ബെൻട്രി സിംഗിൾ_വ്ൽഡ്ബെൻട്രി;
bool_t xdr_single_vldbentry();

struct vldb_list {
vldblist നോഡ്;
};
ടൈപ്പ്ഡെഫ് സ്ട്രക്റ്റ് vldb_list vldb_list;
bool_t xdr_vldb_list();

#ഉൾപ്പെടുന്നു
#നിർവ്വചിക്കുക മൾട്ടി_VL_ReplaceEntry (Volid, voltype, newentry, ReleaseType) \
മൾട്ടി_ബോഡി(StartVL_ReplaceEntry(multi_call, Volid, voltype,
ന്യൂ എൻട്രി, റിലീസ് തരം), EndVL_ReplaceEntry(multi_call))

ടൈപ്പ്ഡെഫ് സ്ട്രക്റ്റ് ബൾക്കന്ററികൾ {
u_int bulkentries_len;
vldbentry *bulkentries_val;
} ബൾക്കന്ററികൾ;
bool_t xdr_bulkentries();

/* പാക്കേജിനായുള്ള ഒപ്‌കോഡുമായി ബന്ധപ്പെട്ട ഉപയോഗപ്രദമായ സ്ഥിതിവിവരക്കണക്കുകൾ: VL_ */
#VL_LOWEST_OPCODE 501 നിർവ്വചിക്കുക
#VL_HIGHEST_OPCODE 506 നിർവചിക്കുക
#നിർവ്വചിക്കുക VL_NUMBER_OPCODES 6

എല്ലാ ഘടനകളും സ്വയമേവ ടൈപ്പ് ചെയ്യപ്പെടുകയും എല്ലാ "const"-കളിലേക്ക് പരിവർത്തനം ചെയ്യപ്പെടുകയും ചെയ്യുന്നു എന്നത് ശ്രദ്ധിക്കുക
"#നിർവചിക്കുക". ബൾക്കന്ററികൾ പോലെയുള്ള ചില ഡാറ്റാ ഘടനകൾ നടപടിക്രമ പാരാമുകളിൽ നിന്ന് എടുത്തതാണ്
(ListAttributes proc-ൽ നിന്ന്). അതിനാൽ, അപൂർണ്ണലേഖനങ്ങൾ സൃഷ്ടിക്കുമ്പോൾ ഇത് മനസ്സിൽ സൂക്ഷിക്കണം
കൂടെ കഷണം rxgen (അതായത്, ഉപയോഗിക്കുന്നത് -c, -h, -C, അഥവാ -S പതാകകൾ). കൂടാതെ, ഒരു വശത്ത്
"മൾട്ടി" ഓപ്ഷന്റെ ഇഫക്റ്റുകൾ ("ReplaceEntry" proc-ൽ) ജനറേഷൻ ആണ്
മുകളിൽ "multi_VL_ReplaceEntry".

XDR ദിനചര്യകൾ വേണ്ടി ഘടനകളെ (vldbint.xdr.c)

/* മെഷീൻ ജനറേറ്റഡ് ഫയൽ -- എഡിറ്റ് ചെയ്യരുത് */

#ഉൾപ്പെടുന്നു
#"vldbint.h" ഉൾപ്പെടുത്തുക

# "vl_opcodes.h" /* നേരിട്ട് മറ്റ് സ്ഥലങ്ങളിലേക്ക് */ ഉൾപ്പെടുത്തുക

bool_t
xdr_vldbentry(xdrs, objp)
XDR *xdrs;
vldbentry *objp;
{
എങ്കിൽ (!xdr_vector(xdrs, (char *)objp->പേര്, MAXNAMELEN,
sizeof(char), xdr_char))
മടക്കം (FALSE);
എങ്കിൽ (!xdr_long(xdrs, &objp->volumeType))
മടക്കം (FALSE);
എങ്കിൽ (!xdr_long(xdrs, &objp->nServers))
മടക്കം (FALSE);
എങ്കിൽ (!xdr_vector(xdrs, (char *)objp->serverNumber, MAXNSERVERS,
വലിപ്പം(നീളം), xdr_long))
മടക്കം (FALSE);
എങ്കിൽ (!xdr_vector(xdrs, (char *)objp->serverPartition,
MAXNSERVERS, വലിപ്പം(നീളം), xdr_long))
മടക്കം (FALSE);
എങ്കിൽ (!xdr_vector(xdrs, (char *)objp->serverFlags, MAXNSERVERS,
വലിപ്പം(നീളം), xdr_long))
മടക്കം (FALSE);
എങ്കിൽ (!xdr_vector(xdrs, (char *)objp->volumeId, MAXTYPES,
വലിപ്പം (u_long), xdr_u_long))
മടക്കം (FALSE);
എങ്കിൽ (!xdr_long(xdrs, &objp->പതാകകൾ))
മടക്കം (FALSE);
മടക്കം (TRUE);
}

bool_t
xdr_vldblist(xdrs, objp)
XDR *xdrs;
vldblist *objp;
{
എങ്കിൽ (!xdr_pointer(xdrs, (char **)objp,
വലിപ്പം(struct single_vldbentry),
xdr_single_vldbentry))
മടക്കം (FALSE);
മടക്കം (TRUE);
}

bool_t
xdr_single_vldbentry(xdrs, objp)
XDR *xdrs;
single_vldbentry *objp;
{
എങ്കിൽ (!xdr_vldbentry(xdrs, &objp->VldbEntry))
മടക്കം (FALSE);
എങ്കിൽ (!xdr_vldblist(xdrs, &objp->next_vldb))
മടക്കം (FALSE);
മടക്കം (TRUE);
}

bool_t
xdr_vldb_list(xdrs, objp)
XDR *xdrs;
vldb_list *objp;
{
എങ്കിൽ (!xdr_vldblist(xdrs, &objp->നോഡ്))
മടക്കം (FALSE);
മടക്കം (TRUE);
}

bool_t
xdr_bulkentries(xdrs, objp)
XDR *xdrs;
ബൾക്കൻട്രികൾ *objp;
{
എങ്കിൽ (!xdr_array(xdrs, (char **)&objp->bulkentries_val,
(u_int *)&objp->bulkentries_len, MAXVLDBLEN,
sizeof(vldbentry), xdr_vldbentry))
മടക്കം (FALSE);
മടക്കം (TRUE);
}

ശ്രദ്ധിക്കുക xdr_bulkentries() ഒരു നടപടിക്രമത്തിന്റെ പാർശ്വഫലമായി യാന്ത്രികമായി സൃഷ്ടിക്കപ്പെടുന്നു
പാരാമീറ്റർ പ്രഖ്യാപനം. അങ്ങനെ, ഒരേ ഒന്നിലധികം തരം പാരാമീറ്റർ ഡിക്ലറേഷനുകൾ ഉപയോഗിക്കുകയാണെങ്കിൽ,
തുടർന്ന് ഗുണന-നിർവചിക്കപ്പെട്ട xdr_* അപൂർണ്ണലേഖനങ്ങൾ സൃഷ്ടിക്കപ്പെടും! ഇതൊരു മികച്ച ബദലാണെന്ന് ഞങ്ങൾക്ക് തോന്നി
ഉള്ളതിന് rxgen ബൾക്കന്റീസ്_1, ബൾക്കൻറീസ്_2 തുടങ്ങിയ തരങ്ങളുമായി പ്രോഗ്രാമർ ഇടപെടുന്നു...

ക്ലയന്റ്-സൈഡ് സ്റ്റബ്ബ് ദിനചര്യകൾ (vldbint.cs.c)

/* മെഷീൻ ജനറേറ്റഡ് ഫയൽ -- എഡിറ്റ് ചെയ്യരുത് */

#ഉൾപ്പെടുന്നു
#ഉൾപ്പെടുന്നു
#ഉൾപ്പെടുന്നു
#"vldbint.h" ഉൾപ്പെടുത്തുക

# "vl_opcodes.h" /* നേരിട്ട് മറ്റ് സ്ഥലങ്ങളിലേക്ക് */ ഉൾപ്പെടുത്തുക

int VL_CreateEntry(z_conn, Volid, newentry)
രജിസ്റ്റർ struct rx_connection *z_conn;
നീണ്ട വോളിഡ്;
vldbentry * ന്യൂ എൻട്രി;
{
struct rx_call *z_call = rx_NewCall(z_conn);
സ്റ്റാറ്റിക് ഇൻറ്റ് z_op = 501;
int z_ഫലം;
XDR z_xdrs;

xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

/* വാദങ്ങൾ മാർഷൽ */
എങ്കിൽ ((!xdr_int(&z_xdrs, &z_op))
|| (!xdr_long(&z_xdrs, &Volid))
|| (!xdr_vldbentry(&z_xdrs, newentry))) {
z_ഫലം = RXGEN_CC_MARSHAL;
പരാജയപ്പെട്ടു;
}

z_ഫലം = RXGEN_SUCCESS;
പരാജയം:
റിട്ടേൺ rx_EndCall(z_call, z_result);
}

int VL_GetEntryByName(z_conn, volumename, entry)
രജിസ്റ്റർ struct rx_connection *z_conn;
ചാർ * വോളിയം നാമം;
vldbentry * പ്രവേശനം;
{
struct rx_call *z_call = rx_NewCall(z_conn);
സ്റ്റാറ്റിക് ഇൻറ്റ് z_op = 504;
int z_ഫലം;
XDR z_xdrs;

xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

/* വാദങ്ങൾ മാർഷൽ */
എങ്കിൽ ((!xdr_int(&z_xdrs, &z_op))
|| (!xdr_string(&z_xdrs, &വാള്യം, 65))) {
z_ഫലം = RXGEN_CC_MARSHAL;
പരാജയപ്പെട്ടു;
}

/* അൺ-മാർഷൽ ദി റിപ്ലൈ ആർഗ്യുമെന്റുകൾ */
z_xdrs.x_op = XDR_DECODE;
എങ്കിൽ ((!xdr_vldbentry(&z_xdrs, എൻട്രി))) {
z_result = RXGEN_CC_UNMARSHAL;
പരാജയപ്പെട്ടു;
}

z_ഫലം = RXGEN_SUCCESS;
പരാജയം:
റിട്ടേൺ rx_EndCall(z_call, z_result);
}

int VL_GetNewVolumeId(z_conn, bumpcount, newvolumid)
രജിസ്റ്റർ struct rx_connection *z_conn;
നീണ്ട ബമ്പ് കൗണ്ട്;
നീളം * ന്യൂവോലുമിഡ്;
{
struct rx_call *z_call = rx_NewCall(z_conn);
സ്റ്റാറ്റിക് ഇൻറ്റ് z_op = 505;
int z_ഫലം;
XDR z_xdrs;

xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

/* വാദങ്ങൾ മാർഷൽ */
എങ്കിൽ ((!xdr_int(&z_xdrs, &z_op))
|| (!xdr_long(&z_xdrs, &bumpcount)) {
z_ഫലം = RXGEN_CC_MARSHAL;
പരാജയപ്പെട്ടു;
}

/* അൺ-മാർഷൽ ദി റിപ്ലൈ ആർഗ്യുമെന്റുകൾ */
z_xdrs.x_op = XDR_DECODE;
എങ്കിൽ ((!xdr_long(&z_xdrs, newvolumid))) {
z_result = RXGEN_CC_UNMARSHAL;
പരാജയപ്പെട്ടു;
}

z_ഫലം = RXGEN_SUCCESS;
പരാജയം:
റിട്ടേൺ rx_EndCall(z_call, z_result);
}

int VL_ReplaceEntry(z_conn, Volid, voltype, newentry, ReleaseType)
രജിസ്റ്റർ struct rx_connection *z_conn;
നീണ്ട വോളിഡ്, വോൾടൈപ്പ്, റിലീസ് ടൈപ്പ്;
vldbentry * ന്യൂ എൻട്രി;
{
struct rx_call *z_call = rx_NewCall(z_conn);
സ്റ്റാറ്റിക് ഇൻറ്റ് z_op = 506;
int z_ഫലം;
XDR z_xdrs;

xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

/* വാദങ്ങൾ മാർഷൽ */
എങ്കിൽ ((!xdr_int(&z_xdrs, &z_op))
|| (!xdr_long(&z_xdrs, &Volid))
|| (!xdr_long(&z_xdrs, &voltype))
|| (!xdr_vldbentry(&z_xdrs, newentry))
|| (!xdr_long(&z_xdrs, &ReleaseType))) {
z_ഫലം = RXGEN_CC_MARSHAL;
പരാജയപ്പെട്ടു;
}

z_ഫലം = RXGEN_SUCCESS;
പരാജയം:
റിട്ടേൺ rx_EndCall(z_call, z_result);
}

int StartVL_ReplaceEntry(z_call, Volid, voltype, newentry, ReleaseType)
രജിസ്റ്റർ struct rx_call *z_call;
നീണ്ട വോളിഡ്, വോൾടൈപ്പ്, റിലീസ് ടൈപ്പ്;
vldbentry * ന്യൂ എൻട്രി;
{
സ്റ്റാറ്റിക് ഇൻറ്റ് z_op = 506;
int z_ഫലം;
XDR z_xdrs;

xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

/* വാദങ്ങൾ മാർഷൽ */
എങ്കിൽ ((!xdr_int(&z_xdrs, &z_op))
|| (!xdr_long(&z_xdrs, &Volid))
|| (!xdr_long(&z_xdrs, &voltype))
|| (!xdr_vldbentry(&z_xdrs, newentry))
|| (!xdr_long(&z_xdrs, &ReleaseType))) {
z_ഫലം = RXGEN_CC_MARSHAL;
പരാജയപ്പെട്ടു;
}

z_ഫലം = RXGEN_SUCCESS;
പരാജയം:
തിരികെ z_ഫലം;
}

int EndVL_ReplaceEntry(z_call)
രജിസ്റ്റർ struct rx_call *z_call;
{
int z_ഫലം;
XDR z_xdrs;

z_ഫലം = RXGEN_SUCCESS;
പരാജയം:
തിരികെ z_ഫലം;
}

int VL_ListAttributes(z_conn, attributes, nentries, bulkentries_1)
രജിസ്റ്റർ struct rx_connection *z_conn;
VldbListByAttributes * ആട്രിബ്യൂട്ടുകൾ;
നീണ്ട * എൻട്രികൾ;
ബൾക്കന്ററികൾ * ബൾക്കന്ററികൾ_1;
{
struct rx_call *z_call = rx_NewCall(z_conn);
സ്റ്റാറ്റിക് ഇൻറ്റ് z_op = 511;
int z_ഫലം;
XDR z_xdrs;

xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

/* വാദങ്ങൾ മാർഷൽ */
എങ്കിൽ ((!xdr_int(&z_xdrs, &z_op))
|| (!xdr_VldbListByAttributes(&z_xdrs, ആട്രിബ്യൂട്ടുകൾ))) {
z_ഫലം = RXGEN_CC_MARSHAL;
പരാജയപ്പെട്ടു;
}

/* അൺ-മാർഷൽ ദി റിപ്ലൈ ആർഗ്യുമെന്റുകൾ */
z_xdrs.x_op = XDR_DECODE;
എങ്കിൽ ((!xdr_long(&z_xdrs, nentries))
|| (!xdr_bulkentries(&z_xdrs, bulkentries_1))) {
z_result = RXGEN_CC_UNMARSHAL;
പരാജയപ്പെട്ടു;
}

z_ഫലം = RXGEN_SUCCESS;
പരാജയം:
റിട്ടേൺ rx_EndCall(z_call, z_result);
}

int VL_LinkedList(z_conn, attributes, nentries, linkedentries)
രജിസ്റ്റർ struct rx_connection *z_conn;
VldbListByAttributes * ആട്രിബ്യൂട്ടുകൾ;
നീണ്ട * എൻട്രികൾ;
vldb_list * linkedentries;
{
struct rx_call *z_call = rx_NewCall(z_conn);
സ്റ്റാറ്റിക് ഇൻറ്റ് z_op = 512;
int z_ഫലം;
XDR z_xdrs;

xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

/* വാദങ്ങൾ മാർഷൽ */
എങ്കിൽ ((!xdr_int(&z_xdrs, &z_op))
|| (!xdr_VldbListByAttributes(&z_xdrs, ആട്രിബ്യൂട്ടുകൾ))) {
z_ഫലം = RXGEN_CC_MARSHAL;
പരാജയപ്പെട്ടു;
}

/* അൺ-മാർഷൽ ദി റിപ്ലൈ ആർഗ്യുമെന്റുകൾ */
z_xdrs.x_op = XDR_DECODE;
എങ്കിൽ ((!xdr_long(&z_xdrs, nentries))
|| (!xdr_vldb_list(&z_xdrs, linkedentries))) {
z_result = RXGEN_CC_UNMARSHAL;
പരാജയപ്പെട്ടു;
}

z_ഫലം = RXGEN_SUCCESS;
പരാജയം:
റിട്ടേൺ rx_EndCall(z_call, z_result);
}

"മൾട്ടി" സവിശേഷതയുടെ പാർശ്വഫലങ്ങൾ ശ്രദ്ധിക്കുക ("ReplaceEntry" എന്നതിനായുള്ള മൂന്ന് വ്യത്യസ്ത മൊഡ്യൂളുകൾ
പ്രോസി).

സെർവർ-സൈഡ് സ്റ്റബ്ബ് ദിനചര്യകൾ (vldbint.ss.c)

/* മെഷീൻ ജനറേറ്റഡ് ഫയൽ -- എഡിറ്റ് ചെയ്യരുത് */

#ഉൾപ്പെടുന്നു
#ഉൾപ്പെടുന്നു
#ഉൾപ്പെടുന്നു
#"vldbint.h" ഉൾപ്പെടുത്തുക

# "vl_opcodes.h" /* നേരിട്ട് മറ്റ് സ്ഥലങ്ങളിലേക്ക് */ ഉൾപ്പെടുത്തുക

നീണ്ട _VL_CreateEntry(z_call, z_xdrs)
struct rx_call *z_call;
XDR *z_xdrs;
{
നീണ്ട z_ഫലം;
നീണ്ട വോളിഡ്;
vldbentry ന്യൂഎൻട്രി;

എങ്കിൽ (!xdr_long(z_xdrs, &Volid))
|| (!xdr_vldbentry(z_xdrs, &newentry))) {
z_ഫലം = RXGEN_SS_UNMARSHAL;
പരാജയപ്പെട്ടു;
}

z_result = VL_CreateEntry(z_call, Volid, &newentry);
പരാജയം:
തിരികെ z_ഫലം;
}

നീണ്ട _VL_GetEntryByName(z_call, z_xdrs)
struct rx_call *z_call;
XDR *z_xdrs;
{
നീണ്ട z_ഫലം;
char *volumename = (char *)0;
vldbentry പ്രവേശനം;

എങ്കിൽ (!xdr_string(z_xdrs, &volumename, 65))) {
z_ഫലം = RXGEN_SS_UNMARSHAL;
പരാജയപ്പെട്ടു;
}

z_result = VL_GetEntryByName(z_call, &volumename, &entry);
z_xdrs->x_op = XDR_ENCODE;
എങ്കിൽ ((!xdr_vldbentry(z_xdrs, &entry)))
z_ഫലം = RXGEN_SS_MARSHAL;
പരാജയം:
z_xdrs->x_op = XDR_FREE;
എങ്കിൽ (!xdr_string(z_xdrs, &volumename, 65)) goto fail1;
തിരികെ z_ഫലം;
പരാജയം1:
RXGEN_SS_XDRFREE മടങ്ങുക;
}

നീണ്ട _VL_GetNewVolumeId(z_call, z_xdrs)
struct rx_call *z_call;
XDR *z_xdrs;
{
നീണ്ട z_ഫലം;
നീണ്ട ബമ്പ് കൗണ്ട്;
നീളമുള്ള ന്യൂവോലൂമിഡ്;

എങ്കിൽ ((!xdr_long(z_xdrs, &bumpcount))) {
z_ഫലം = RXGEN_SS_UNMARSHAL;
പരാജയപ്പെട്ടു;
}

z_result = VL_GetNewVolumeId(z_call, bumpcount, &newvolumid);
z_xdrs->x_op = XDR_ENCODE;
എങ്കിൽ ((!xdr_long(z_xdrs, &newvolumid)))
z_ഫലം = RXGEN_SS_MARSHAL;
പരാജയം:
തിരികെ z_ഫലം;
}

നീണ്ട _VL_ReplaceEntry(z_call, z_xdrs)
struct rx_call *z_call;
XDR *z_xdrs;
{
നീണ്ട z_ഫലം;
നീണ്ട വോളിഡ്, വോൾടൈപ്പ്, റിലീസ് ടൈപ്പ്;
vldbentry ന്യൂഎൻട്രി;

എങ്കിൽ (!xdr_long(z_xdrs, &Volid))
|| (!xdr_long(z_xdrs, &voltype))
|| (!xdr_vldbentry(z_xdrs, &newentry))
|| (!xdr_long(z_xdrs, &ReleaseType)) {
z_ഫലം = RXGEN_SS_UNMARSHAL;
പരാജയപ്പെട്ടു;
}

z_result = VL_ReplaceEntry(z_call, Volid, voltype, &newentry,
റിലീസ് തരം);
പരാജയം:
തിരികെ z_ഫലം;
}

നീണ്ട _VL_ListAtributes(z_call, z_xdrs)
struct rx_call *z_call;
XDR *z_xdrs;
{
നീണ്ട z_ഫലം;
VldbListByAttributes ആട്രിബ്യൂട്ടുകൾ;
നീണ്ട നെട്രികൾ;
ബൾക്കൻറീസ് ബൾക്കന്ററികൾ_1;

എങ്കിൽ ((!xdr_VldbListByAttributes(z_xdrs, &ആട്രിബ്യൂട്ടുകൾ))) {
z_ഫലം = RXGEN_SS_UNMARSHAL;
പരാജയപ്പെട്ടു;
}

z_result = VL_ListAttributes(z_call, &attributes, &nentries,
&ബൾക്കന്റീസ്_1);
z_xdrs->x_op = XDR_ENCODE;
എങ്കിൽ (!xdr_long(z_xdrs, &nentries))
|| (!xdr_bulkentries(z_xdrs, &bulkentries_1)))
z_ഫലം = RXGEN_SS_MARSHAL;
പരാജയം:
z_xdrs->x_op = XDR_FREE;
എങ്കിൽ (!xdr_bulkentries(z_xdrs, &bulkentries_1)) പരാജയപ്പെടുകയാണെങ്കിൽ1;
തിരികെ z_ഫലം;
പരാജയം1:
RXGEN_SS_XDRFREE മടങ്ങുക;
}

നീണ്ട _VL_LinkedList(z_call, z_xdrs)
struct rx_call *z_call;
XDR *z_xdrs;
{
നീണ്ട z_ഫലം;
VldbListByAttributes ആട്രിബ്യൂട്ടുകൾ;
നീണ്ട നെട്രികൾ;
vldb_list linkedentries;

എങ്കിൽ ((!xdr_VldbListByAttributes(z_xdrs, &ആട്രിബ്യൂട്ടുകൾ))) {
z_ഫലം = RXGEN_SS_UNMARSHAL;
പരാജയപ്പെട്ടു;
}

z_result = VL_LinkedList(z_call, &attributes, &nentries,
&ലിങ്കെഡൻട്രികൾ);
z_xdrs->x_op = XDR_ENCODE;
എങ്കിൽ (!xdr_long(z_xdrs, &nentries))
|| (!xdr_vldb_list(z_xdrs, &linkedentries)))
z_ഫലം = RXGEN_SS_MARSHAL;
പരാജയം:
തിരികെ z_ഫലം;
}

നീണ്ട _VL_CreateEntry();
നീണ്ട _VL_GetEntryByName();
നീണ്ട _VL_GetNewVolumeId();
നീണ്ട _VL_ReplaceEntry();
നീണ്ട _VL_ListAtributes();
നീണ്ട _VL_LinkedList();

സ്റ്റാറ്റിക് ലോംഗ് (*StubProcsArray0[])() = {_VL_CreateEntry,
_VL_GetEntryByName, _VL_GetNewVolumeId, _VL_ReplaceEntry,
_VL_ListAtributes, _VL_LinkedList};

VL_ExecuteRequest(z_call)
രജിസ്റ്റർ struct rx_call *z_call;
{
ഇന്റർ ഒപി;
XDR z_xdrs;
നീണ്ട z_ഫലം;

xdrrx_create(&z_xdrs, z_call, XDR_DECODE);
എങ്കിൽ (!xdr_int(&z_xdrs, &op))
z_ഫലം = RXGEN_DECODE;
അല്ലെങ്കിൽ (op < VL_LOWEST_OPCODE || op > VL_HIGHEST_OPCODE)
z_ഫലം = RXGEN_OPCODE;
മറ്റാരെങ്കിലും
z_result = (*StubProcsArray0[op - VL_LOWEST_OPCODE])
(z_call, &z_xdrs);
തിരികെ z_ഫലം;
}

നടപടിക്രമങ്ങളുടെ ഒപ്‌കോഡ് ക്രമത്തിൽ വിടവുകളുണ്ടെങ്കിൽ അതിനുള്ള കോഡ് VL_ExecuteRequest()
പതിവ് തികച്ചും വ്യത്യസ്തമാകുമായിരുന്നു (ഇത് ഒരു കേസ് സ്റ്റേറ്റ്‌മെന്റ് ആകുമായിരുന്നു
ഓരോ നടപടിക്രമവും).

കുറിപ്പുകൾ

rxgen സൂര്യനിൽ നിന്ന് നടപ്പിലാക്കുന്നു rpcgen യൂട്ടിലിറ്റി. എല്ലാ നിലവാരവും rpcgen's
പ്രവർത്തനം പൂർണ്ണമായും പരിപാലിക്കുന്നു. ചിലത് സജീവമാണെന്ന് ശ്രദ്ധിക്കുക rpcgen ബാധകമല്ലാത്ത ഓപ്ഷനുകൾ
ലേക്ക് rxgenന്റെ ഉദ്ദേശ്യം ഇവിടെ പരാമർശിക്കുന്നില്ല (അതായത്, -s, -l, -m ഓപ്‌ഷനുകളും) താൽപ്പര്യമുള്ളവരും
വായനക്കാരൻ പരാമർശിക്കേണ്ടതാണ് rpcgen(1) വിശദാംശങ്ങൾക്ക്.

"% #ഉൾപ്പെടുമ്പോൾ നിങ്ങൾക്ക് ഒന്നുമില്ലെന്ന് ഉറപ്പാക്കാൻ ഫീച്ചർ ഉപയോഗിക്കുന്നു
rxgen ഭാഷാ സവിശേഷതകൾ (അതായത് %# നിർവചിക്കുന്നു) കാരണം നിങ്ങൾക്ക് വാക്യഘടന പിശകുകൾ ലഭിക്കും
സമാഹാരങ്ങൾ..

ഇതൊരു നടന്നുകൊണ്ടിരിക്കുന്ന പ്രൊജക്‌റ്റ് ആയതിനാൽ മുകളിൽ പറഞ്ഞവയിൽ പലതും പ്രധാനം കൂടാതെ മാറാം/അപ്രത്യക്ഷമാകാം
മുന്നറിയിപ്പ്.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് rxgen ഓൺലൈനായി ഉപയോഗിക്കുക