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

272 lines
6.0 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
-
optional (0of or 1of) with "[+]" semantics.
-
if (array_len=="+") {
print_template(f,"prs_array_optional.tpl", v);
return;
}
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
-
{
messing about.
-
if (elements[elnum,"nowire"] != "") {
return;
}
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.
-
}
}
more SMBtrans, SMBnttrans stuff.
-
function parse_align2(f, v, elnum, flags,
LOCAL, elem)
{
elem = elements[elnum, "elem"];
v["OFFSET"] = elem_name(v, elem);
print_template(f, "prs_align2.tpl", v);
}
function parse_align4(f, v, elnum, flags,
LOCAL, elem)
{
elem = elements[elnum, "elem"];
v["OFFSET"] = elem_name(v, elem);
print_template(f, "prs_align4.tpl", v);
}
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);
}
messing about.
-
function parse_scalar_fn(m, v, elnum,
LOCAL, elem, type)
{
elem = elements[elnum, "elem"];
type = elements[elnum, "type"]
xprintf(m, "%s %s", type, elem_name(v, elem));
if (type == "union") {
} else if (elements[elnum, "array_len"]!="") {
} else {
}
}
function parse_pointer_fn(f, v, elnum, flags,
LOCAL, elem)
{
elem = elements[elnum, "elem"];
v["ELEM"] = elem_name(v, elem);
v["FLAGS"] = flags;
xprintf(m, "%s\n", v["ELEM"]);
}
function parse_scalars_fn(m, v, elnum, flags)
{
if (elements[elnum, "type"] == ".align2") {
}
else if (elements[elnum, "type"] == ".align4") {
}
else if (elements[elnum, "ptr"] == "1") {
parse_pointer_fn(m, v, elnum, flags);
} else {
parse_scalar_fn(m, v, elnum, flags);
}
}
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)
{
more SMBtrans, SMBnttrans stuff.
-
if (elements[elnum, "type"] == ".align2") {
parse_align2(f, v, elnum, flags);
}
else if (elements[elnum, "type"] == ".align4") {
parse_align4(f, v, elnum, flags);
}
else if (elements[elnum, "ptr"] == "1") {
another awk parser update we can now handle arrays of structures, pointers to structures, pointers in unions etc
-
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);
more SMBtrans, SMBnttrans stuff.
-
if (elements[elnum, "type"] == ".align2") {
}
else if (elements[elnum, "type"] == ".align4") {
} else 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
-
messing about.
-
function struct_parser(f, m, v, struct_num,
LOCAL, i, n1, f1, num_elems)
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
-
{
messing about.
-
f1 = -1;
num_elems = structs[struct_num, "num_elems"];
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);
messing about.
-
for (n1=0;n1<num_elems;n1++) {
if (elements[structs[struct_num, n1], "type"] == ".trailer") {
f1 = n1;
break;
}
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
-
# 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
messing about.
-
for (i=n1;i<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
-
}
more SMBtrans, SMBnttrans stuff.
-
if (i > 0) {
print_template(f, "fn_end.tpl", v);
}
else {
print_template(f, "fn_end0.tpl", v);
}
messing about.
-
if (f1 == -1)
return;
xprintf(m, "void fn_%s(\n", v["STRUCTNAME"]);
for (i=f1+1;i<num_elems;i++) {
parse_scalars_fn(m, v, structs[struct_num, i]);
if (i != num_elems-1)
xprintf(m, ", \n");
}
xprintf(m, ")\n{\n}\n");
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
-
}
messing about.
-
function produce_parsers(f, m,
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++) {
messing about.
-
struct_parser(f, m, 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
-
}
print_template(f, "module_end.tpl", v);
}
Copy Permalink