sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-02-23 09:57:40 +03:00
Code
samba-mirror/source/aparser/parsefn.awk

181 lines
4.2 KiB
Awk
Raw Normal View History

vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
# build parse functions for a parsed struct file
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
function elem_name(v, elem)
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
{
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
return v["UNION"]elem;
}
function parse_array(f, v, elnum, flags,
cifs parser.
-
LOCAL, type, elem, array_len)
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
{
type = elements[elnum, "type"];
elem = elements[elnum, "elem"];
cifs parser.
-
array_len = elements[elnum, "array_len"];
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
v["ELEM"] = elem_name(v, elem);
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
v["TYPE"] = type;
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
v["FLAGS"] = flags;
cifs parser.
-
v["ARRAY_LEN"] = array_len;
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
cifs parser.
-
if (array_len=="*") {
print_template(f,"prs_array_remainder.tpl", v);
return;
}
if (type == "wchar" || type == "uint16") {
if (match(array_len,"[0-9]") == 1) {
print_template(f, "prs_wstring_fixed.tpl", v);
} else {
print_template(f, "prs_wstring.tpl", v);
}
} else if (type == "uint8") {
if (match(array_len,"[0-9]") == 1) {
print_template(f, "prs_uint8s_fixed.tpl", v);
} else {
print_template(f, "prs_uint8s.tpl", v);
}
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
} else {
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
print_template(f, "prs_array.tpl", v);
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
}
}
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
function parse_element(f, v, elnum, flags,
LOCAL, type, elem)
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
{
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
type = elements[elnum, "type"];
added the ".trailer" type, to mark where a packet turns into a trailer this now gives us enough to parse complete function calls, including the return values
-
if (substr(type,1,1) == ".") return;
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
elem = elements[elnum, "elem"];
if (elements[elnum,"ptr"] == "") {
v["PTR"] = "\\&";
} else {
v["PTR"] = " ";
}
v["ELEM"] = elem_name(v, elem);
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
v["TYPE"] = type;
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
v["FLAGS"] = flags;
print_template(f, "prs_element.tpl", v);
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
}
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
function parse_union(f, v, elnum, flags,
LOCAL, i)
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
{
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
v["UNION"] = elements[elnum, "elem"];
v["SWITCH"] = elements[elnum, "switch"];
if (elements[elnum, "ptr"] == "1") {
v["UNION"] = v["UNION"]"->";
} else {
v["UNION"] = v["UNION"]".";
}
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
print_template(f, "union_start.tpl", v);
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
for (i=0;i<unions[elnum, "num_elems"];i++) {
v["CASE"] = elements[unions[elnum, i], "case"];
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
print_template(f, "prs_case.tpl", v);
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
if (elements[elnum, "ptr"] == "1") {
parse_scalars(f, v, unions[elnum, i], "PARSE_SCALARS");
parse_buffers(f, v, unions[elnum, i], "PARSE_BUFFERS");
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
} else {
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
if (flags == "PARSE_SCALARS") {
parse_scalars(f, v, unions[elnum, i], flags);
} else {
parse_buffers(f, v, unions[elnum, i], flags);
}
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
}
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
print_template(f, "prs_break.tpl", v);
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
}
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
v["UNION"] = "";
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
print_template(f, "union_end.tpl", v);
}
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
function parse_scalar(f, v, elnum, flags)
started update to handle arbitrary arrays note: this code is currently broken.
-
{
if (elements[elnum, "type"] == "union") {
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
parse_union(f, v, elnum, flags);
started update to handle arbitrary arrays note: this code is currently broken.
-
} else if (elements[elnum, "array_len"]!="") {
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
parse_array(f, v, elnum, flags);
started update to handle arbitrary arrays note: this code is currently broken.
-
} else {
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
parse_element(f, v, elnum, flags);
started update to handle arbitrary arrays note: this code is currently broken.
-
}
}
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
function parse_pointer(f, v, elnum, flags,
started update to handle arbitrary arrays note: this code is currently broken.
-
LOCAL, elem)
{
elem = elements[elnum, "elem"];
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
v["ELEM"] = elem_name(v, elem);
v["FLAGS"] = flags;
started update to handle arbitrary arrays note: this code is currently broken.
-
print_template(f, "prs_pointer.tpl", v);
}
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
function parse_scalars(f, v, elnum, flags)
{
if (elements[elnum, "ptr"] == "1") {
parse_pointer(f, v, elnum, flags);
} else {
parse_scalar(f, v, elnum, flags);
}
}
function parse_buffers(f, v, elnum, flags,
LOCAL, elem, type)
started update to handle arbitrary arrays note: this code is currently broken.
-
{
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
elem = elements[elnum, "elem"];
type = elements[elnum, "type"];
v["ELEM"] = elem_name(v, elem);
started update to handle arbitrary arrays note: this code is currently broken.
-
if (elements[elnum, "ptr"] == "1") {
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
print_template(f, "ifptr_start.tpl", v);
parse_scalar(f, v, elnum, "PARSE_SCALARS|PARSE_BUFFERS");
print_template(f, "ifptr_end.tpl", v);
started update to handle arbitrary arrays note: this code is currently broken.
-
} else {
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
parse_scalar(f, v, elnum, flags);
started update to handle arbitrary arrays note: this code is currently broken.
-
}
}
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
function struct_parser(f, v, struct_num,
added the ".trailer" type, to mark where a packet turns into a trailer this now gives us enough to parse complete function calls, including the return values
-
LOCAL, i, n1)
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
{
v["STRUCTNAME"] = structs[struct_num, "name"];
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
v["FUNCNAME"] = "io_" v["STRUCTNAME"];
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
print_template(f, "fn_start.tpl", v);
added the ".trailer" type, to mark where a packet turns into a trailer this now gives us enough to parse complete function calls, including the return values
-
for (n1=0;n1<structs[struct_num, "num_elems"];n1++) {
if (elements[structs[struct_num, n1], "type"] == ".trailer") break;
}
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
# first all the structure pointers, scalars and arrays
added the ".trailer" type, to mark where a packet turns into a trailer this now gives us enough to parse complete function calls, including the return values
-
for (i=0;i<n1;i++) {
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
parse_scalars(f, v, structs[struct_num, i], "PARSE_SCALARS");
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
}
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
print_template(f, "fn_mid.tpl", v);
started update to handle arbitrary arrays note: this code is currently broken.
-
# now the buffers
added the ".trailer" type, to mark where a packet turns into a trailer this now gives us enough to parse complete function calls, including the return values
-
for (i=0;i<n1;i++) {
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
parse_buffers(f, v, structs[struct_num, i], "PARSE_BUFFERS");
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
}
added the ".trailer" type, to mark where a packet turns into a trailer this now gives us enough to parse complete function calls, including the return values
-
# and any trailers
for (i=n1;i<structs[struct_num, "num_elems"];i++) {
take the sructure name to run through vluke on the command line
-
parse_scalars(f, v, structs[struct_num, i], "PARSE_SCALARS");
parse_buffers(f, v, structs[struct_num, i], "PARSE_BUFFERS");
added the ".trailer" type, to mark where a packet turns into a trailer this now gives us enough to parse complete function calls, including the return values
-
}
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
print_template(f, "fn_end.tpl", v);
}
function produce_parsers(f,
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
LOCAL, v, i)
vastly improved awk based code generator now handles recursive function definitions, unions etc it is sufficient for some basic types like UNISTR2 and BUFFER5 to be defined in the *.struct file and used successfully this generator uses templates (in *.tpl files) for all code generation, allowing easy replacement of the backend functions
-
{
v["MODULE"]=module;
print_template(f, "module_start.tpl", v);
for (i=0;i < num_structs;i++) {
struct_parser(f, v, i);
}
print_template(f, "module_end.tpl", v);
}
Copy Permalink