Datasets:

---

iNeil77

/

the-vault-function

like 0

[ "Unlicense" ]

[ "write", "an", "XML", "tree", "to", "a", "file" ]

[ "void", "xml_file_write", "(", "xml_data_node", "*", "node", ",", "core_file", "*", "file", ")", "{", "if", "(", "node", "->", "name", "!=", "NULL", ")", "return", ";", "core_fprintf", "(", "file", ",", "\"", "\\\"", "\\\"", "\\n", "\"", ")", ";", "core_fprintf", "(", "file", ",", "\"", "\\n", "\"", ")", ";", "for", "(", "node", "=", "node", "->", "child", ";", "node", ";", "node", "=", "node", "->", "next", ")", "write_node_recursive", "(", "node", ",", "0", ",", "file", ")", ";", "}" ]

[ "xml_file_write", "-", "write", "an", "XML", "tree", "to", "a", "file" ]

[ "/* ensure this is a root node */", "/* output a simple header */", "/* loop over children of the root and output */" ]

[ { "param": "node", "type": "xml_data_node" }, { "param": "file", "type": "core_file" } ]

[ "Unlicense" ]

[ "count", "the", "number", "of", "child", "nodes" ]

[ "int", "xml_count_children", "(", "xml_data_node", "*", "node", ")", "{", "int", "count", "=", "0", ";", "for", "(", "node", "=", "node", "->", "child", ";", "node", ";", "node", "=", "node", "->", "next", ")", "count", "++", ";", "return", "count", ";", "}" ]

[ "xml_count_children", "-", "count", "the", "number", "of", "child", "nodes" ]

[ "/* loop over children and count */" ]

[ { "param": "node", "type": "xml_data_node" } ]

[ "Unlicense" ]

[ "find", "the", "next", "sibling", "of", "the", "specified", "node", "with", "the", "specified", "tag" ]

[ "xml_data_node", "*", "xml_get_sibling", "(", "xml_data_node", "*", "node", ",", "const", "char", "*", "name", ")", "{", "for", "(", ";", "node", ";", "node", "=", "node", "->", "next", ")", "if", "(", "strcmp", "(", "node", "->", "name", ",", "name", ")", "==", "0", ")", "return", "node", ";", "return", "NULL", ";", "}" ]

[ "xml_get_sibling", "-", "find", "the", "next", "sibling", "of", "the", "specified", "node", "with", "the", "specified", "tag" ]

[ "/* loop over siblings and find a matching name */" ]

[ { "param": "node", "type": "xml_data_node" }, { "param": "name", "type": "char" } ]

[ "Unlicense" ]

[ "find", "the", "next", "sibling", "of", "the", "specified", "node", "with", "the", "specified", "tag", "or", "attribute", "/", "value", "pair" ]

[ "xml_data_node", "*", "xml_find_matching_sibling", "(", "xml_data_node", "*", "node", ",", "const", "char", "*", "name", ",", "const", "char", "*", "attribute", ",", "const", "char", "*", "matchval", ")", "{", "for", "(", ";", "node", ";", "node", "=", "node", "->", "next", ")", "{", "if", "(", "name", "==", "NULL", "||", "strcmp", "(", "name", ",", "node", "->", "name", ")", "==", "0", ")", "{", "xml_attribute_node", "*", "attr", "=", "xml_get_attribute", "(", "node", ",", "attribute", ")", ";", "if", "(", "attr", "!=", "NULL", "&&", "strcmp", "(", "attr", "->", "value", ",", "matchval", ")", "==", "0", ")", "return", "node", ";", "}", "}", "return", "NULL", ";", "}" ]

[ "xml_find_matching_sibling", "-", "find", "the", "next", "sibling", "of", "the", "specified", "node", "with", "the", "specified", "tag", "or", "attribute", "/", "value", "pair" ]

[ "/* loop over siblings and find a matching attribute */", "/* can pass NULL as a wildcard for the node name */", "/* find a matching attribute */" ]

[ { "param": "node", "type": "xml_data_node" }, { "param": "name", "type": "char" }, { "param": "attribute", "type": "char" }, { "param": "matchval", "type": "char" } ]

[ "Unlicense" ]

[ "add", "a", "new", "child", "node", "to", "the", "given", "node" ]

[ "xml_data_node", "*", "xml_add_child", "(", "xml_data_node", "*", "node", ",", "const", "char", "*", "name", ",", "const", "char", "*", "value", ")", "{", "return", "add_child", "(", "node", ",", "name", ",", "value", ")", ";", "}" ]

[ "xml_add_child", "-", "add", "a", "new", "child", "node", "to", "the", "given", "node" ]

[ "/* just a standard add child */" ]

[ { "param": "node", "type": "xml_data_node" }, { "param": "name", "type": "char" }, { "param": "value", "type": "char" } ]

[ "Unlicense" ]

[ "find", "a", "child", "node", "of", "the", "specified", "type", ";", "if", "not", "found", "add", "one" ]

[ "xml_data_node", "*", "xml_get_or_add_child", "(", "xml_data_node", "*", "node", ",", "const", "char", "*", "name", ",", "const", "char", "*", "value", ")", "{", "xml_data_node", "*", "child", ";", "child", "=", "xml_get_sibling", "(", "node", "->", "child", ",", "name", ")", ";", "if", "(", "child", "!=", "NULL", ")", "return", "child", ";", "return", "add_child", "(", "node", ",", "name", ",", "value", ")", ";", "}" ]

[ "xml_get_or_add_child", "-", "find", "a", "child", "node", "of", "the", "specified", "type", ";", "if", "not", "found", "add", "one" ]

[ "/* find the child first */", "/* if not found, do a standard add child */" ]

[ { "param": "node", "type": "xml_data_node" }, { "param": "name", "type": "char" }, { "param": "value", "type": "char" } ]

[ "Unlicense" ]

[ "delete", "a", "node", "and", "its", "children" ]

[ "void", "xml_delete_node", "(", "xml_data_node", "*", "node", ")", "{", "xml_data_node", "*", "*", "pnode", ";", "for", "(", "pnode", "=", "&", "node", "->", "parent", "->", "child", ";", "*", "pnode", ";", "pnode", "=", "&", "(", "*", "pnode", ")", "->", "next", ")", "if", "(", "*", "pnode", "==", "node", ")", "{", "*", "pnode", "=", "node", "->", "next", ";", "break", ";", "}", "free_node_recursive", "(", "node", ")", ";", "}" ]

[ "xml_delete_node", "-", "delete", "a", "node", "and", "its", "children" ]

[ "/* first unhook us from the list of children of our parent */", "/* now free ourselves and our children */" ]

[ { "param": "node", "type": "xml_data_node" } ]

[ "Unlicense" ]

[ "get", "the", "value", "of", "the", "specified", "attribute", "or", "NULL", "if", "not", "found" ]

[ "xml_attribute_node", "*", "xml_get_attribute", "(", "xml_data_node", "*", "node", ",", "const", "char", "*", "attribute", ")", "{", "xml_attribute_node", "*", "anode", ";", "for", "(", "anode", "=", "node", "->", "attribute", ";", "anode", ";", "anode", "=", "anode", "->", "next", ")", "if", "(", "strcmp", "(", "anode", "->", "name", ",", "attribute", ")", "==", "0", ")", "return", "anode", ";", "return", "NULL", ";", "}" ]

[ "xml_get_attribute", "-", "get", "the", "value", "of", "the", "specified", "attribute", "or", "NULL", "if", "not", "found" ]

[ "/* loop over attributes and find a match */" ]

[ { "param": "node", "type": "xml_data_node" }, { "param": "attribute", "type": "char" } ]

[ "Unlicense" ]

[ "get", "the", "string", "value", "of", "the", "specified", "attribute", ";", "if", "not", "found", "return", "=", "the", "provided", "default" ]

[ "const", "char", "*", "xml_get_attribute_string", "(", "xml_data_node", "*", "node", ",", "const", "char", "*", "attribute", ",", "const", "char", "*", "defvalue", ")", "{", "xml_attribute_node", "*", "attr", "=", "xml_get_attribute", "(", "node", ",", "attribute", ")", ";", "return", "attr", "?", "attr", "->", "value", ":", "defvalue", ";", "}" ]

[ "xml_get_attribute_string", "-", "get", "the", "string", "value", "of", "the", "specified", "attribute", ";", "if", "not", "found", "return", "=", "the", "provided", "default" ]

[]

[ { "param": "node", "type": "xml_data_node" }, { "param": "attribute", "type": "char" }, { "param": "defvalue", "type": "char" } ]

[ "Unlicense" ]

[ "get", "the", "integer", "value", "of", "the", "specified", "attribute", ";", "if", "not", "found", "return", "=", "the", "provided", "default" ]

[ "int", "xml_get_attribute_int", "(", "xml_data_node", "*", "node", ",", "const", "char", "*", "attribute", ",", "int", "defvalue", ")", "{", "const", "char", "*", "string", "=", "xml_get_attribute_string", "(", "node", ",", "attribute", ",", "NULL", ")", ";", "int", "value", ";", "if", "(", "string", "==", "NULL", ")", "return", "defvalue", ";", "if", "(", "string", "[", "0", "]", "==", "'", "'", ")", "return", "(", "sscanf", "(", "&", "string", "[", "1", "]", ",", "\"", "\"", ",", "&", "value", ")", "==", "1", ")", "?", "value", ":", "defvalue", ";", "if", "(", "string", "[", "0", "]", "==", "'", "'", "&&", "string", "[", "1", "]", "==", "'", "'", ")", "return", "(", "sscanf", "(", "&", "string", "[", "2", "]", ",", "\"", "\"", ",", "&", "value", ")", "==", "1", ")", "?", "value", ":", "defvalue", ";", "if", "(", "string", "[", "0", "]", "==", "'", "'", ")", "return", "(", "sscanf", "(", "&", "string", "[", "1", "]", ",", "\"", "\"", ",", "&", "value", ")", "==", "1", ")", "?", "value", ":", "defvalue", ";", "return", "(", "sscanf", "(", "&", "string", "[", "0", "]", ",", "\"", "\"", ",", "&", "value", ")", "==", "1", ")", "?", "value", ":", "defvalue", ";", "}" ]

[ "xml_get_attribute_int", "-", "get", "the", "integer", "value", "of", "the", "specified", "attribute", ";", "if", "not", "found", "return", "=", "the", "provided", "default" ]

[]

[ { "param": "node", "type": "xml_data_node" }, { "param": "attribute", "type": "char" }, { "param": "defvalue", "type": "int" } ]

[ "Unlicense" ]

[ "return", "the", "format", "of", "the", "given", "integer", "attribute" ]

[ "int", "xml_get_attribute_int_format", "(", "xml_data_node", "*", "node", ",", "const", "char", "*", "attribute", ")", "{", "const", "char", "*", "string", "=", "xml_get_attribute_string", "(", "node", ",", "attribute", ",", "NULL", ")", ";", "if", "(", "string", "==", "NULL", ")", "return", "XML_INT_FORMAT_DECIMAL", ";", "if", "(", "string", "[", "0", "]", "==", "'", "'", ")", "return", "XML_INT_FORMAT_HEX_DOLLAR", ";", "if", "(", "string", "[", "0", "]", "==", "'", "'", "&&", "string", "[", "1", "]", "==", "'", "'", ")", "return", "XML_INT_FORMAT_HEX_C", ";", "if", "(", "string", "[", "0", "]", "==", "'", "'", ")", "return", "XML_INT_FORMAT_DECIMAL_POUND", ";", "return", "XML_INT_FORMAT_DECIMAL", ";", "}" ]

[ "xml_get_attribute_int_format", "-", "return", "the", "format", "of", "the", "given", "integer", "attribute" ]

[]

[ { "param": "node", "type": "xml_data_node" }, { "param": "attribute", "type": "char" } ]

[ "Unlicense" ]

[ "get", "the", "float", "value", "of", "the", "specified", "attribute", ";", "if", "not", "found", "return", "=", "the", "provided", "default" ]

[ "float", "xml_get_attribute_float", "(", "xml_data_node", "*", "node", ",", "const", "char", "*", "attribute", ",", "float", "defvalue", ")", "{", "const", "char", "*", "string", "=", "xml_get_attribute_string", "(", "node", ",", "attribute", ",", "NULL", ")", ";", "float", "value", ";", "if", "(", "string", "==", "NULL", "||", "sscanf", "(", "string", ",", "\"", "\"", ",", "&", "value", ")", "!=", "1", ")", "return", "defvalue", ";", "return", "value", ";", "}" ]

[ "xml_get_attribute_float", "-", "get", "the", "float", "value", "of", "the", "specified", "attribute", ";", "if", "not", "found", "return", "=", "the", "provided", "default" ]

[]

[ { "param": "node", "type": "xml_data_node" }, { "param": "attribute", "type": "char" }, { "param": "defvalue", "type": "float" } ]

[ "Unlicense" ]

[ "set", "a", "new", "attribute", "and", "string", "value", "on", "the", "node" ]

[ "xml_attribute_node", "*", "xml_set_attribute", "(", "xml_data_node", "*", "node", ",", "const", "char", "*", "name", ",", "const", "char", "*", "value", ")", "{", "xml_attribute_node", "*", "anode", ";", "anode", "=", "xml_get_attribute", "(", "node", ",", "name", ")", ";", "if", "(", "anode", "!=", "NULL", ")", "{", "if", "(", "anode", "->", "value", "!=", "NULL", ")", "free", "(", "(", "void", "*", ")", "anode", "->", "value", ")", ";", "anode", "->", "value", "=", "copystring", "(", "value", ")", ";", "}", "else", "anode", "=", "add_attribute", "(", "node", ",", "name", ",", "value", ")", ";", "return", "anode", ";", "}" ]

[ "xml_set_attribute", "-", "set", "a", "new", "attribute", "and", "string", "value", "on", "the", "node" ]

[ "/* first find an existing one to replace */", "/* if we found it, free the old value and replace it */", "/* otherwise, create a new node */" ]

[ { "param": "node", "type": "xml_data_node" }, { "param": "name", "type": "char" }, { "param": "value", "type": "char" } ]

[ "Unlicense" ]

[ "set", "a", "new", "attribute", "and", "integer", "value", "on", "the", "node" ]

[ "xml_attribute_node", "*", "xml_set_attribute_int", "(", "xml_data_node", "*", "node", ",", "const", "char", "*", "name", ",", "int", "value", ")", "{", "char", "buffer", "[", "100", "]", ";", "sprintf", "(", "buffer", ",", "\"", "\"", ",", "value", ")", ";", "return", "xml_set_attribute", "(", "node", ",", "name", ",", "buffer", ")", ";", "}" ]

[ "xml_set_attribute_int", "-", "set", "a", "new", "attribute", "and", "integer", "value", "on", "the", "node" ]

[]

[ { "param": "node", "type": "xml_data_node" }, { "param": "name", "type": "char" }, { "param": "value", "type": "int" } ]

[ "Unlicense" ]

[ "set", "a", "new", "attribute", "and", "float", "value", "on", "the", "node" ]

[ "xml_attribute_node", "*", "xml_set_attribute_float", "(", "xml_data_node", "*", "node", ",", "const", "char", "*", "name", ",", "float", "value", ")", "{", "char", "buffer", "[", "100", "]", ";", "sprintf", "(", "buffer", ",", "\"", "\"", ",", "value", ")", ";", "return", "xml_set_attribute", "(", "node", ",", "name", ",", "buffer", ")", ";", "}" ]

[ "xml_set_attribute_int", "-", "set", "a", "new", "attribute", "and", "float", "value", "on", "the", "node" ]

[]

[ { "param": "node", "type": "xml_data_node" }, { "param": "name", "type": "char" }, { "param": "value", "type": "float" } ]

[ "Unlicense" ]

[ "normalize", "a", "string", "to", "ensure", "it", "doesn", "'", "t", "contain", "embedded", "tags" ]

[ "const", "char", "*", "xml_normalize_string", "(", "const", "char", "*", "string", ")", "{", "static", "char", "buffer", "[", "1024", "]", ";", "char", "*", "d", "=", "&", "buffer", "[", "0", "]", ";", "if", "(", "string", "!=", "NULL", ")", "{", "while", "(", "*", "string", ")", "{", "switch", "(", "*", "string", ")", "{", "case", "'", "\\\"", "'", ":", "d", "+=", "sprintf", "(", "d", ",", "\"", "\"", ")", ";", "break", ";", "case", "'", "'", ":", "d", "+=", "sprintf", "(", "d", ",", "\"", "\"", ")", ";", "break", ";", "case", "'", "'", ":", "d", "+=", "sprintf", "(", "d", ",", "\"", "\"", ")", ";", "break", ";", "case", "'", "'", ":", "d", "+=", "sprintf", "(", "d", ",", "\"", "\"", ")", ";", "break", ";", "default", ":", "*", "d", "++", "=", "*", "string", ";", "}", "++", "string", ";", "}", "}", "*", "d", "++", "=", "0", ";", "return", "buffer", ";", "}" ]

[ "xml_normalize_string", "-", "normalize", "a", "string", "to", "ensure", "it", "doesn", "'", "t", "contain", "embedded", "tags" ]

[]

[ { "param": "string", "type": "char" } ]

[ "Unlicense" ]

[ "expat", "callback", "for", "a", "new", "element" ]

[ "static", "void", "expat_element_start", "(", "void", "*", "data", ",", "const", "XML_Char", "*", "name", ",", "const", "XML_Char", "*", "*", "attributes", ")", "{", "xml_parse_info", "*", "parse_info", "=", "(", "xml_parse_info", "*", ")", "data", ";", "xml_data_node", "*", "*", "curnode", "=", "&", "parse_info", "->", "curnode", ";", "xml_data_node", "*", "newnode", ";", "int", "attr", ";", "newnode", "=", "add_child", "(", "*", "curnode", ",", "name", ",", "NULL", ")", ";", "if", "(", "newnode", "==", "NULL", ")", "return", ";", "newnode", "->", "line", "=", "XML_GetCurrentLineNumber", "(", "parse_info", "->", "parser", ")", ";", "for", "(", "attr", "=", "0", ";", "attributes", "[", "attr", "]", ";", "attr", "+=", "2", ")", "add_attribute", "(", "newnode", ",", "attributes", "[", "attr", "+", "0", "]", ",", "attributes", "[", "attr", "+", "1", "]", ")", ";", "*", "curnode", "=", "newnode", ";", "}" ]

[ "expat_element_start", "-", "expat", "callback", "for", "a", "new", "element" ]

[ "/* add a new child node to the current node */", "/* remember the line number */", "/* add all the attributes as well */", "/* set us up as the current node */" ]

[ { "param": "data", "type": "void" }, { "param": "name", "type": "XML_Char" }, { "param": "attributes", "type": "XML_Char" } ]

[ "Unlicense" ]

[ "expat", "callback", "for", "a", "additional", "element", "data" ]

[ "static", "void", "expat_data", "(", "void", "*", "data", ",", "const", "XML_Char", "*", "s", ",", "int", "len", ")", "{", "xml_parse_info", "*", "parse_info", "=", "(", "xml_parse_info", "*", ")", "data", ";", "xml_data_node", "*", "*", "curnode", "=", "&", "parse_info", "->", "curnode", ";", "int", "oldlen", "=", "0", ";", "char", "*", "newdata", ";", "if", "(", "len", "==", "0", ")", "return", ";", "if", "(", "(", "*", "curnode", ")", "->", "value", "!=", "NULL", ")", "oldlen", "=", "(", "int", ")", "strlen", "(", "(", "*", "curnode", ")", "->", "value", ")", ";", "newdata", "=", "(", "char", "*", ")", "realloc", "(", "(", "void", "*", ")", "(", "*", "curnode", ")", "->", "value", ",", "oldlen", "+", "len", "+", "1", ")", ";", "if", "(", "newdata", "==", "NULL", ")", "return", ";", "memcpy", "(", "&", "newdata", "[", "oldlen", "]", ",", "s", ",", "len", ")", ";", "newdata", "[", "oldlen", "+", "len", "]", "=", "0", ";", "(", "*", "curnode", ")", "->", "value", "=", "newdata", ";", "}" ]

[ "expat_data", "-", "expat", "callback", "for", "a", "additional", "element", "data" ]

[ "/* if no data, skip */", "/* determine how much data we currently have */", "/* realloc */", "/* copy in the new data a NULL-terminate */" ]

[ { "param": "data", "type": "void" }, { "param": "s", "type": "XML_Char" }, { "param": "len", "type": "int" } ]

[ "Unlicense" ]

[ "expat", "callback", "for", "the", "end", "of", "an", "element" ]

[ "static", "void", "expat_element_end", "(", "void", "*", "data", ",", "const", "XML_Char", "*", "name", ")", "{", "xml_parse_info", "*", "parse_info", "=", "(", "xml_parse_info", "*", ")", "data", ";", "xml_data_node", "*", "*", "curnode", "=", "&", "parse_info", "->", "curnode", ";", "char", "*", "orig", ";", "orig", "=", "(", "char", "*", ")", "(", "*", "curnode", ")", "->", "value", ";", "if", "(", "orig", "!=", "NULL", "&&", "!", "(", "parse_info", "->", "flags", "&", "XML_PARSE_FLAG_WHITESPACE_SIGNIFICANT", ")", ")", "{", "char", "*", "start", "=", "orig", ";", "char", "*", "end", "=", "start", "+", "strlen", "(", "start", ")", ";", "while", "(", "*", "start", "&&", "isspace", "(", "(", "UINT8", ")", "*", "start", ")", ")", "start", "++", ";", "while", "(", "end", ">", "start", "&&", "isspace", "(", "(", "UINT8", ")", "end", "[", "-1", "]", ")", ")", "end", "--", ";", "if", "(", "start", "==", "end", ")", "{", "free", "(", "orig", ")", ";", "(", "*", "curnode", ")", "->", "value", "=", "NULL", ";", "}", "else", "{", "memmove", "(", "orig", ",", "start", ",", "end", "-", "start", ")", ";", "orig", "[", "end", "-", "start", "]", "=", "0", ";", "}", "}", "*", "curnode", "=", "(", "*", "curnode", ")", "->", "parent", ";", "}" ]

[ "expat_element_end", "-", "expat", "callback", "for", "the", "end", "of", "an", "element" ]

[ "/* strip leading/trailing spaces from the value data */", "/* first strip leading spaces */", "/* then strip trailing spaces */", "/* if nothing left, just free it */", "/* otherwise, memmove the data */", "/* back us up a node */" ]

[ { "param": "data", "type": "void" }, { "param": "name", "type": "XML_Char" } ]

[ "Unlicense" ]

[ "add", "a", "new", "node", "to", "the", "parent" ]

[ "static", "xml_data_node", "*", "add_child", "(", "xml_data_node", "*", "parent", ",", "const", "char", "*", "name", ",", "const", "char", "*", "value", ")", "{", "xml_data_node", "*", "*", "pnode", ";", "xml_data_node", "*", "node", ";", "node", "=", "(", "xml_data_node", "*", ")", "malloc", "(", "sizeof", "(", "*", "node", ")", ")", ";", "if", "(", "node", "==", "NULL", ")", "return", "NULL", ";", "node", "->", "next", "=", "NULL", ";", "node", "->", "parent", "=", "parent", ";", "node", "->", "child", "=", "NULL", ";", "node", "->", "name", "=", "copystring_lower", "(", "name", ")", ";", "if", "(", "node", "->", "name", "==", "NULL", ")", "{", "free", "(", "node", ")", ";", "return", "NULL", ";", "}", "node", "->", "value", "=", "copystring", "(", "value", ")", ";", "if", "(", "node", "->", "value", "==", "NULL", "&&", "value", "!=", "NULL", ")", "{", "free", "(", "(", "void", "*", ")", "node", "->", "name", ")", ";", "free", "(", "node", ")", ";", "return", "NULL", ";", "}", "node", "->", "attribute", "=", "NULL", ";", "for", "(", "pnode", "=", "&", "parent", "->", "child", ";", "*", "pnode", ";", "pnode", "=", "&", "(", "*", "pnode", ")", "->", "next", ")", ";", "*", "pnode", "=", "node", ";", "return", "node", ";", "}" ]

[ "add_child", "-", "add", "a", "new", "node", "to", "the", "parent" ]

[ "/* new element: create a new node */", "/* initialize the members */", "/* add us to the end of the list of siblings */" ]

[ { "param": "parent", "type": "xml_data_node" }, { "param": "name", "type": "char" }, { "param": "value", "type": "char" } ]

[ "Unlicense" ]

[ "add", "a", "new", "attribute", "to", "the", "given", "node" ]

[ "static", "xml_attribute_node", "*", "add_attribute", "(", "xml_data_node", "*", "node", ",", "const", "char", "*", "name", ",", "const", "char", "*", "value", ")", "{", "xml_attribute_node", "*", "anode", ",", "*", "*", "panode", ";", "anode", "=", "(", "xml_attribute_node", "*", ")", "malloc", "(", "sizeof", "(", "*", "anode", ")", ")", ";", "if", "(", "anode", "==", "NULL", ")", "return", "NULL", ";", "anode", "->", "next", "=", "NULL", ";", "anode", "->", "name", "=", "copystring_lower", "(", "name", ")", ";", "if", "(", "anode", "->", "name", "==", "NULL", ")", "{", "free", "(", "anode", ")", ";", "return", "NULL", ";", "}", "anode", "->", "value", "=", "copystring", "(", "value", ")", ";", "if", "(", "anode", "->", "value", "==", "NULL", ")", "{", "free", "(", "(", "void", "*", ")", "anode", "->", "name", ")", ";", "free", "(", "anode", ")", ";", "return", "NULL", ";", "}", "for", "(", "panode", "=", "&", "node", "->", "attribute", ";", "*", "panode", ";", "panode", "=", "&", "(", "*", "panode", ")", "->", "next", ")", ";", "*", "panode", "=", "anode", ";", "return", "anode", ";", "}" ]

[ "add_attribute", "-", "add", "a", "new", "attribute", "to", "the", "given", "node" ]

[ "/* allocate a new attribute node */", "/* fill it in */", "/* add us to the end of the list of attributes */" ]

[ { "param": "node", "type": "xml_data_node" }, { "param": "name", "type": "char" }, { "param": "value", "type": "char" } ]

[ "Unlicense" ]

[ "recursively", "write", "an", "XML", "node", "and", "its", "children", "to", "a", "file" ]

[ "static", "void", "write_node_recursive", "(", "xml_data_node", "*", "node", ",", "int", "indent", ",", "core_file", "*", "file", ")", "{", "xml_attribute_node", "*", "anode", ";", "xml_data_node", "*", "child", ";", "core_fprintf", "(", "file", ",", "\"", "\"", ",", "indent", ",", "\"", "\"", ",", "node", "->", "name", ")", ";", "for", "(", "anode", "=", "node", "->", "attribute", ";", "anode", ";", "anode", "=", "anode", "->", "next", ")", "core_fprintf", "(", "file", ",", "\"", "\\\"", "\\\"", "\"", ",", "anode", "->", "name", ",", "anode", "->", "value", ")", ";", "if", "(", "node", "->", "child", "==", "NULL", "&&", "node", "->", "value", "==", "NULL", ")", "core_fprintf", "(", "file", ",", "\"", "\\n", "\"", ")", ";", "else", "{", "core_fprintf", "(", "file", ",", "\"", "\\n", "\"", ")", ";", "if", "(", "node", "->", "value", "!=", "NULL", ")", "core_fprintf", "(", "file", ",", "\"", "\\n", "\"", ",", "indent", "+", "4", ",", "\"", "\"", ",", "node", "->", "value", ")", ";", "if", "(", "node", "->", "child", "!=", "NULL", ")", "{", "for", "(", "child", "=", "node", "->", "child", ";", "child", ";", "child", "=", "child", "->", "next", ")", "write_node_recursive", "(", "child", ",", "indent", "+", "4", ",", "file", ")", ";", "}", "core_fprintf", "(", "file", ",", "\"", "\\n", "\"", ",", "indent", ",", "\"", "\"", ",", "node", "->", "name", ")", ";", "}", "}" ]

[ "write_node_recursive", "-", "recursively", "write", "an", "XML", "node", "and", "its", "children", "to", "a", "file" ]

[ "/* output this tag */", "/* output any attributes */", "/* if there are no children and no value, end the tag here */", "/* otherwise, close this tag and output more stuff */", "/* if there is a value, output that here */", "/* loop over children and output them as well */", "/* write a closing tag */" ]

[ { "param": "node", "type": "xml_data_node" }, { "param": "indent", "type": "int" }, { "param": "file", "type": "core_file" } ]

[ "Unlicense" ]

[ "recursively", "free", "the", "data", "allocated", "to", "an", "XML", "node" ]

[ "static", "void", "free_node_recursive", "(", "xml_data_node", "*", "node", ")", "{", "xml_attribute_node", "*", "anode", ",", "*", "nanode", ";", "xml_data_node", "*", "child", ",", "*", "nchild", ";", "if", "(", "node", "->", "name", "!=", "NULL", ")", "free", "(", "(", "void", "*", ")", "node", "->", "name", ")", ";", "if", "(", "node", "->", "value", "!=", "NULL", ")", "free", "(", "(", "void", "*", ")", "node", "->", "value", ")", ";", "for", "(", "anode", "=", "node", "->", "attribute", ";", "anode", ";", "anode", "=", "nanode", ")", "{", "if", "(", "anode", "->", "name", "!=", "NULL", ")", "free", "(", "(", "void", "*", ")", "anode", "->", "name", ")", ";", "if", "(", "anode", "->", "value", "!=", "NULL", ")", "free", "(", "(", "void", "*", ")", "anode", "->", "value", ")", ";", "nanode", "=", "anode", "->", "next", ";", "free", "(", "anode", ")", ";", "}", "for", "(", "child", "=", "node", "->", "child", ";", "child", ";", "child", "=", "nchild", ")", "{", "nchild", "=", "child", "->", "next", ";", "free_node_recursive", "(", "child", ")", ";", "}", "free", "(", "node", ")", ";", "}" ]

[ "free_node_recursive", "-", "recursively", "free", "the", "data", "allocated", "to", "an", "XML", "node" ]

[ "/* free name/value */", "/* free attributes */", "/* free name/value */", "/* note the next node and free this node */", "/* free the children */", "/* note the next node and free this node */", "/* finally free ourself */" ]

[ { "param": "node", "type": "xml_data_node" } ]

[ "Unlicense" ]

[ "execute", "basic", "commands", "that", "don", "'", "t", "require", "any", "context" ]

[ "static", "int", "execute_simple_commands", "(", "core_options", "*", "options", ",", "const", "char", "*", "exename", ")", "{", "if", "(", "options_get_bool", "(", "options", ",", "CLIOPTION_HELP", ")", ")", "{", "display_help", "(", ")", ";", "return", "MAMERR_NONE", ";", "}", "if", "(", "options_get_bool", "(", "options", ",", "CLIOPTION_SHOWUSAGE", ")", ")", "{", "mame_printf_info", "(", "\"", "\\n", "\\n", "\\n", "\"", ",", "exename", ",", "GAMENOUN", ")", ";", "options_output_help", "(", "options", ",", "help_output", ")", ";", "return", "MAMERR_NONE", ";", "}", "if", "(", "options_get_bool", "(", "options", ",", "CLIOPTION_VALIDATE", ")", ")", "{", "extern", "int", "mame_validitychecks", "(", "const", "game_driver", "*", "driver", ")", ";", "return", "mame_validitychecks", "(", "NULL", ")", ";", "}", "return", "-1", ";", "}" ]

[ "execute_simple_commands", "-", "execute", "basic", "commands", "that", "don", "'", "t", "require", "any", "context" ]

[ "/* help? */", "/* showusage? */", "/* validate? */" ]

[ { "param": "options", "type": "core_options" }, { "param": "exename", "type": "char" } ]

[ "Unlicense" ]

[ "output", "the", "XML", "data", "for", "one", "or", "more", "games" ]

[ "int", "cli_info_listxml", "(", "core_options", "*", "options", ",", "const", "char", "*", "gamename", ")", "{", "init_resource_tracking", "(", ")", ";", "print_mame_xml", "(", "stdout", ",", "drivers", ",", "gamename", ")", ";", "exit_resource_tracking", "(", ")", ";", "return", "MAMERR_NONE", ";", "}" ]

[ "cli_info_listxml", "-", "output", "the", "XML", "data", "for", "one", "or", "more", "games" ]

[ "/* since print_mame_xml expands the machine driver, we need to set things up */", "/* clean up our tracked resources */" ]

[ { "param": "options", "type": "core_options" }, { "param": "gamename", "type": "char" } ]

[ "Unlicense" ]

[ "output", "the", "name", "and", "description", "of", "one", "or", "more", "games" ]

[ "int", "cli_info_listfull", "(", "core_options", "*", "options", ",", "const", "char", "*", "gamename", ")", "{", "int", "drvindex", ",", "count", "=", "0", ";", "for", "(", "drvindex", "=", "0", ";", "drivers", "[", "drvindex", "]", "!=", "NULL", ";", "drvindex", "++", ")", "if", "(", "(", "drivers", "[", "drvindex", "]", "->", "flags", "&", "GAME_NO_STANDALONE", ")", "==", "0", "&&", "mame_strwildcmp", "(", "gamename", ",", "drivers", "[", "drvindex", "]", "->", "name", ")", "==", "0", ")", "{", "if", "(", "count", "==", "0", ")", "mame_printf_info", "(", "\"", "\\n", "\"", ")", ";", "mame_printf_info", "(", "\"", "\\\"", "\\\"", "\\n", "\"", ",", "drivers", "[", "drvindex", "]", "->", "name", ",", "drivers", "[", "drvindex", "]", "->", "description", ")", ";", "count", "++", ";", "}", "return", "(", "count", ">", "0", ")", "?", "MAMERR_NONE", ":", "MAMERR_NO_SUCH_GAME", ";", "}" ]

[ "cli_info_listfull", "-", "output", "the", "name", "and", "description", "of", "one", "or", "more", "games" ]

[ "/* iterate over drivers */", "/* print the header on the first one */", "/* output the remaining information */", "/* return an error if none found */" ]

[ { "param": "options", "type": "core_options" }, { "param": "gamename", "type": "char" } ]

[ "Unlicense" ]

[ "output", "the", "name", "and", "source", "filename", "of", "one", "or", "more", "games" ]

[ "int", "cli_info_listsource", "(", "core_options", "*", "options", ",", "const", "char", "*", "gamename", ")", "{", "astring", "*", "filename", "=", "astring_alloc", "(", ")", ";", "int", "drvindex", ",", "count", "=", "0", ";", "for", "(", "drvindex", "=", "0", ";", "drivers", "[", "drvindex", "]", "!=", "NULL", ";", "drvindex", "++", ")", "if", "(", "mame_strwildcmp", "(", "gamename", ",", "drivers", "[", "drvindex", "]", "->", "name", ")", "==", "0", ")", "{", "mame_printf_info", "(", "\"", "\\n", "\"", ",", "drivers", "[", "drvindex", "]", "->", "name", ",", "astring_c", "(", "core_filename_extract_base", "(", "filename", ",", "drivers", "[", "drvindex", "]", "->", "source_file", ",", "FALSE", ")", ")", ")", ";", "count", "++", ";", "}", "astring_free", "(", "filename", ")", ";", "return", "(", "count", ">", "0", ")", "?", "MAMERR_NONE", ":", "MAMERR_NO_SUCH_GAME", ";", "}" ]

[ "cli_info_listsource", "-", "output", "the", "name", "and", "source", "filename", "of", "one", "or", "more", "games" ]

[ "/* iterate over drivers */", "/* output the remaining information */", "/* return an error if none found */" ]

[ { "param": "options", "type": "core_options" }, { "param": "gamename", "type": "char" } ]

[ "Unlicense" ]

[ "output", "the", "name", "and", "source", "filename", "of", "one", "or", "more", "games" ]

[ "int", "cli_info_listclones", "(", "core_options", "*", "options", ",", "const", "char", "*", "gamename", ")", "{", "int", "drvindex", ",", "count", "=", "0", ";", "for", "(", "drvindex", "=", "0", ";", "drivers", "[", "drvindex", "]", "!=", "NULL", ";", "drvindex", "++", ")", "{", "const", "game_driver", "*", "clone_of", "=", "driver_get_clone", "(", "drivers", "[", "drvindex", "]", ")", ";", "if", "(", "clone_of", "!=", "NULL", "&&", "(", "clone_of", "->", "flags", "&", "GAME_IS_BIOS_ROOT", ")", "==", "0", ")", "if", "(", "mame_strwildcmp", "(", "gamename", ",", "drivers", "[", "drvindex", "]", "->", "name", ")", "==", "0", "||", "mame_strwildcmp", "(", "gamename", ",", "clone_of", "->", "name", ")", "==", "0", ")", "{", "if", "(", "count", "==", "0", ")", "mame_printf_info", "(", "\"", "\\n", "\"", ")", ";", "mame_printf_info", "(", "\"", "\\n", "\"", ",", "drivers", "[", "drvindex", "]", "->", "name", ",", "clone_of", "->", "name", ")", ";", "count", "++", ";", "}", "}", "return", "(", "count", ">", "0", ")", "?", "MAMERR_NONE", ":", "MAMERR_NO_SUCH_GAME", ";", "}" ]

[ "cli_info_listclones", "-", "output", "the", "name", "and", "source", "filename", "of", "one", "or", "more", "games" ]

[ "/* iterate over drivers */", "/* if we are a clone, and either our name matches the gamename, or the clone's name matches, display us */", "/* print the header on the first one */", "/* output the remaining information */", "/* return an error if none found */" ]

[ { "param": "options", "type": "core_options" }, { "param": "gamename", "type": "char" } ]

[ "Unlicense" ]

[ "output", "the", "name", "and", "source", "filename", "of", "one", "or", "more", "games" ]

[ "int", "cli_info_listbrothers", "(", "core_options", "*", "options", ",", "const", "char", "*", "gamename", ")", "{", "UINT8", "*", "didit", "=", "alloc_array_or_die", "(", "UINT8", ",", "driver_list_get_count", "(", "drivers", ")", ")", ";", "astring", "*", "filename", "=", "astring_alloc", "(", ")", ";", "int", "drvindex", ",", "count", "=", "0", ";", "memset", "(", "didit", ",", "0", ",", "driver_list_get_count", "(", "drivers", ")", ")", ";", "for", "(", "drvindex", "=", "0", ";", "drivers", "[", "drvindex", "]", "!=", "NULL", ";", "drvindex", "++", ")", "if", "(", "!", "didit", "[", "drvindex", "]", "&&", "mame_strwildcmp", "(", "gamename", ",", "drivers", "[", "drvindex", "]", "->", "name", ")", "==", "0", ")", "{", "int", "matchindex", ";", "didit", "[", "drvindex", "]", "=", "TRUE", ";", "if", "(", "count", ">", "0", ")", "mame_printf_info", "(", "\"", "\\n", "\"", ")", ";", "mame_printf_info", "(", "\"", "\\n", "\"", ",", "drivers", "[", "drvindex", "]", "->", "name", ",", "astring_c", "(", "core_filename_extract_base", "(", "filename", ",", "drivers", "[", "drvindex", "]", "->", "source_file", ",", "FALSE", ")", ")", ")", ";", "for", "(", "matchindex", "=", "0", ";", "drivers", "[", "matchindex", "]", ";", "matchindex", "++", ")", "if", "(", "matchindex", "!=", "drvindex", "&&", "strcmp", "(", "drivers", "[", "drvindex", "]", "->", "source_file", ",", "drivers", "[", "matchindex", "]", "->", "source_file", ")", "==", "0", ")", "{", "const", "char", "*", "matchstring", "=", "(", "mame_strwildcmp", "(", "gamename", ",", "drivers", "[", "matchindex", "]", "->", "name", ")", "==", "0", ")", "?", "\"", "\"", ":", "\"", "\"", ";", "const", "game_driver", "*", "clone_of", "=", "driver_get_clone", "(", "drivers", "[", "matchindex", "]", ")", ";", "if", "(", "clone_of", "!=", "NULL", "&&", "(", "clone_of", "->", "flags", "&", "GAME_IS_BIOS_ROOT", ")", "==", "0", ")", "mame_printf_info", "(", "\"", "\\n", "\"", ",", "matchstring", ",", "drivers", "[", "matchindex", "]", "->", "name", ",", "clone_of", "->", "name", ")", ";", "else", "mame_printf_info", "(", "\"", "\\n", "\"", ",", "matchstring", ",", "drivers", "[", "matchindex", "]", "->", "name", ")", ";", "didit", "[", "matchindex", "]", "=", "TRUE", ";", "}", "count", "++", ";", "}", "astring_free", "(", "filename", ")", ";", "free", "(", "didit", ")", ";", "return", "(", "count", ">", "0", ")", "?", "MAMERR_NONE", ":", "MAMERR_NO_SUCH_GAME", ";", "}" ]

[ "cli_info_listbrothers", "-", "output", "the", "name", "and", "source", "filename", "of", "one", "or", "more", "games" ]

[ "/* iterate over drivers */", "/* now iterate again over drivers, finding those with the same source file */", "/* return an error if none found */" ]

[ { "param": "options", "type": "core_options" }, { "param": "gamename", "type": "char" } ]

[ "Unlicense" ]

[ "output", "the", "CRC", "and", "name", "of", "all", "ROMs", "referenced", "by", "MAME" ]

[ "int", "cli_info_listcrc", "(", "core_options", "*", "options", ",", "const", "char", "*", "gamename", ")", "{", "int", "drvindex", ",", "count", "=", "0", ";", "for", "(", "drvindex", "=", "0", ";", "drivers", "[", "drvindex", "]", "!=", "NULL", ";", "drvindex", "++", ")", "if", "(", "mame_strwildcmp", "(", "gamename", ",", "drivers", "[", "drvindex", "]", "->", "name", ")", "==", "0", ")", "{", "machine_config", "*", "config", "=", "machine_config_alloc", "(", "drivers", "[", "drvindex", "]", "->", "machine_config", ")", ";", "const", "rom_entry", "*", "region", ",", "*", "rom", ";", "const", "rom_source", "*", "source", ";", "for", "(", "source", "=", "rom_first_source", "(", "drivers", "[", "drvindex", "]", ",", "config", ")", ";", "source", "!=", "NULL", ";", "source", "=", "rom_next_source", "(", "drivers", "[", "drvindex", "]", ",", "config", ",", "source", ")", ")", "for", "(", "region", "=", "rom_first_region", "(", "drivers", "[", "drvindex", "]", ",", "source", ")", ";", "region", ";", "region", "=", "rom_next_region", "(", "region", ")", ")", "for", "(", "rom", "=", "rom_first_file", "(", "region", ")", ";", "rom", ";", "rom", "=", "rom_next_file", "(", "rom", ")", ")", "{", "char", "hashbuf", "[", "HASH_BUF_SIZE", "]", ";", "if", "(", "hash_data_extract_printable_checksum", "(", "ROM_GETHASHDATA", "(", "rom", ")", ",", "HASH_CRC", ",", "hashbuf", ")", ")", "mame_printf_info", "(", "\"", "\\n", "\"", ",", "hashbuf", ",", "ROM_GETNAME", "(", "rom", ")", ",", "drivers", "[", "drvindex", "]", "->", "description", ")", ";", "}", "count", "++", ";", "machine_config_free", "(", "config", ")", ";", "}", "return", "(", "count", ">", "0", ")", "?", "MAMERR_NONE", ":", "MAMERR_NO_SUCH_GAME", ";", "}" ]

[ "cli_info_listcrc", "-", "output", "the", "CRC", "and", "name", "of", "all", "ROMs", "referenced", "by", "MAME" ]

[ "/* iterate over drivers */", "/* iterate over sources, regions, and then ROMs within the region */", "/* if we have a CRC, display it */", "/* return an error if none found */" ]

[ { "param": "options", "type": "core_options" }, { "param": "gamename", "type": "char" } ]

[ "Unlicense" ]

[ "output", "the", "list", "of", "ROMs", "referenced", "by", "a", "given", "game", "or", "set", "of", "games" ]

[ "int", "cli_info_listroms", "(", "core_options", "*", "options", ",", "const", "char", "*", "gamename", ")", "{", "int", "drvindex", ",", "count", "=", "0", ";", "for", "(", "drvindex", "=", "0", ";", "drivers", "[", "drvindex", "]", "!=", "NULL", ";", "drvindex", "++", ")", "if", "(", "mame_strwildcmp", "(", "gamename", ",", "drivers", "[", "drvindex", "]", "->", "name", ")", "==", "0", ")", "{", "machine_config", "*", "config", "=", "machine_config_alloc", "(", "drivers", "[", "drvindex", "]", "->", "machine_config", ")", ";", "const", "rom_entry", "*", "region", ",", "*", "rom", ";", "const", "rom_source", "*", "source", ";", "if", "(", "count", ">", "0", ")", "mame_printf_info", "(", "\"", "\\n", "\"", ")", ";", "mame_printf_info", "(", "\"", "\\\"", "\\\"", "\\n", "\"", "\"", "\\n", "\"", ",", "drivers", "[", "drvindex", "]", "->", "name", ")", ";", "for", "(", "source", "=", "rom_first_source", "(", "drivers", "[", "drvindex", "]", ",", "config", ")", ";", "source", "!=", "NULL", ";", "source", "=", "rom_next_source", "(", "drivers", "[", "drvindex", "]", ",", "config", ",", "source", ")", ")", "for", "(", "region", "=", "rom_first_region", "(", "drivers", "[", "drvindex", "]", ",", "source", ")", ";", "region", "!=", "NULL", ";", "region", "=", "rom_next_region", "(", "region", ")", ")", "for", "(", "rom", "=", "rom_first_file", "(", "region", ")", ";", "rom", "!=", "NULL", ";", "rom", "=", "rom_next_file", "(", "rom", ")", ")", "{", "const", "char", "*", "name", "=", "ROM_GETNAME", "(", "rom", ")", ";", "const", "char", "*", "hash", "=", "ROM_GETHASHDATA", "(", "rom", ")", ";", "char", "hashbuf", "[", "HASH_BUF_SIZE", "]", ";", "int", "length", "=", "-1", ";", "if", "(", "ROMREGION_ISROMDATA", "(", "region", ")", ")", "length", "=", "rom_file_size", "(", "rom", ")", ";", "mame_printf_info", "(", "\"", "\"", ",", "name", ")", ";", "if", "(", "length", ">=", "0", ")", "mame_printf_info", "(", "\"", "\"", ",", "length", ")", ";", "else", "mame_printf_info", "(", "\"", "\"", ")", ";", "if", "(", "!", "hash_data_has_info", "(", "hash", ",", "HASH_INFO_NO_DUMP", ")", ")", "{", "if", "(", "hash_data_has_info", "(", "hash", ",", "HASH_INFO_BAD_DUMP", ")", ")", "mame_printf_info", "(", "\"", "\"", ")", ";", "hash_data_print", "(", "hash", ",", "0", ",", "hashbuf", ")", ";", "mame_printf_info", "(", "\"", "\"", ",", "hashbuf", ")", ";", "}", "else", "mame_printf_info", "(", "\"", "\"", ")", ";", "mame_printf_info", "(", "\"", "\\n", "\"", ")", ";", "}", "count", "++", ";", "machine_config_free", "(", "config", ")", ";", "}", "return", "(", "count", ">", "0", ")", "?", "MAMERR_NONE", ":", "MAMERR_NO_SUCH_GAME", ";", "}" ]

[ "cli_info_listroms", "-", "output", "the", "list", "of", "ROMs", "referenced", "by", "a", "given", "game", "or", "set", "of", "games" ]

[ "/* iterate over drivers */", "/* print the header */", "/* iterate over sources, regions and then ROMs within the region */", "/* accumulate the total length of all chunks */", "/* start with the name */", "/* output the length next */", "/* output the hash data */", "/* end with a CR */" ]

[ { "param": "options", "type": "core_options" }, { "param": "gamename", "type": "char" } ]

[ "Unlicense" ]

[ "output", "the", "list", "of", "samples", "referenced", "by", "a", "given", "game", "or", "set", "of", "games" ]

[ "int", "cli_info_listsamples", "(", "core_options", "*", "options", ",", "const", "char", "*", "gamename", ")", "{", "int", "count", "=", "0", ";", "#if", "(", "HAS_SAMPLES", ")", "\n", "int", "drvindex", ";", "init_resource_tracking", "(", ")", ";", "for", "(", "drvindex", "=", "0", ";", "drivers", "[", "drvindex", "]", "!=", "NULL", ";", "drvindex", "++", ")", "if", "(", "mame_strwildcmp", "(", "gamename", ",", "drivers", "[", "drvindex", "]", "->", "name", ")", "==", "0", ")", "{", "machine_config", "*", "config", "=", "machine_config_alloc", "(", "drivers", "[", "drvindex", "]", "->", "machine_config", ")", ";", "const", "device_config", "*", "device", ";", "for", "(", "device", "=", "sound_first", "(", "config", ")", ";", "device", "!=", "NULL", ";", "device", "=", "sound_next", "(", "device", ")", ")", "if", "(", "sound_get_type", "(", "device", ")", "==", "SOUND_SAMPLES", ")", "{", "const", "char", "*", "const", "*", "samplenames", "=", "(", "(", "const", "samples_interface", "*", ")", "device", "->", "static_config", ")", "->", "samplenames", ";", "int", "sampnum", ";", "if", "(", "samplenames", "!=", "NULL", ")", "for", "(", "sampnum", "=", "0", ";", "samplenames", "[", "sampnum", "]", "!=", "NULL", ";", "sampnum", "++", ")", "mame_printf_info", "(", "\"", "\\n", "\"", ",", "samplenames", "[", "sampnum", "]", ")", ";", "}", "count", "++", ";", "machine_config_free", "(", "config", ")", ";", "}", "exit_resource_tracking", "(", ")", ";", "#else", "mame_printf_error", "(", "\"", "\\n", "\"", ")", ";", "#endif", "return", "(", "count", ">", "0", ")", "?", "MAMERR_NONE", ":", "MAMERR_NO_SUCH_GAME", ";", "}" ]

[ "cli_info_listsamples", "-", "output", "the", "list", "of", "samples", "referenced", "by", "a", "given", "game", "or", "set", "of", "games" ]

[ "/* since we expand the machine driver, we need to set things up */", "/* iterate over drivers */", "/* find samples interfaces */", "/* if the list is legit, walk it and print the sample info */", "/* clean up our tracked resources */" ]

[ { "param": "options", "type": "core_options" }, { "param": "gamename", "type": "char" } ]

[ "Unlicense" ]

[ "verify", "the", "ROM", "sets", "of", "one", "or", "more", "games" ]

[ "static", "int", "info_verifyroms", "(", "core_options", "*", "options", ",", "const", "char", "*", "gamename", ")", "{", "int", "correct", "=", "0", ";", "int", "incorrect", "=", "0", ";", "int", "notfound", "=", "0", ";", "int", "drvindex", ";", "for", "(", "drvindex", "=", "0", ";", "drivers", "[", "drvindex", "]", "!=", "NULL", ";", "drvindex", "++", ")", "if", "(", "mame_strwildcmp", "(", "gamename", ",", "drivers", "[", "drvindex", "]", "->", "name", ")", "==", "0", ")", "{", "audit_record", "*", "audit", ";", "int", "audit_records", ";", "int", "res", ";", "audit_records", "=", "audit_images", "(", "options", ",", "drivers", "[", "drvindex", "]", ",", "AUDIT_VALIDATE_FAST", ",", "&", "audit", ")", ";", "res", "=", "audit_summary", "(", "drivers", "[", "drvindex", "]", ",", "audit_records", ",", "audit", ",", "TRUE", ")", ";", "if", "(", "audit_records", ">", "0", ")", "free", "(", "audit", ")", ";", "if", "(", "res", "==", "NOTFOUND", ")", "notfound", "++", ";", "else", "{", "const", "game_driver", "*", "clone_of", ";", "mame_printf_info", "(", "\"", "\"", ",", "drivers", "[", "drvindex", "]", "->", "name", ")", ";", "clone_of", "=", "driver_get_clone", "(", "drivers", "[", "drvindex", "]", ")", ";", "if", "(", "clone_of", "!=", "NULL", ")", "mame_printf_info", "(", "\"", "\"", ",", "clone_of", "->", "name", ")", ";", "switch", "(", "res", ")", "{", "case", "INCORRECT", ":", "mame_printf_info", "(", "\"", "\\n", "\"", ")", ";", "incorrect", "++", ";", "break", ";", "case", "CORRECT", ":", "mame_printf_info", "(", "\"", "\\n", "\"", ")", ";", "correct", "++", ";", "break", ";", "case", "BEST_AVAILABLE", ":", "mame_printf_info", "(", "\"", "\\n", "\"", ")", ";", "correct", "++", ";", "break", ";", "}", "}", "}", "zip_file_cache_clear", "(", ")", ";", "if", "(", "correct", "+", "incorrect", "==", "0", ")", "{", "if", "(", "notfound", ">", "0", ")", "mame_printf_info", "(", "\"", "\\\"", "\\\"", "\\n", "\"", ",", "gamename", ")", ";", "else", "mame_printf_info", "(", "\"", "\\\"", "\\\"", "\\n", "\"", ",", "gamename", ")", ";", "return", "MAMERR_NO_SUCH_GAME", ";", "}", "else", "{", "mame_printf_info", "(", "\"", "\\n", "\"", ",", "correct", "+", "incorrect", ",", "correct", ")", ";", "return", "(", "incorrect", ">", "0", ")", "?", "MAMERR_MISSING_FILES", ":", "MAMERR_NONE", ";", "}", "}" ]

[ "info_verifyroms", "-", "verify", "the", "ROM", "sets", "of", "one", "or", "more", "games" ]

[ "/* iterate over drivers */", "/* audit the ROMs in this set */", "/* if not found, count that and leave it at that */", "/* else display information about what we discovered */", "/* output the name of the driver and its clone */", "/* switch off of the result */", "/* clear out any cached files */", "/* if we didn't get anything at all, display a generic end message */", "/* otherwise, print a summary */" ]

[ { "param": "options", "type": "core_options" }, { "param": "gamename", "type": "char" } ]

[ "Unlicense" ]

[ "verify", "the", "sample", "sets", "of", "one", "or", "more", "games" ]

[ "static", "int", "info_verifysamples", "(", "core_options", "*", "options", ",", "const", "char", "*", "gamename", ")", "{", "int", "correct", "=", "0", ";", "int", "incorrect", "=", "0", ";", "int", "notfound", "=", "FALSE", ";", "int", "drvindex", ";", "for", "(", "drvindex", "=", "0", ";", "drivers", "[", "drvindex", "]", "!=", "NULL", ";", "drvindex", "++", ")", "if", "(", "mame_strwildcmp", "(", "gamename", ",", "drivers", "[", "drvindex", "]", "->", "name", ")", "==", "0", ")", "{", "audit_record", "*", "audit", ";", "int", "audit_records", ";", "int", "res", ";", "audit_records", "=", "audit_samples", "(", "options", ",", "drivers", "[", "drvindex", "]", ",", "&", "audit", ")", ";", "res", "=", "audit_summary", "(", "drivers", "[", "drvindex", "]", ",", "audit_records", ",", "audit", ",", "TRUE", ")", ";", "if", "(", "audit_records", ">", "0", ")", "free", "(", "audit", ")", ";", "else", "continue", ";", "if", "(", "res", "==", "NOTFOUND", ")", "{", "mame_printf_error", "(", "\"", "\\\"", "\\\"", "\\n", "\"", ",", "drivers", "[", "drvindex", "]", "->", "name", ")", ";", "notfound", "=", "TRUE", ";", "}", "else", "{", "mame_printf_info", "(", "\"", "\"", ",", "drivers", "[", "drvindex", "]", "->", "name", ")", ";", "switch", "(", "res", ")", "{", "case", "INCORRECT", ":", "mame_printf_info", "(", "\"", "\\n", "\"", ")", ";", "incorrect", "++", ";", "break", ";", "case", "CORRECT", ":", "mame_printf_info", "(", "\"", "\\n", "\"", ")", ";", "correct", "++", ";", "break", ";", "case", "BEST_AVAILABLE", ":", "mame_printf_info", "(", "\"", "\\n", "\"", ")", ";", "correct", "++", ";", "break", ";", "}", "}", "}", "zip_file_cache_clear", "(", ")", ";", "if", "(", "correct", "+", "incorrect", "==", "0", ")", "{", "if", "(", "!", "notfound", ")", "mame_printf_error", "(", "\"", "\\\"", "\\\"", "\\n", "\"", ",", "gamename", ")", ";", "return", "MAMERR_NO_SUCH_GAME", ";", "}", "else", "{", "mame_printf_info", "(", "\"", "\\n", "\"", ",", "correct", "+", "incorrect", ",", "correct", ")", ";", "return", "(", "incorrect", ">", "0", ")", "?", "MAMERR_MISSING_FILES", ":", "MAMERR_NONE", ";", "}", "}" ]

[ "info_verifysamples", "-", "verify", "the", "sample", "sets", "of", "one", "or", "more", "games" ]

[ "/* now iterate over drivers */", "/* audit the samples in this set */", "/* if not found, print a message and set the flag */", "/* else display information about what we discovered */", "/* switch off of the result */", "/* clear out any cached files */", "/* if we didn't get anything at all because of an unsupported set, display message */", "/* otherwise, print a summary */" ]

[ { "param": "options", "type": "core_options" }, { "param": "gamename", "type": "char" } ]

[ "Unlicense" ]

[ "identify", "ROMs", "by", "looking", "for", "matches", "in", "our", "internal", "database" ]

[ "static", "int", "info_romident", "(", "core_options", "*", "options", ",", "const", "char", "*", "gamename", ")", "{", "romident_status", "status", ";", "if", "(", "gamename", "==", "NULL", ")", "return", "MAMERR_FATALERROR", ";", "romident", "(", "gamename", ",", "&", "status", ")", ";", "zip_file_cache_clear", "(", ")", ";", "if", "(", "status", ".", "matches", "==", "status", ".", "total", ")", "return", "MAMERR_NONE", ";", "else", "if", "(", "status", ".", "matches", "==", "status", ".", "total", "-", "status", ".", "nonroms", ")", "return", "MAMERR_IDENT_NONROMS", ";", "else", "if", "(", "status", ".", "matches", ">", "0", ")", "return", "MAMERR_IDENT_PARTIAL", ";", "else", "return", "MAMERR_IDENT_NONE", ";", "}" ]

[ "info_romident", "-", "identify", "ROMs", "by", "looking", "for", "matches", "in", "our", "internal", "database" ]

[ "/* a NULL gamename is a fatal error */", "/* do the identification */", "/* clear out any cached files */", "/* return the appropriate error code */" ]

[ { "param": "options", "type": "core_options" }, { "param": "gamename", "type": "char" } ]

[ "Unlicense" ]

[ "identify", "a", "file", ";", "if", "it", "is", "a", "ZIP", "file", "scan", "it", "and", "identify", "all", "enclosed", "files" ]

[ "static", "void", "identify_file", "(", "const", "char", "*", "name", ",", "romident_status", "*", "status", ")", "{", "file_error", "filerr", ";", "osd_file", "*", "file", ";", "UINT64", "length", ";", "filerr", "=", "osd_open", "(", "name", ",", "OPEN_FLAG_READ", ",", "&", "file", ",", "&", "length", ")", ";", "if", "(", "filerr", "==", "FILERR_NONE", "&&", "length", ">", "0", "&&", "(", "UINT32", ")", "length", "==", "length", ")", "{", "UINT8", "*", "data", "=", "(", "UINT8", "*", ")", "malloc", "(", "length", ")", ";", "if", "(", "data", "!=", "NULL", ")", "{", "UINT32", "bytes", ";", "filerr", "=", "osd_read", "(", "file", ",", "data", ",", "0", ",", "length", ",", "&", "bytes", ")", ";", "if", "(", "filerr", "==", "FILERR_NONE", ")", "identify_data", "(", "name", ",", "data", ",", "bytes", ",", "status", ")", ";", "free", "(", "data", ")", ";", "}", "osd_close", "(", "file", ")", ";", "}", "}" ]

[ "identify_file", "-", "identify", "a", "file", ";", "if", "it", "is", "a", "ZIP", "file", "scan", "it", "and", "identify", "all", "enclosed", "files" ]

[ "/* open for read and process if it opens and has a valid length */", "/* read file data into RAM and identify it */" ]

[ { "param": "name", "type": "char" }, { "param": "status", "type": "romident_status" } ]

[ "Unlicense" ]

[ "identify", "a", "buffer", "full", "of", "data", ";", "if", "it", "comes", "from", "a", ".", "JED", "file", "parse", "the", "fusemap", "into", "raw", "data", "first" ]

[ "static", "void", "identify_data", "(", "const", "char", "*", "name", ",", "const", "UINT8", "*", "data", ",", "int", "length", ",", "romident_status", "*", "status", ")", "{", "char", "hash", "[", "HASH_BUF_SIZE", "]", ";", "UINT8", "*", "tempjed", "=", "NULL", ";", "astring", "*", "basename", ";", "int", "found", "=", "0", ";", "jed_data", "jed", ";", "if", "(", "core_filename_ends_with", "(", "name", ",", "\"", "\"", ")", "&&", "jed_parse", "(", "data", ",", "length", ",", "&", "jed", ")", "==", "JEDERR_NONE", ")", "{", "length", "=", "jedbin_output", "(", "&", "jed", ",", "NULL", ",", "0", ")", ";", "tempjed", "=", "(", "UINT8", "*", ")", "malloc", "(", "length", ")", ";", "if", "(", "tempjed", "==", "NULL", ")", "return", ";", "jedbin_output", "(", "&", "jed", ",", "tempjed", ",", "length", ")", ";", "data", "=", "tempjed", ";", "}", "hash_data_clear", "(", "hash", ")", ";", "hash_compute", "(", "hash", ",", "data", ",", "length", ",", "HASH_SHA1", "|", "HASH_CRC", ")", ";", "status", "->", "total", "++", ";", "basename", "=", "core_filename_extract_base", "(", "astring_alloc", "(", ")", ",", "name", ",", "FALSE", ")", ";", "mame_printf_info", "(", "\"", "\"", ",", "astring_c", "(", "basename", ")", ")", ";", "astring_free", "(", "basename", ")", ";", "match_roms", "(", "hash", ",", "length", ",", "&", "found", ")", ";", "if", "(", "found", "==", "0", ")", "{", "if", "(", "(", "length", "&", "(", "length", "-", "1", ")", ")", "!=", "0", ")", "{", "mame_printf_info", "(", "\"", "\\n", "\"", ")", ";", "status", "->", "nonroms", "++", ";", "}", "else", "mame_printf_info", "(", "\"", "\\n", "\"", ")", ";", "}", "else", "status", "->", "matches", "++", ";", "if", "(", "tempjed", "!=", "NULL", ")", "free", "(", "tempjed", ")", ";", "}" ]

[ "identify_data", "-", "identify", "a", "buffer", "full", "of", "data", ";", "if", "it", "comes", "from", "a", ".", "JED", "file", "parse", "the", "fusemap", "into", "raw", "data", "first" ]

[ "/* if this is a '.jed' file, process it into raw bits first */", "/* now determine the new data length and allocate temporary memory for it */", "/* create a binary output of the JED data and use that instead */", "/* compute the hash of the data */", "/* output the name */", "/* see if we can find a match in the ROMs */", "/* if we didn't find it, try to guess what it might be */", "/* if not a power of 2, assume it is a non-ROM file */", "/* otherwise, it's just not a match */", "/* if we did find it, count it as a match */", "/* free any temporary JED data */" ]

[ { "param": "name", "type": "char" }, { "param": "data", "type": "UINT8" }, { "param": "length", "type": "int" }, { "param": "status", "type": "romident_status" } ]

[ "Unlicense" ]

[ "scan", "for", "a", "matching", "ROM", "by", "hash" ]

[ "static", "void", "match_roms", "(", "const", "char", "*", "hash", ",", "int", "length", ",", "int", "*", "found", ")", "{", "int", "drvindex", ";", "for", "(", "drvindex", "=", "0", ";", "drivers", "[", "drvindex", "]", "!=", "NULL", ";", "drvindex", "++", ")", "{", "machine_config", "*", "config", "=", "machine_config_alloc", "(", "drivers", "[", "drvindex", "]", "->", "machine_config", ")", ";", "const", "rom_entry", "*", "region", ",", "*", "rom", ";", "const", "rom_source", "*", "source", ";", "for", "(", "source", "=", "rom_first_source", "(", "drivers", "[", "drvindex", "]", ",", "config", ")", ";", "source", "!=", "NULL", ";", "source", "=", "rom_next_source", "(", "drivers", "[", "drvindex", "]", ",", "config", ",", "source", ")", ")", "for", "(", "region", "=", "rom_first_region", "(", "drivers", "[", "drvindex", "]", ",", "source", ")", ";", "region", ";", "region", "=", "rom_next_region", "(", "region", ")", ")", "for", "(", "rom", "=", "rom_first_file", "(", "region", ")", ";", "rom", ";", "rom", "=", "rom_next_file", "(", "rom", ")", ")", "if", "(", "hash_data_is_equal", "(", "hash", ",", "ROM_GETHASHDATA", "(", "rom", ")", ",", "0", ")", ")", "{", "int", "baddump", "=", "hash_data_has_info", "(", "ROM_GETHASHDATA", "(", "rom", ")", ",", "HASH_INFO_BAD_DUMP", ")", ";", "if", "(", "*", "found", "!=", "0", ")", "mame_printf_info", "(", "\"", "\"", ")", ";", "mame_printf_info", "(", "\"", "\\n", "\"", ",", "baddump", "?", "\"", "\"", ":", "\"", "\"", ",", "ROM_GETNAME", "(", "rom", ")", ",", "drivers", "[", "drvindex", "]", "->", "description", ")", ";", "(", "*", "found", ")", "++", ";", "}", "machine_config_free", "(", "config", ")", ";", "}", "}" ]

[ "match_roms", "-", "scan", "for", "a", "matching", "ROM", "by", "hash" ]

[ "/* iterate over drivers */", "/* iterate over sources, regions and files within the region */", "/* output information about the match */" ]

[ { "param": "hash", "type": "char" }, { "param": "length", "type": "int" }, { "param": "found", "type": "int" } ]

[ "Unlicense" ]

[ "Display", "a", "seven", "digit", "counter", "on", "layout", "-", "Index", "points", "to", "less", "significant", "digit" ]

[ "static", "void", "count_7dig", "(", "unsigned", "long", "data", ",", "UINT8", "index", ")", "{", "UINT8", "i", ";", "char", "strn", "[", "8", "]", ";", "sprintf", "(", "strn", ",", "\"", "\"", ",", "data", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "7", ";", "i", "++", ")", "{", "output_set_digit_value", "(", "index", "+", "i", ",", "dec_7seg", "(", "(", "strn", "[", "6", "-", "i", "]", "|", "0x10", ")", "-", "0x30", ")", ")", ";", "}", "}" ]

[ "Display", "a", "seven", "digit", "counter", "on", "layout", "-", "Index", "points", "to", "less", "significant", "digit" ]

[]

[ { "param": "data", "type": "unsigned long" }, { "param": "index", "type": "UINT8" } ]

[ "Unlicense" ]

[ "update_background", "There", "are", "three", "background", "ROMs", "each", "one", "contains", "a", "512x256", "picture", ".", "Redraw", "them", "if", "the", "palette", "changes", "." ]

[ "static", "void", "update_background", "(", "running_machine", "*", "machine", ")", "{", "int", "row", ",", "col", ",", "page", ";", "int", "charcode", ";", "charcode", "=", "0", ";", "for", "(", "page", "=", "0", ";", "page", "<", "4", ";", "page", "++", ")", "{", "for", "(", "row", "=", "0", ";", "row", "<", "256", ";", "row", "++", ")", "{", "for", "(", "col", "=", "0", ";", "col", "<", "512", ";", "col", "+=", "32", ")", "{", "drawgfx_opaque", "(", "bg_bitmap", ",", "0", ",", "machine", "->", "gfx", "[", "2", "]", ",", "charcode", ",", "row", "<", "128", "?", "0", ":", "1", ",", "0", ",", "0", ",", "512", "*", "page", "+", "col", ",", "row", ")", ";", "charcode", "++", ";", "}", "}", "}", "}" ]

[ "update_background", "There", "are", "three", "background", "ROMs", "each", "one", "contains", "a", "512x256", "picture", "." ]

[ "/* There are only three background ROMs (4 on bunccaneers!) */" ]

[ { "param": "machine", "type": "running_machine" } ]

[ "Unlicense" ]

[ "This", "function", "expands", "the", "32x32", "5", "-", "bit", "data", "into", "a", "format", "which", "is", "easier", "to", "decode", "in", "MAME" ]

[ "static", "void", "expand_32x32x5bpp", "(", "running_machine", "*", "machine", ")", "{", "UINT8", "*", "src", "=", "memory_region", "(", "machine", ",", "\"", "\"", ")", ";", "UINT8", "*", "dst", "=", "memory_region", "(", "machine", ",", "\"", "\"", ")", ";", "size_t", "srcsize", "=", "memory_region_length", "(", "machine", ",", "\"", "\"", ")", ";", "int", "cnt", ",", "pix", ";", "for", "(", "cnt", "=", "0", ";", "cnt", "<", "srcsize", "/", "5", ";", "cnt", "++", ")", "{", "pix", "=", "(", "(", "src", "[", "0", "+", "5", "*", "cnt", "]", ">>", "0", ")", "&", "0x1f", ")", ";", "dst", "[", "0", "+", "8", "*", "cnt", "]", "=", "pix", ";", "pix", "=", "(", "(", "src", "[", "0", "+", "5", "*", "cnt", "]", ">>", "5", ")", "&", "0x07", ")", "|", "(", "(", "src", "[", "1", "+", "5", "*", "cnt", "]", "<<", "3", ")", "&", "0x18", ")", ";", "dst", "[", "1", "+", "8", "*", "cnt", "]", "=", "pix", ";", "pix", "=", "(", "(", "src", "[", "1", "+", "5", "*", "cnt", "]", ">>", "2", ")", "&", "0x1f", ")", ";", "dst", "[", "2", "+", "8", "*", "cnt", "]", "=", "pix", ";", "pix", "=", "(", "(", "src", "[", "1", "+", "5", "*", "cnt", "]", ">>", "7", ")", "&", "0x01", ")", "|", "(", "(", "src", "[", "2", "+", "5", "*", "cnt", "]", "<<", "1", ")", "&", "0x1e", ")", ";", "dst", "[", "3", "+", "8", "*", "cnt", "]", "=", "pix", ";", "pix", "=", "(", "(", "src", "[", "2", "+", "5", "*", "cnt", "]", ">>", "4", ")", "&", "0x0f", ")", "|", "(", "(", "src", "[", "3", "+", "5", "*", "cnt", "]", "<<", "4", ")", "&", "0x10", ")", ";", "dst", "[", "4", "+", "8", "*", "cnt", "]", "=", "pix", ";", "pix", "=", "(", "(", "src", "[", "3", "+", "5", "*", "cnt", "]", ">>", "1", ")", "&", "0x1f", ")", ";", "dst", "[", "5", "+", "8", "*", "cnt", "]", "=", "pix", ";", "pix", "=", "(", "(", "src", "[", "3", "+", "5", "*", "cnt", "]", ">>", "6", ")", "&", "0x03", ")", "|", "(", "(", "src", "[", "4", "+", "5", "*", "cnt", "]", "<<", "2", ")", "&", "0x1c", ")", ";", "dst", "[", "6", "+", "8", "*", "cnt", "]", "=", "pix", ";", "pix", "=", "(", "(", "src", "[", "4", "+", "5", "*", "cnt", "]", ">>", "3", ")", "&", "0x1f", ")", ";", "dst", "[", "7", "+", "8", "*", "cnt", "]", "=", "pix", ";", "}", "}" ]

[ "This", "function", "expands", "the", "32x32", "5", "-", "bit", "data", "into", "a", "format", "which", "is", "easier", "to", "decode", "in", "MAME" ]

[]

[ { "param": "machine", "type": "running_machine" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "0", "000", "100", "ddd", "x", "x", "x", "x", "NEGR", "Rd" ]

[ "static", "void", "cp1610_negr", "(", "cp1610_state", "*", "cpustate", ",", "int", "n", ")", "{", "UINT32", "temp", ";", "CLR_SZOC", ";", "temp", "=", "(", "cpustate", "->", "r", "[", "n", "]", "^", "0xffff", ")", "+", "1", ";", "SET_COV", "(", "0", ",", "temp", ",", "1", ")", ";", "cpustate", "->", "r", "[", "n", "]", "=", "temp", "&", "0xffff", ";", "SET_SZ", "(", "cpustate", "->", "r", "[", "n", "]", ")", ";", "cpustate", "->", "icount", "-=", "6", ";", "}" ]

[ "S", "Z", "C", "OV", "0", "000", "100", "ddd", "x", "x", "x", "x", "NEGR", "Rd" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "n", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "0", "000", "101", "ddd", "x", "x", "x", "x", "ADCR", "Rd" ]

[ "static", "void", "cp1610_adcr", "(", "cp1610_state", "*", "cpustate", ",", "int", "n", ")", "{", "UINT16", "offset", "=", "0", ";", "if", "(", "cpustate", "->", "flags", "&", "C", ")", "offset", "=", "1", ";", "CLR_SZOC", ";", "SET_COV", "(", "cpustate", "->", "r", "[", "n", "]", ",", "offset", ",", "0", ")", ";", "cpustate", "->", "r", "[", "n", "]", "+=", "offset", ";", "SET_SZ", "(", "cpustate", "->", "r", "[", "n", "]", ")", ";", "cpustate", "->", "icount", "-=", "6", ";", "}" ]

[ "S", "Z", "C", "OV", "0", "000", "101", "ddd", "x", "x", "x", "x", "ADCR", "Rd" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "n", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "0", "000", "111", "sss", "x", "x", "x", "x", "RSWD", "Rs" ]

[ "static", "void", "cp1610_rswd", "(", "cp1610_state", "*", "cpustate", ",", "int", "n", ")", "{", "cpustate", "->", "flags", "=", "cpustate", "->", "r", "[", "n", "]", ";", "cpustate", "->", "icount", "-=", "6", ";", "}" ]

[ "S", "Z", "C", "OV", "0", "000", "111", "sss", "x", "x", "x", "x", "RSWD", "Rs" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "n", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "0", "011", "sss", "ddd", "x", "x", "x", "x", "ADDR", "Rs", "Rd" ]

[ "static", "void", "cp1610_addr", "(", "cp1610_state", "*", "cpustate", ",", "int", "s", ",", "int", "d", ")", "{", "CLR_SZOC", ";", "SET_COV", "(", "cpustate", "->", "r", "[", "s", "]", ",", "cpustate", "->", "r", "[", "d", "]", ",", "0", ")", ";", "cpustate", "->", "r", "[", "d", "]", "+=", "cpustate", "->", "r", "[", "s", "]", ";", "SET_SZ", "(", "cpustate", "->", "r", "[", "d", "]", ")", ";", "cpustate", "->", "icount", "-=", "6", ";", "}" ]

[ "S", "Z", "C", "OV", "0", "011", "sss", "ddd", "x", "x", "x", "x", "ADDR", "Rs", "Rd" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "s", "type": "int" }, { "param": "d", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "0", "100", "sss", "ddd", "x", "x", "x", "x", "SUBR", "Rs", "Rd" ]

[ "static", "void", "cp1610_subr", "(", "cp1610_state", "*", "cpustate", ",", "int", "s", ",", "int", "d", ")", "{", "CLR_SZOC", ";", "SET_COV", "(", "cpustate", "->", "r", "[", "d", "]", ",", "(", "UINT32", ")", "(", "(", "cpustate", "->", "r", "[", "s", "]", "^", "0xffff", ")", "+", "1", ")", ",", "1", ")", ";", "cpustate", "->", "r", "[", "d", "]", "-=", "cpustate", "->", "r", "[", "s", "]", ";", "SET_SZ", "(", "cpustate", "->", "r", "[", "d", "]", ")", ";", "cpustate", "->", "icount", "-=", "6", ";", "}" ]

[ "S", "Z", "C", "OV", "0", "100", "sss", "ddd", "x", "x", "x", "x", "SUBR", "Rs", "Rd" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "s", "type": "int" }, { "param": "d", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "0", "101", "sss", "ddd", "x", "x", "x", "x", "CMPR", "Rs", "Rd" ]

[ "static", "void", "cp1610_cmpr", "(", "cp1610_state", "*", "cpustate", ",", "int", "s", ",", "int", "d", ")", "{", "UINT16", "temp", ";", "CLR_SZOC", ";", "SET_COV", "(", "cpustate", "->", "r", "[", "d", "]", ",", "(", "UINT32", ")", "(", "(", "cpustate", "->", "r", "[", "s", "]", "^", "0xffff", ")", "+", "1", ")", ",", "1", ")", ";", "temp", "=", "cpustate", "->", "r", "[", "d", "]", "-", "cpustate", "->", "r", "[", "s", "]", ";", "SET_SZ", "(", "temp", ")", ";", "cpustate", "->", "icount", "-=", "6", ";", "}" ]

[ "S", "Z", "C", "OV", "0", "101", "sss", "ddd", "x", "x", "x", "x", "CMPR", "Rs", "Rd" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "s", "type": "int" }, { "param": "d", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "1", "011", "000", "ddd", "a", "aaa", "aaa", "aaa", "aaa", "aaa", "x", "x", "x", "x", "ADD", "ADDR", "Rd" ]

[ "static", "void", "cp1610_add", "(", "cp1610_state", "*", "cpustate", ",", "int", "d", ")", "{", "UINT16", "addr", "=", "cp1610_readop", "(", "cpustate", "->", "r", "[", "7", "]", ")", ";", "UINT16", "data", "=", "cp1610_readmem16", "(", "addr", ")", ";", "cpustate", "->", "r", "[", "7", "]", "++", ";", "CLR_SZOC", ";", "SET_COV", "(", "cpustate", "->", "r", "[", "d", "]", ",", "data", ",", "0", ")", ";", "cpustate", "->", "r", "[", "d", "]", "+=", "data", ";", "SET_SZ", "(", "cpustate", "->", "r", "[", "d", "]", ")", ";", "cpustate", "->", "icount", "-=", "10", ";", "}" ]

[ "S", "Z", "C", "OV", "1", "011", "000", "ddd", "a", "aaa", "aaa", "aaa", "aaa", "aaa", "x", "x", "x", "x", "ADD", "ADDR", "Rd" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "d", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "1", "100", "000", "ddd", "a", "aaa", "aaa", "aaa", "aaa", "aaa", "x", "x", "x", "x", "SUB", "ADDR", "Rd" ]

[ "static", "void", "cp1610_sub", "(", "cp1610_state", "*", "cpustate", ",", "int", "d", ")", "{", "UINT16", "addr", "=", "cp1610_readop", "(", "cpustate", "->", "r", "[", "7", "]", ")", ";", "UINT32", "data", "=", "cp1610_readmem16", "(", "addr", ")", ";", "cpustate", "->", "r", "[", "7", "]", "++", ";", "CLR_SZOC", ";", "data", "=", "(", "data", "^", "0xffff", ")", "+", "1", ";", "SET_COV", "(", "cpustate", "->", "r", "[", "d", "]", ",", "data", ",", "1", ")", ";", "data", "&=", "0xffff", ";", "cpustate", "->", "r", "[", "d", "]", "+=", "data", ";", "SET_SZ", "(", "cpustate", "->", "r", "[", "d", "]", ")", ";", "cpustate", "->", "icount", "-=", "10", ";", "}" ]

[ "S", "Z", "C", "OV", "1", "100", "000", "ddd", "a", "aaa", "aaa", "aaa", "aaa", "aaa", "x", "x", "x", "x", "SUB", "ADDR", "Rd" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "d", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "1", "101", "000", "ddd", "a", "aaa", "aaa", "aaa", "aaa", "aaa", "x", "x", "x", "x", "CMP", "ADDR", "Rd" ]

[ "static", "void", "cp1610_cmp", "(", "cp1610_state", "*", "cpustate", ",", "int", "d", ")", "{", "UINT16", "addr", "=", "cp1610_readop", "(", "cpustate", "->", "r", "[", "7", "]", ")", ";", "UINT32", "data", "=", "cp1610_readmem16", "(", "addr", ")", ";", "UINT16", "res", ";", "cpustate", "->", "r", "[", "7", "]", "++", ";", "CLR_SZOC", ";", "data", "=", "(", "data", "^", "0xffff", ")", "+", "1", ";", "SET_COV", "(", "cpustate", "->", "r", "[", "d", "]", ",", "data", ",", "1", ")", ";", "data", "&=", "0xffff", ";", "res", "=", "cpustate", "->", "r", "[", "d", "]", "+", "data", ";", "SET_SZ", "(", "res", ")", ";", "cpustate", "->", "icount", "-=", "10", ";", "}" ]

[ "S", "Z", "C", "OV", "1", "101", "000", "ddd", "a", "aaa", "aaa", "aaa", "aaa", "aaa", "x", "x", "x", "x", "CMP", "ADDR", "Rd" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "d", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "1", "110", "000", "ddd", "a", "aaa", "aaa", "aaa", "aaa", "aaa", "x", "x", "-", "-", "AND", "ADDR", "Rd" ]

[ "static", "void", "cp1610_and", "(", "cp1610_state", "*", "cpustate", ",", "int", "d", ")", "{", "UINT16", "addr", "=", "cp1610_readop", "(", "cpustate", "->", "r", "[", "7", "]", ")", ";", "UINT16", "data", "=", "cp1610_readmem16", "(", "addr", ")", ";", "cpustate", "->", "r", "[", "7", "]", "++", ";", "CLR_SZ", ";", "cpustate", "->", "r", "[", "d", "]", "&=", "data", ";", "SET_SZ", "(", "cpustate", "->", "r", "[", "d", "]", ")", ";", "cpustate", "->", "icount", "-=", "10", ";", "}" ]

[ "S", "Z", "C", "OV", "1", "110", "000", "ddd", "a", "aaa", "aaa", "aaa", "aaa", "aaa", "x", "x", "-", "-", "AND", "ADDR", "Rd" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "d", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "1", "111", "000", "ddd", "a", "aaa", "aaa", "aaa", "aaa", "aaa", "x", "x", "-", "-", "XOR", "ADDR", "Rd" ]

[ "static", "void", "cp1610_xor", "(", "cp1610_state", "*", "cpustate", ",", "int", "d", ")", "{", "UINT16", "addr", "=", "cp1610_readop", "(", "cpustate", "->", "r", "[", "7", "]", ")", ";", "UINT16", "data", "=", "cp1610_readmem16", "(", "addr", ")", ";", "cpustate", "->", "r", "[", "7", "]", "++", ";", "CLR_SZ", ";", "cpustate", "->", "r", "[", "d", "]", "^=", "data", ";", "SET_SZ", "(", "cpustate", "->", "r", "[", "d", "]", ")", ";", "cpustate", "->", "icount", "-=", "10", ";", "}" ]

[ "S", "Z", "C", "OV", "1", "111", "000", "ddd", "a", "aaa", "aaa", "aaa", "aaa", "aaa", "x", "x", "-", "-", "XOR", "ADDR", "Rd" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "d", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "0x001", "1", "011", "111", "ddd", "x", "xxx", "xLL", "LLL", "LLL", "x", "xxx", "xUU", "UUU", "UUU", "x", "x", "x", "x", "SDBD", "ADDI", "I", "-", "I", "Rd" ]

[ "static", "void", "cp1610_sdbd_addi", "(", "cp1610_state", "*", "cpustate", ",", "int", "d", ")", "{", "UINT16", "addr", ";", "UINT16", "temp", ";", "CLR_SZOC", ";", "addr", "=", "cp1610_readop", "(", "cpustate", "->", "r", "[", "7", "]", ")", "&", "0xff", ";", "cpustate", "->", "r", "[", "7", "]", "++", ";", "addr", "|=", "(", "cp1610_readop", "(", "cpustate", "->", "r", "[", "7", "]", ")", "<<", "8", ")", ";", "cpustate", "->", "r", "[", "7", "]", "++", ";", "temp", "=", "addr", ";", "SET_COV", "(", "cpustate", "->", "r", "[", "d", "]", ",", "temp", ",", "0", ")", ";", "cpustate", "->", "r", "[", "d", "]", "+=", "temp", ";", "SET_SZ", "(", "cpustate", "->", "r", "[", "d", "]", ")", ";", "cpustate", "->", "icount", "-=", "14", ";", "}" ]

[ "S", "Z", "C", "OV", "0x001", "1", "011", "111", "ddd", "x", "xxx", "xLL", "LLL", "LLL", "x", "xxx", "xUU", "UUU", "UUU", "x", "x", "x", "x", "SDBD", "ADDI", "I", "-", "I", "Rd" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "d", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "0x001", "1", "100", "111", "ddd", "x", "xxx", "xLL", "LLL", "LLL", "x", "xxx", "xUU", "UUU", "UUU", "x", "x", "x", "x", "SDBD", "SUBI", "I", "-", "I", "Rd" ]

[ "static", "void", "cp1610_sdbd_subi", "(", "cp1610_state", "*", "cpustate", ",", "int", "d", ")", "{", "UINT16", "addr", ";", "UINT32", "temp", ";", "CLR_SZOC", ";", "addr", "=", "cp1610_readop", "(", "cpustate", "->", "r", "[", "7", "]", ")", "&", "0xff", ";", "cpustate", "->", "r", "[", "7", "]", "++", ";", "addr", "|=", "(", "cp1610_readop", "(", "cpustate", "->", "r", "[", "7", "]", ")", "<<", "8", ")", ";", "cpustate", "->", "r", "[", "7", "]", "++", ";", "temp", "=", "addr", ";", "temp", "=", "(", "temp", "^", "0xffff", ")", "+", "1", ";", "SET_COV", "(", "cpustate", "->", "r", "[", "d", "]", ",", "temp", ",", "1", ")", ";", "temp", "&=", "0xffff", ";", "cpustate", "->", "r", "[", "d", "]", "+=", "temp", ";", "SET_SZ", "(", "cpustate", "->", "r", "[", "d", "]", ")", ";", "cpustate", "->", "icount", "-=", "14", ";", "}" ]

[ "S", "Z", "C", "OV", "0x001", "1", "100", "111", "ddd", "x", "xxx", "xLL", "LLL", "LLL", "x", "xxx", "xUU", "UUU", "UUU", "x", "x", "x", "x", "SDBD", "SUBI", "I", "-", "I", "Rd" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "d", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "0x001", "1", "101", "111", "ddd", "x", "xxx", "xLL", "LLL", "LLL", "x", "xxx", "xUU", "UUU", "UUU", "x", "x", "x", "x", "SDBD", "CMPI", "I", "-", "I", "Rd" ]

[ "static", "void", "cp1610_sdbd_cmpi", "(", "cp1610_state", "*", "cpustate", ",", "int", "d", ")", "{", "UINT16", "addr", ";", "UINT32", "temp", ";", "UINT16", "temp2", ";", "CLR_SZOC", ";", "addr", "=", "cp1610_readop", "(", "cpustate", "->", "r", "[", "7", "]", ")", "&", "0xff", ";", "cpustate", "->", "r", "[", "7", "]", "++", ";", "addr", "|=", "(", "cp1610_readop", "(", "cpustate", "->", "r", "[", "7", "]", ")", "<<", "8", ")", ";", "cpustate", "->", "r", "[", "7", "]", "++", ";", "temp", "=", "addr", ";", "temp", "=", "(", "temp", "^", "0xffff", ")", "+", "1", ";", "SET_COV", "(", "cpustate", "->", "r", "[", "d", "]", ",", "temp", ",", "1", ")", ";", "temp", "&=", "0xffff", ";", "temp2", "=", "cpustate", "->", "r", "[", "d", "]", "+", "temp", ";", "SET_SZ", "(", "temp2", ")", ";", "cpustate", "->", "icount", "-=", "14", ";", "}" ]

[ "S", "Z", "C", "OV", "0x001", "1", "101", "111", "ddd", "x", "xxx", "xLL", "LLL", "LLL", "x", "xxx", "xUU", "UUU", "UUU", "x", "x", "x", "x", "SDBD", "CMPI", "I", "-", "I", "Rd" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "d", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "0x001", "1", "110", "111", "ddd", "x", "xxx", "xLL", "LLL", "LLL", "x", "xxx", "xUU", "UUU", "UUU", "x", "x", "-", "-", "SDBD", "ANDI", "I", "-", "I", "Rd" ]

[ "static", "void", "cp1610_sdbd_andi", "(", "cp1610_state", "*", "cpustate", ",", "int", "d", ")", "{", "UINT16", "addr", ";", "CLR_SZ", ";", "addr", "=", "cp1610_readop", "(", "cpustate", "->", "r", "[", "7", "]", ")", "&", "0xff", ";", "cpustate", "->", "r", "[", "7", "]", "++", ";", "addr", "|=", "(", "cp1610_readop", "(", "cpustate", "->", "r", "[", "7", "]", ")", "<<", "8", ")", ";", "cpustate", "->", "r", "[", "7", "]", "++", ";", "cpustate", "->", "r", "[", "d", "]", "&=", "addr", ";", "SET_SZ", "(", "cpustate", "->", "r", "[", "d", "]", ")", ";", "cpustate", "->", "icount", "-=", "14", ";", "}" ]

[ "S", "Z", "C", "OV", "0x001", "1", "110", "111", "ddd", "x", "xxx", "xLL", "LLL", "LLL", "x", "xxx", "xUU", "UUU", "UUU", "x", "x", "-", "-", "SDBD", "ANDI", "I", "-", "I", "Rd" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "d", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "0x001", "1", "111", "111", "ddd", "x", "xxx", "xLL", "LLL", "LLL", "x", "xxx", "xUU", "UUU", "UUU", "x", "x", "-", "-", "SDBD", "XORI", "I", "-", "I", "Rd" ]

[ "static", "void", "cp1610_sdbd_xori", "(", "cp1610_state", "*", "cpustate", ",", "int", "d", ")", "{", "UINT16", "addr", ";", "CLR_SZ", ";", "addr", "=", "cp1610_readop", "(", "cpustate", "->", "r", "[", "7", "]", ")", "&", "0xff", ";", "cpustate", "->", "r", "[", "7", "]", "++", ";", "addr", "|=", "(", "cp1610_readop", "(", "cpustate", "->", "r", "[", "7", "]", ")", "<<", "8", ")", ";", "cpustate", "->", "r", "[", "7", "]", "++", ";", "cpustate", "->", "r", "[", "d", "]", "^=", "addr", ";", "SET_SZ", "(", "cpustate", "->", "r", "[", "d", "]", ")", ";", "cpustate", "->", "icount", "-=", "14", ";", "}" ]

[ "S", "Z", "C", "OV", "0x001", "1", "111", "111", "ddd", "x", "xxx", "xLL", "LLL", "LLL", "x", "xxx", "xUU", "UUU", "UUU", "x", "x", "-", "-", "SDBD", "XORI", "I", "-", "I", "Rd" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "d", "type": "int" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "1", "1aa", "aaa", "a01", "x", "xxx", "xxa", "aaa", "aaa", "aaa", "-", "-", "-", "-", "JE", "ADDR" ]

[ "static", "void", "cp1610_je", "(", "cp1610_state", "*", "cpustate", ",", "UINT16", "addr", ")", "{", "cpustate", "->", "r", "[", "7", "]", "=", "addr", ";", "cpustate", "->", "intr_enabled", "=", "1", ";", "}" ]

[ "S", "Z", "C", "OV", "1", "1aa", "aaa", "a01", "x", "xxx", "xxa", "aaa", "aaa", "aaa", "-", "-", "-", "-", "JE", "ADDR" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "addr", "type": "UINT16" } ]

[ "Unlicense" ]

[ "S", "Z", "C", "OV", "1", "1aa", "aaa", "a10", "x", "xxx", "xxa", "aaa", "aaa", "aaa", "-", "-", "-", "-", "JD", "ADDR" ]

[ "static", "void", "cp1610_jd", "(", "cp1610_state", "*", "cpustate", ",", "UINT16", "addr", ")", "{", "cpustate", "->", "r", "[", "7", "]", "=", "addr", ";", "cpustate", "->", "intr_enabled", "=", "0", ";", "}" ]

[ "S", "Z", "C", "OV", "1", "1aa", "aaa", "a10", "x", "xxx", "xxa", "aaa", "aaa", "aaa", "-", "-", "-", "-", "JD", "ADDR" ]

[]

[ { "param": "cpustate", "type": "cp1610_state" }, { "param": "addr", "type": "UINT16" } ]

[ "Unlicense" ]

[ "Palette", "Tables", "Both", "the", "background", "and", "sprites", "within", "the", "VDP", "have", "4", "possible", "palettes", "to", "select", "from", ".", "External", "hardware", "on", "the", "C2", "boards", "controlled", "by", "the", "EPM5032", "chip", "and", "the", "I", "/", "O", "chip", "allows", "for", "more", "complex", "palette", "selection", ".", "The", "actual", "palette", "entry", "comes", "from", ".", "Bits", "10", "-", "9", "=", "output", "from", "I", "/", "O", "port", "H", "Bits", "8", "-", "5", "=", "output", "from", "EPM5032", "Bits", "4", "-", "0", "=", "direct", "from", "the", "VDP", "In", "order", "to", "compute", "bits", "8", "-", "5", "the", "EPM5032", "gets", "the", "sprite", "/", "background", "output", "line", "along", "with", "the", "two", "bits", "of", "palette", "info", ".", "For", "most", "games", "the", "two", "bits", "of", "palette", "info", "map", "straight", "through", "as", "follows", ".", "However", "because", "there", "are", "4", "bits", "completely", "controlled", "by", "the", "EPM5032", "it", "doesn", "'", "t", "have", "to", "always", "map", "this", "way", ".", "An", "alternate", "palette", "mode", "can", "be", "selected", "which", "alters", "the", "output", "palette", "by", "swizzling", "the", "color", "RAM", "address", "bits", "." ]

[ "static", "void", "recompute_palette_tables", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "{", "int", "bgpal", "=", "0x000", "+", "bg_palbase", "*", "0x40", "+", "i", "*", "0x10", ";", "int", "sppal", "=", "0x100", "+", "sp_palbase", "*", "0x40", "+", "i", "*", "0x10", ";", "if", "(", "!", "segac2_alt_palette_mode", ")", "{", "segac2_bg_pal_lookup", "[", "i", "]", "=", "0x200", "*", "palbank", "+", "bgpal", ";", "segac2_sp_pal_lookup", "[", "i", "]", "=", "0x200", "*", "palbank", "+", "sppal", ";", "}", "else", "{", "segac2_bg_pal_lookup", "[", "i", "]", "=", "0x200", "*", "palbank", "+", "(", "(", "bgpal", "<<", "1", ")", "&", "0x180", ")", "+", "(", "(", "~", "bgpal", ">>", "2", ")", "&", "0x40", ")", "+", "(", "bgpal", "&", "0x30", ")", ";", "segac2_sp_pal_lookup", "[", "i", "]", "=", "0x200", "*", "palbank", "+", "(", "(", "~", "sppal", "<<", "2", ")", "&", "0x100", ")", "+", "(", "(", "sppal", "<<", "2", ")", "&", "0x80", ")", "+", "(", "(", "~", "sppal", ">>", "2", ")", "&", "0x40", ")", "+", "(", "(", "sppal", ">>", "2", ")", "&", "0x20", ")", "+", "(", "sppal", "&", "0x10", ")", ";", "}", "}", "}" ]

[ "Palette", "Tables", "Both", "the", "background", "and", "sprites", "within", "the", "VDP", "have", "4", "possible", "palettes", "to", "select", "from", "." ]

[]

[]

[ "Unlicense" ]

[ "IRQ", "handling", ".", "The", "priority", "encoder", "has", "to", "be", "emulated", ".", "Otherwise", "interrupts", "are", "lost", "." ]

[ "void", "vertigo_update_irq", "(", "running_device", "*", "device", ")", "{", "if", "(", "irq_state", "<", "7", ")", "cputag_set_input_line", "(", "device", "->", "machine", ",", "\"", "\"", ",", "irq_state", "^", "7", ",", "CLEAR_LINE", ")", ";", "irq_state", "=", "ttl74148_output_r", "(", "device", ")", ";", "if", "(", "irq_state", "<", "7", ")", "cputag_set_input_line", "(", "device", "->", "machine", ",", "\"", "\"", ",", "irq_state", "^", "7", ",", "ASSERT_LINE", ")", ";", "}" ]

[ "IRQ", "handling", "." ]

[]

[ { "param": "device", "type": "running_device" } ]

[ "Unlicense" ]

[ "mix", "&", "blend", "the", "paletted", "16", "-", "bit", "tile", "and", "sprite", "bitmaps", "into", "an", "RGB", "32", "-", "bit", "bitmap" ]

[ "static", "void", "blendbitmaps", "(", "running_machine", "*", "machine", ",", "bitmap_t", "*", "dest", ",", "bitmap_t", "*", "src1", ",", "bitmap_t", "*", "src2", ",", "bitmap_t", "*", "src3", ",", "int", "sx", ",", "int", "sy", ",", "const", "rectangle", "*", "clip", ")", "{", "int", "ox", ";", "int", "oy", ";", "int", "ex", ";", "int", "ey", ";", "ox", "=", "sx", ";", "oy", "=", "sy", ";", "ex", "=", "sx", "+", "src1", "->", "width", "-", "1", ";", "if", "(", "sx", "<", "0", ")", "sx", "=", "0", ";", "if", "(", "sx", "<", "clip", "->", "min_x", ")", "sx", "=", "clip", "->", "min_x", ";", "if", "(", "ex", ">=", "dest", "->", "width", ")", "ex", "=", "dest", "->", "width", "-", "1", ";", "if", "(", "ex", ">", "clip", "->", "max_x", ")", "ex", "=", "clip", "->", "max_x", ";", "if", "(", "sx", ">", "ex", ")", "return", ";", "ey", "=", "sy", "+", "src1", "->", "height", "-", "1", ";", "if", "(", "sy", "<", "0", ")", "sy", "=", "0", ";", "if", "(", "sy", "<", "clip", "->", "min_y", ")", "sy", "=", "clip", "->", "min_y", ";", "if", "(", "ey", ">=", "dest", "->", "height", ")", "ey", "=", "dest", "->", "height", "-", "1", ";", "if", "(", "ey", ">", "clip", "->", "max_y", ")", "ey", "=", "clip", "->", "max_y", ";", "if", "(", "sy", ">", "ey", ")", "return", ";", "{", "const", "pen_t", "*", "paldata", "=", "machine", "->", "pens", ";", "UINT32", "*", "end", ";", "UINT16", "*", "sd1", "=", "(", "UINT16", "*", ")", "src1", "->", "base", ";", "UINT16", "*", "sd2", "=", "(", "UINT16", "*", ")", "src2", "->", "base", ";", "UINT16", "*", "sd3", "=", "(", "UINT16", "*", ")", "src3", "->", "base", ";", "int", "sw", "=", "ex", "-", "sx", "+", "1", ";", "int", "sh", "=", "ey", "-", "sy", "+", "1", ";", "int", "sm", "=", "src1", "->", "rowpixels", ";", "UINT32", "*", "dd", "=", "BITMAP_ADDR32", "(", "dest", ",", "sy", ",", "sx", ")", ";", "int", "dm", "=", "dest", "->", "rowpixels", ";", "sd1", "+=", "(", "sx", "-", "ox", ")", ";", "sd1", "+=", "sm", "*", "(", "sy", "-", "oy", ")", ";", "sd2", "+=", "(", "sx", "-", "ox", ")", ";", "sd2", "+=", "sm", "*", "(", "sy", "-", "oy", ")", ";", "sd3", "+=", "(", "sx", "-", "ox", ")", ";", "sd3", "+=", "sm", "*", "(", "sy", "-", "oy", ")", ";", "sm", "-=", "sw", ";", "dm", "-=", "sw", ";", "while", "(", "sh", ")", "{", "#define", "BLENDPIXEL", "(", "x", ")", "\tif (sd3[x]) {\t\t\t\t\t\t\t\t\t\t\t\t\t\t\\\r\n\t\t\t\t\t\t\tif (sd2[x]) {\t\t\t\t\t\t\t\t\t\t\t\t\t\\\r\n\t\t\t\t\t\t\t\tdd[x] = paldata[sd2[x] | 0x0400] + paldata[sd3[x]];\t\t\t\\\r\n\t\t\t\t\t\t\t} else {\t\t\t\t\t\t\t\t\t\t\t\t\t\t\\\r\n\t\t\t\t\t\t\t\tdd[x] = paldata[sd1[x] | 0x0400] + paldata[sd3[x]];\t\t\t\\\r\n\t\t\t\t\t\t\t}\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\\\r\n\t\t\t\t\t\t} else {\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\\\r\n\t\t\t\t\t\t\tif (sd2[x]) {\t\t\t\t\t\t\t\t\t\t\t\t\t\\\r\n\t\t\t\t\t\t\t\tif (sd2[x] & 0x0800) {\t\t\t\t\t\t\t\t\t\t\\\r\n\t\t\t\t\t\t\t\t\tdd[x] = paldata[sd1[x] | 0x0400] + paldata[sd2[x]];\t\t\\\r\n\t\t\t\t\t\t\t\t} else {\t\t\t\t\t\t\t\t\t\t\t\t\t\\\r\n\t\t\t\t\t\t\t\t\tdd[x] = paldata[sd2[x]];\t\t\t\t\t\t\t\t\\\r\n\t\t\t\t\t\t\t\t}\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\\\r\n\t\t\t\t\t\t\t} else {\t\t\t\t\t\t\t\t\t\t\t\t\t\t\\\r\n\t\t\t\t\t\t\t\tdd[x] = paldata[sd1[x]];\t\t\t\t\t\t\t\t\t\\\r\n\t\t\t\t\t\t\t}\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\\\r\n\t\t\t\t\t\t}\r", "\n", "end", "=", "dd", "+", "sw", ";", "while", "(", "dd", "<=", "end", "-", "8", ")", "{", "BLENDPIXEL", "(", "0", ")", ";", "BLENDPIXEL", "(", "1", ")", ";", "BLENDPIXEL", "(", "2", ")", ";", "BLENDPIXEL", "(", "3", ")", ";", "BLENDPIXEL", "(", "4", ")", ";", "BLENDPIXEL", "(", "5", ")", ";", "BLENDPIXEL", "(", "6", ")", ";", "BLENDPIXEL", "(", "7", ")", ";", "dd", "+=", "8", ";", "sd1", "+=", "8", ";", "sd2", "+=", "8", ";", "sd3", "+=", "8", ";", "}", "while", "(", "dd", "<", "end", ")", "{", "BLENDPIXEL", "(", "0", ")", ";", "dd", "++", ";", "sd1", "++", ";", "sd2", "++", ";", "sd3", "++", ";", "}", "dd", "+=", "dm", ";", "sd1", "+=", "sm", ";", "sd2", "+=", "sm", ";", "sd3", "+=", "sm", ";", "sh", "--", ";", "#undef", " BLENDPIXEL\r", "\n", "}", "}", "}" ]

[ "mix", "&", "blend", "the", "paletted", "16", "-", "bit", "tile", "and", "sprite", "bitmaps", "into", "an", "RGB", "32", "-", "bit", "bitmap" ]

[ "/* check bounds */", "/* source data */", "/* source width */", "/* source height */", "/* source modulo */", "/* dest data */", "/* dest modulo */" ]

[ { "param": "machine", "type": "running_machine" }, { "param": "dest", "type": "bitmap_t" }, { "param": "src1", "type": "bitmap_t" }, { "param": "src2", "type": "bitmap_t" }, { "param": "src3", "type": "bitmap_t" }, { "param": "sx", "type": "int" }, { "param": "sy", "type": "int" }, { "param": "clip", "type": "rectangle" } ]

[ "Unlicense" ]

[ "-", "handle", "bit", "data", "write", "to", "the", "TMS5110", "(", "as", "a", "result", "of", "toggling", "M0", "pin", ")" ]

[ "static", "void", "FIFO_data_write", "(", "tms5110_state", "*", "tms", ",", "int", "data", ")", "{", "if", "(", "tms", "->", "fifo_count", "<", "FIFO_SIZE", ")", "{", "tms", "->", "fifo", "[", "tms", "->", "fifo_tail", "]", "=", "(", "data", "&", "1", ")", ";", "tms", "->", "fifo_tail", "=", "(", "tms", "->", "fifo_tail", "+", "1", ")", "%", "FIFO_SIZE", ";", "tms", "->", "fifo_count", "++", ";", "if", "(", "DEBUG_5110", ")", "logerror", "(", "\"", "\\n", "\"", ",", "tms", "->", "fifo_count", ")", ";", "}", "else", "{", "if", "(", "DEBUG_5110", ")", "logerror", "(", "\"", "\\n", "\"", ")", ";", "}", "}" ]

[ "FIFO_data_write", "--", "handle", "bit", "data", "write", "to", "the", "TMS5110", "(", "as", "a", "result", "of", "toggling", "M0", "pin", ")" ]

[ "/* add this bit to the FIFO */", "/* set bit to 1 or 0 */" ]

[ { "param": "tms", "type": "tms5110_state" }, { "param": "data", "type": "int" } ]

[ "Unlicense" ]

[ "-", "extract", "a", "specific", "number", "of", "bits", "from", "the", "FIFO" ]

[ "static", "int", "extract_bits", "(", "tms5110_state", "*", "tms", ",", "int", "count", ")", "{", "int", "val", "=", "0", ";", "while", "(", "count", "--", ")", "{", "val", "=", "(", "val", "<<", "1", ")", "|", "(", "tms", "->", "fifo", "[", "tms", "->", "fifo_head", "]", "&", "1", ")", ";", "tms", "->", "fifo_count", "--", ";", "tms", "->", "fifo_head", "=", "(", "tms", "->", "fifo_head", "+", "1", ")", "%", "FIFO_SIZE", ";", "}", "return", "val", ";", "}" ]

[ "extract_bits", "--", "extract", "a", "specific", "number", "of", "bits", "from", "the", "FIFO" ]

[]

[ { "param": "tms", "type": "tms5110_state" }, { "param": "count", "type": "int" } ]

[ "Unlicense" ]

[ "-", "set", "Processor", "Data", "Clock", ".", "Execute", "CTL_pins", "command", "on", "hi", "-", "lo", "transition", "." ]

[ "void", "tms5110_PDC_set", "(", "tms5110_state", "*", "tms", ",", "int", "data", ")", "{", "if", "(", "tms", "->", "PDC", "!=", "(", "data", "&", "0x1", ")", ")", "{", "tms", "->", "PDC", "=", "data", "&", "0x1", ";", "if", "(", "tms", "->", "PDC", "==", "0", ")", "{", "switch", "(", "tms", "->", "state", ")", "{", "case", "CTL_STATE_INPUT", ":", "break", ";", "case", "CTL_STATE_NEXT_OUTPUT", ":", "tms", "->", "state", "=", "CTL_STATE_OUTPUT", ";", "return", ";", "case", "CTL_STATE_OUTPUT", ":", "tms", "->", "state", "=", "CTL_STATE_INPUT", ";", "return", ";", "}", "if", "(", "tms", "->", "next_is_address", ")", "{", "tms", "->", "next_is_address", "=", "FALSE", ";", "tms", "->", "address", "=", "tms", "->", "address", "|", "(", "(", "tms", "->", "CTL_pins", "&", "0x0F", ")", "<<", "tms", "->", "addr_bit", ")", ";", "tms", "->", "addr_bit", "=", "(", "tms", "->", "addr_bit", "+", "4", ")", "%", "12", ";", "tms", "->", "schedule_dummy_read", "=", "TRUE", ";", "if", "(", "tms", "->", "set_load_address", ")", "tms", "->", "set_load_address", "(", "tms", "->", "device", ",", "tms", "->", "address", ")", ";", "new_int_write_addr", "(", "tms", ",", "tms", "->", "CTL_pins", "&", "0x0F", ")", ";", "}", "else", "{", "switch", "(", "tms", "->", "CTL_pins", "&", "0xe", ")", "{", "case", "TMS5110_CMD_SPEAK", ":", "perform_dummy_read", "(", "tms", ")", ";", "tms", "->", "speaking_now", "=", "1", ";", "break", ";", "case", "TMS5110_CMD_RESET", ":", "perform_dummy_read", "(", "tms", ")", ";", "tms", "->", "device", "->", "reset", "(", ")", ";", "break", ";", "case", "TMS5110_CMD_READ_BIT", ":", "if", "(", "tms", "->", "schedule_dummy_read", ")", "perform_dummy_read", "(", "tms", ")", ";", "else", "{", "request_bits", "(", "tms", ",", "1", ")", ";", "tms", "->", "CTL_pins", "=", "(", "tms", "->", "CTL_pins", "&", "0x0E", ")", "|", "extract_bits", "(", "tms", ",", "1", ")", ";", "}", "break", ";", "case", "TMS5110_CMD_LOAD_ADDRESS", ":", "tms", "->", "next_is_address", "=", "TRUE", ";", "break", ";", "case", "TMS5110_CMD_READ_BRANCH", ":", "new_int_write", "(", "tms", ",", "0", ",", "1", ",", "1", ",", "0", ")", ";", "new_int_write", "(", "tms", ",", "1", ",", "1", ",", "1", ",", "0", ")", ";", "new_int_write", "(", "tms", ",", "0", ",", "1", ",", "1", ",", "0", ")", ";", "new_int_write", "(", "tms", ",", "0", ",", "0", ",", "0", ",", "0", ")", ";", "new_int_write", "(", "tms", ",", "1", ",", "0", ",", "0", ",", "0", ")", ";", "new_int_write", "(", "tms", ",", "0", ",", "0", ",", "0", ",", "0", ")", ";", "tms", "->", "schedule_dummy_read", "=", "FALSE", ";", "break", ";", "case", "TMS5110_CMD_TEST_TALK", ":", "tms", "->", "state", "=", "CTL_STATE_NEXT_OUTPUT", ";", "break", ";", "default", ":", "logerror", "(", "\"", "\\n", "\"", ",", "tms", "->", "CTL_pins", ")", ";", "break", ";", "}", "}", "}", "}", "}" ]

[ "PDC_set", "--", "set", "Processor", "Data", "Clock", "." ]

[ "/* toggling 1->0 processes command on CTL_pins */", "/* first pdc toggles output, next toggles input */", "/* continue */", "/* the only real commands we handle now are SPEAK and RESET */", "/*CTL1 - don't care*/", "//should FIFO be cleared now ?????\r" ]

[ { "param": "tms", "type": "tms5110_state" }, { "param": "data", "type": "int" } ]

[ "Unlicense" ]

[ "-", "parse", "a", "new", "frame", "'", "s", "worth", "of", "data", ";", "returns", "0", "if", "not", "enough", "bits", "in", "buffer" ]

[ "static", "void", "parse_frame", "(", "tms5110_state", "*", "tms", ")", "{", "int", "bits", ",", "indx", ",", "i", ",", "rep_flag", ";", "#if", "(", "DEBUG_5110", ")", "\n", "int", "ene", ";", "#endif", "bits", "=", "tms", "->", "fifo_count", ";", "bits", "-=", "tms", "->", "coeff", "->", "energy_bits", ";", "if", "(", "bits", "<", "0", ")", "{", "request_bits", "(", "tms", ",", "-", "bits", ")", ";", "bits", "=", "0", ";", "}", "indx", "=", "extract_bits", "(", "tms", ",", "tms", "->", "coeff", "->", "energy_bits", ")", ";", "tms", "->", "new_energy", "=", "tms", "->", "coeff", "->", "energytable", "[", "indx", "]", ";", "#if", "(", "DEBUG_5110", ")", "\n", "ene", "=", "indx", ";", "#endif", "if", "(", "(", "indx", "==", "0", ")", "||", "(", "indx", "==", "15", ")", ")", "{", "if", "(", "DEBUG_5110", ")", "logerror", "(", "\"", "\\n", "\"", ",", "tms", "->", "new_energy", ")", ";", "if", "(", "indx", "==", "0", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "tms", "->", "coeff", "->", "num_k", ";", "i", "++", ")", "tms", "->", "new_k", "[", "i", "]", "=", "0", ";", "}", "if", "(", "indx", "==", "15", ")", "{", "if", "(", "DEBUG_5110", ")", "logerror", "(", "\"", "\\n", "\"", ",", "tms", "->", "new_energy", ")", ";", "tms", "->", "fifo_head", "=", "tms", "->", "fifo_tail", "=", "tms", "->", "fifo_count", "=", "0", ";", "}", "return", ";", "}", "bits", "-=", "1", ";", "if", "(", "bits", "<", "0", ")", "{", "request_bits", "(", "tms", ",", "-", "bits", ")", ";", "bits", "=", "0", ";", "}", "rep_flag", "=", "extract_bits", "(", "tms", ",", "1", ")", ";", "bits", "-=", "tms", "->", "coeff", "->", "pitch_bits", ";", "if", "(", "bits", "<", "0", ")", "{", "request_bits", "(", "tms", ",", "-", "bits", ")", ";", "bits", "=", "0", ";", "}", "indx", "=", "extract_bits", "(", "tms", ",", "tms", "->", "coeff", "->", "pitch_bits", ")", ";", "tms", "->", "new_pitch", "=", "tms", "->", "coeff", "->", "pitchtable", "[", "indx", "]", ";", "if", "(", "rep_flag", ")", "{", "if", "(", "DEBUG_5110", ")", "logerror", "(", "\"", "\\n", "\"", ",", "tms", "->", "new_energy", ",", "tms", "->", "new_pitch", ",", "rep_flag", ")", ";", "return", ";", "}", "if", "(", "indx", "==", "0", ")", "{", "bits", "-=", "18", ";", "if", "(", "bits", "<", "0", ")", "{", "request_bits", "(", "tms", ",", "-", "bits", ")", ";", "bits", "=", "0", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "tms", "->", "new_k", "[", "i", "]", "=", "tms", "->", "coeff", "->", "ktable", "[", "i", "]", "[", "extract_bits", "(", "tms", ",", "tms", "->", "coeff", "->", "kbits", "[", "i", "]", ")", "]", ";", "for", "(", "i", "=", "4", ";", "i", "<", "tms", "->", "coeff", "->", "num_k", ";", "i", "++", ")", "tms", "->", "new_k", "[", "i", "]", "=", "0", ";", "if", "(", "DEBUG_5110", ")", "logerror", "(", "\"", "\\n", "\"", ",", "tms", "->", "new_energy", ",", "tms", "->", "new_pitch", ",", "rep_flag", ")", ";", "return", ";", "}", "bits", "-=", "39", ";", "if", "(", "bits", "<", "0", ")", "{", "request_bits", "(", "tms", ",", "-", "bits", ")", ";", "bits", "=", "0", ";", "}", "#if", "(", "DEBUG_5110", ")", "\n", "printf", "(", "\"", "\"", ",", "ene", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "tms", "->", "coeff", "->", "num_k", ";", "i", "++", ")", "{", "int", "x", ";", "x", "=", "extract_bits", "(", "tms", ",", "tms", "->", "coeff", "->", "kbits", "[", "i", "]", ")", ";", "tms", "->", "new_k", "[", "i", "]", "=", "tms", "->", "coeff", "->", "ktable", "[", "i", "]", "[", "x", "]", ";", "printf", "(", "\"", "\"", ",", "x", ")", ";", "}", "printf", "(", "\"", "\\n", "\"", ")", ";", "#else", "for", "(", "i", "=", "0", ";", "i", "<", "tms", "->", "coeff", "->", "num_k", ";", "i", "++", ")", "{", "int", "x", ";", "x", "=", "extract_bits", "(", "tms", ",", "tms", "->", "coeff", "->", "kbits", "[", "i", "]", ")", ";", "tms", "->", "new_k", "[", "i", "]", "=", "tms", "->", "coeff", "->", "ktable", "[", "i", "]", "[", "x", "]", ";", "}", "#endif", "if", "(", "DEBUG_5110", ")", "logerror", "(", "\"", "\\n", "\"", ",", "tms", "->", "new_energy", ",", "tms", "->", "new_pitch", ",", "rep_flag", ")", ";", "}" ]

[ "parse_frame", "--", "parse", "a", "new", "frame", "'", "s", "worth", "of", "data", ";", "returns", "0", "if", "not", "enough", "bits", "in", "buffer" ]

[ "/* count the total number of bits available */", "/* attempt to extract the energy index */", "/* toggle M0 to receive needed bits */", "/* if the energy index is 0 or 15, we're done */", "/* clear the k's */", "/* clear fifo if stop frame encountered */", "/* attempt to extract the repeat flag */", "/* toggle M0 to receive needed bits */", "/* attempt to extract the pitch */", "/* toggle M0 to receive needed bits */", "/* if this is a repeat frame, just copy the k's */", "//actually, we do nothing because the k's were already loaded (on parsing the previous frame)\r", "/* if the pitch index was zero, we need 4 k's */", "/* attempt to extract 4 K's */", "/* toggle M0 to receive needed bits */", "/* and clear the rest of the new_k[] */", "/* else we need 10 K's */", "/* toggle M0 to receive needed bits */" ]

[ { "param": "tms", "type": "tms5110_state" } ]

[ "Unlicense" ]

[ "-", "return", "the", "not", "ready", "status", "from", "the", "sound", "chip" ]

[ "int", "tms5110_ready_r", "(", "running_device", "*", "device", ")", "{", "tms5110_state", "*", "tms", "=", "get_safe_token", "(", "device", ")", ";", "stream_update", "(", "tms", "->", "stream", ")", ";", "return", "(", "tms", "->", "fifo_count", "<", "FIFO_SIZE", "-", "1", ")", ";", "}" ]

[ "tms5110_ready_r", "--", "return", "the", "not", "ready", "status", "from", "the", "sound", "chip" ]

[ "/* bring up to date first */" ]

[ { "param": "device", "type": "running_device" } ]

[ "Unlicense" ]

[ "Counters", "at", "U15", "/", "U16", ":", "On", "VERTDR", "load", "0x33", "into", "counters", "at", "U15", "/", "U16", "On", "HORZDR", "clock", "counters", "stopping", "at", "overflow", "to", "0x00", "(", "prevents", "sparkle", "in", "VBLANK", ")", "Shift", "registers", "at", "U17", "/", "U12", "/", "U11", ":", "cleared", "on", "vertdr", "clocked", "at", "7M", "(", "pixel", "clock", ")", "taps", "from", "bit", "4", "8", "12", "16", "control", "sparkle", "intensity", "Shift", "registers", "at", "U17", "/", "U19", "/", "U18", ":", "cleared", "on", "reset", "clocked", "at", "7M", "(", "pixel", "clock", ")", "if", "bits", "0", "-", "7", "==", "0xfe", "a", "star", "is", "generated", "Both", "shift", "registers", "are", "the", "same", "with", "identical", "feedback", ".", "We", "use", "one", "array", "to", "hold", "both", "shift", "registers", ".", "Bits", "0", "-", "3", "bits", "hold", "the", "intensity", "and", "bit", "4", "holds", "whether", "or", "not", "a", "star", "is", "present", ".", "We", "must", "use", "independent", "lookups", "for", "each", "case", ".", "For", "the", "star", "lookup", "we", "need", "to", "compute", "the", "pixel", "index", "relative", "to", "the", "end", "of", "VBLANK", "and", "use", "that", "(", "which", "at", "455", "*", "262", "is", "guaranteed", "to", "be", "less", "than", "RNG_PERIOD", ")", ".", "For", "the", "sparkle", "lookup", "we", "need", "to", "compute", "the", "pixel", "index", "relative", "to", "the", "beginning", "of", "time", "and", "use", "that", "mod", "RNG_PERIOD", "." ]

[ "static", "void", "init_sparklestar", "(", "running_machine", "*", "machine", ")", "{", "UINT32", "shiftreg", ";", "int", "i", ";", "astrocade_sparkle", "[", "0", "]", "=", "astrocade_sparkle", "[", "1", "]", "=", "astrocade_sparkle", "[", "2", "]", "=", "astrocade_sparkle", "[", "3", "]", "=", "0", ";", "sparklestar", "=", "auto_alloc_array", "(", "machine", ",", "UINT8", ",", "RNG_PERIOD", ")", ";", "for", "(", "shiftreg", "=", "i", "=", "0", ";", "i", "<", "RNG_PERIOD", ";", "i", "++", ")", "{", "UINT8", "newbit", ";", "newbit", "=", "(", "(", "shiftreg", ">>", "12", ")", "^", "~", "shiftreg", ")", "&", "1", ";", "shiftreg", "=", "(", "shiftreg", ">>", "1", ")", "|", "(", "newbit", "<<", "16", ")", ";", "sparklestar", "[", "i", "]", "=", "(", "(", "(", "shiftreg", ">>", "4", ")", "&", "1", ")", "<<", "3", ")", "|", "(", "(", "(", "shiftreg", ">>", "12", ")", "&", "1", ")", "<<", "2", ")", "|", "(", "(", "(", "shiftreg", ">>", "16", ")", "&", "1", ")", "<<", "1", ")", "|", "(", "(", "(", "shiftreg", ">>", "8", ")", "&", "1", ")", "<<", "0", ")", ";", "if", "(", "(", "shiftreg", "&", "0xff", ")", "==", "0xfe", ")", "sparklestar", "[", "i", "]", "|=", "0x10", ";", "}", "}" ]

[ "Counters", "at", "U15", "/", "U16", ":", "On", "VERTDR", "load", "0x33", "into", "counters", "at", "U15", "/", "U16", "On", "HORZDR", "clock", "counters", "stopping", "at", "overflow", "to", "0x00", "(", "prevents", "sparkle", "in", "VBLANK", ")" ]

[ "/* reset global sparkle state */", "/* allocate memory for the sparkle/star array */", "/* generate the data for the sparkle/star array */", "/* clock the shift register */", "/* extract the sparkle/star intensity here */", "/* this is controlled by the shift register at U17/U19/U18 */", "/* determine the star enable here */", "/* this is controlled by the shift register at U17/U12/U11 */" ]

[ { "param": "machine", "type": "running_machine" } ]

[ "Unlicense" ]

[ "Sprites", "probably", "need", "to", "be", "delayed", "Some", "scroll", "layers", "may", "need", "to", "be", "offset", "slightly", "." ]

[ "static", "void", "draw_sprites", "(", "running_machine", "*", "machine", ",", "bitmap_t", "*", "bitmap", ",", "const", "rectangle", "*", "cliprect", ")", "{", "silkroad_state", "*", "state", "=", "machine", "->", "driver_data", "<", "silkroad_state", ">", "(", "", ")", ";", "const", "gfx_element", "*", "gfx", "=", "machine", "->", "gfx", "[", "0", "]", ";", "UINT32", "*", "source", "=", "state", "->", "sprram", ";", "UINT32", "*", "finish", "=", "source", "+", "0x1000", "/", "4", ";", "while", "(", "source", "<", "finish", ")", "{", "int", "xpos", "=", "(", "source", "[", "0", "]", "&", "0x01ff0000", ")", ">>", "16", ";", "int", "ypos", "=", "(", "source", "[", "0", "]", "&", "0x0000ffff", ")", ";", "int", "tileno", "=", "(", "source", "[", "1", "]", "&", "0xffff0000", ")", ">>", "16", ";", "int", "attr", "=", "(", "source", "[", "1", "]", "&", "0x0000ffff", ")", ";", "int", "flipx", "=", "(", "attr", "&", "0x0080", ")", ";", "int", "width", "=", "(", "(", "attr", "&", "0x0f00", ")", ">>", "8", ")", "+", "1", ";", "int", "wcount", ";", "int", "color", "=", "(", "attr", "&", "0x003f", ")", ";", "int", "pri", "=", "(", "(", "attr", "&", "0x1000", ")", ">>", "12", ")", ";", "int", "pri_mask", "=", "~", "(", "(", "1", "<<", "(", "pri", "+", "1", ")", ")", "-", "1", ")", ";", "if", "(", "(", "source", "[", "1", "]", "&", "0xff00", ")", "==", "0xff00", ")", "break", ";", "if", "(", "(", "attr", "&", "0x8000", ")", "==", "0x8000", ")", "tileno", "+=", "0x10000", ";", "if", "(", "!", "flipx", ")", "{", "for", "(", "wcount", "=", "0", ";", "wcount", "<", "width", ";", "wcount", "++", ")", "{", "pdrawgfx_transpen", "(", "bitmap", ",", "cliprect", ",", "gfx", ",", "tileno", "+", "wcount", ",", "color", ",", "0", ",", "0", ",", "xpos", "+", "wcount", "*", "16", "+", "8", ",", "ypos", ",", "machine", "->", "priority_bitmap", ",", "pri_mask", ",", "0", ")", ";", "}", "}", "else", "{", "for", "(", "wcount", "=", "width", ";", "wcount", ">", "0", ";", "wcount", "--", ")", "{", "pdrawgfx_transpen", "(", "bitmap", ",", "cliprect", ",", "gfx", ",", "tileno", "+", "(", "width", "-", "wcount", ")", ",", "color", ",", "1", ",", "0", ",", "xpos", "+", "wcount", "*", "16", "-", "16", "+", "8", ",", "ypos", ",", "machine", "->", "priority_bitmap", ",", "pri_mask", ",", "0", ")", ";", "}", "}", "source", "+=", "2", ";", "}", "}" ]

[ "Sprites", "probably", "need", "to", "be", "delayed", "Some", "scroll", "layers", "may", "need", "to", "be", "offset", "slightly?" ]

[ "// Priority (1 = Low)\r", "// Above the first \"pri\" levels\r", "// attr & 0x2000 -> another priority bit?\r" ]

[ { "param": "machine", "type": "running_machine" }, { "param": "bitmap", "type": "bitmap_t" }, { "param": "cliprect", "type": "rectangle" } ]

[ "Unlicense" ]

[ "Sprites", "Offset", "Encoding", "0", "YYYYYYYY", "1", "TTTTTTTT", "2", "FGGTCCCC", "3", "XXXXXXXX" ]

[ "static", "void", "kchamp_draw_sprites", "(", "running_machine", "*", "machine", ",", "bitmap_t", "*", "bitmap", ",", "const", "rectangle", "*", "cliprect", ")", "{", "kchamp_state", "*", "state", "=", "machine", "->", "driver_data", "<", "kchamp_state", ">", "(", "", ")", ";", "UINT8", "*", "spriteram", "=", "state", "->", "spriteram", ";", "int", "offs", ";", "for", "(", "offs", "=", "0", ";", "offs", "<", "0x100", ";", "offs", "+=", "4", ")", "{", "int", "attr", "=", "spriteram", "[", "offs", "+", "2", "]", ";", "int", "bank", "=", "1", "+", "(", "(", "attr", "&", "0x60", ")", ">>", "5", ")", ";", "int", "code", "=", "spriteram", "[", "offs", "+", "1", "]", "+", "(", "(", "attr", "&", "0x10", ")", "<<", "4", ")", ";", "int", "color", "=", "attr", "&", "0x0f", ";", "int", "flipx", "=", "0", ";", "int", "flipy", "=", "attr", "&", "0x80", ";", "int", "sx", "=", "spriteram", "[", "offs", "+", "3", "]", "-", "8", ";", "int", "sy", "=", "247", "-", "spriteram", "[", "offs", "]", ";", "if", "(", "flip_screen_get", "(", "machine", ")", ")", "{", "sx", "=", "240", "-", "sx", ";", "sy", "=", "240", "-", "sy", ";", "flipx", "=", "!", "flipx", ";", "flipy", "=", "!", "flipy", ";", "}", "drawgfx_transpen", "(", "bitmap", ",", "cliprect", ",", "machine", "->", "gfx", "[", "bank", "]", ",", "code", ",", "color", ",", "flipx", ",", "flipy", ",", "sx", ",", "sy", ",", "0", ")", ";", "}", "}" ]

[ "Sprites" ]

[]

[ { "param": "machine", "type": "running_machine" }, { "param": "bitmap", "type": "bitmap_t" }, { "param": "cliprect", "type": "rectangle" } ]

[ "Unlicense" ]

[ "64", "-", "bit", "int", "printing", "with", "commas" ]

[ "static", "void", "print_big_int", "(", "UINT64", "intvalue", ",", "char", "*", "output", ")", "{", "int", "chunk", ";", "chunk", "=", "intvalue", "%", "1000", ";", "intvalue", "/=", "1000", ";", "if", "(", "intvalue", "!=", "0", ")", "{", "print_big_int", "(", "intvalue", ",", "output", ")", ";", "strcat", "(", "output", ",", "\"", "\"", ")", ";", "sprintf", "(", "&", "output", "[", "strlen", "(", "output", ")", "]", ",", "\"", "\"", ",", "chunk", ")", ";", "}", "else", "sprintf", "(", "&", "output", "[", "strlen", "(", "output", ")", "]", ",", "\"", "\"", ",", "chunk", ")", ";", "}" ]

[ "print_big_int", "-", "64", "-", "bit", "int", "printing", "with", "commas" ]

[]

[ { "param": "intvalue", "type": "UINT64" }, { "param": "output", "type": "char" } ]

[ "Unlicense" ]

[ "return", "a", "string", "for", "a", "big", "integer" ]

[ "static", "char", "*", "big_int_string", "(", "UINT64", "intvalue", ")", "{", "static", "char", "buffer", "[", "256", "]", ";", "buffer", "[", "0", "]", "=", "0", ";", "print_big_int", "(", "intvalue", ",", "buffer", ")", ";", "return", "buffer", ";", "}" ]

[ "big_int_string", "-", "return", "a", "string", "for", "a", "big", "integer" ]

[]

[ { "param": "intvalue", "type": "UINT64" } ]

[ "Unlicense" ]

[ "given", "a", "file", "and", "an", "offset", "compute", "a", "best", "guess", "CHS", "value", "set" ]

[ "static", "chd_error", "guess_chs", "(", "const", "char", "*", "filename", ",", "int", "offset", ",", "int", "sectorsize", ",", "UINT32", "*", "cylinders", ",", "UINT32", "*", "heads", ",", "UINT32", "*", "sectors", ",", "UINT32", "*", "bps", ")", "{", "UINT32", "totalsecs", ",", "hds", ",", "secs", ";", "UINT64", "filesize", ";", "if", "(", "osd_get_physical_drive_geometry", "(", "filename", ",", "cylinders", ",", "heads", ",", "sectors", ",", "bps", ")", ")", "return", "CHDERR_NONE", ";", "filesize", "=", "get_file_size", "(", "filename", ")", ";", "if", "(", "filesize", "<=", "offset", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "filename", ")", ";", "return", "CHDERR_INVALID_FILE", ";", "}", "filesize", "-=", "offset", ";", "if", "(", "filesize", "%", "sectorsize", "!=", "0", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "return", "CHDERR_INVALID_FILE", ";", "}", "totalsecs", "=", "filesize", "/", "sectorsize", ";", "for", "(", "secs", "=", "63", ";", "secs", ">", "1", ";", "secs", "--", ")", "if", "(", "totalsecs", "%", "secs", "==", "0", ")", "{", "size_t", "totalhds", "=", "totalsecs", "/", "secs", ";", "for", "(", "hds", "=", "16", ";", "hds", ">", "1", ";", "hds", "--", ")", "if", "(", "totalhds", "%", "hds", "==", "0", ")", "{", "*", "cylinders", "=", "totalhds", "/", "hds", ";", "*", "heads", "=", "hds", ";", "*", "sectors", "=", "secs", ";", "*", "bps", "=", "sectorsize", ";", "return", "CHDERR_NONE", ";", "}", "}", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "return", "CHDERR_INVALID_FILE", ";", "}" ]

[ "guess_chs", "-", "given", "a", "file", "and", "an", "offset", "compute", "a", "best", "guess", "CHS", "value", "set" ]

[ "/* if this is a direct physical drive read, handle it specially */", "/* compute the filesize */", "/* validate the size */", "/* now find a valid value */", "/* ack, it didn't work! */" ]

[ { "param": "filename", "type": "char" }, { "param": "offset", "type": "int" }, { "param": "sectorsize", "type": "int" }, { "param": "cylinders", "type": "UINT32" }, { "param": "heads", "type": "UINT32" }, { "param": "sectors", "type": "UINT32" }, { "param": "bps", "type": "UINT32" } ]

[ "Unlicense" ]

[ "create", "a", "new", "compressed", "hard", "disk", "image", "from", "a", "raw", "file" ]

[ "static", "int", "do_createhd", "(", "int", "argc", ",", "char", "*", "argv", "[", "]", ",", "int", "param", ")", "{", "UINT32", "guess_cylinders", "=", "0", ",", "guess_heads", "=", "0", ",", "guess_sectors", "=", "0", ",", "guess_sectorsize", "=", "0", ";", "UINT32", "cylinders", ",", "heads", ",", "sectors", ",", "sectorsize", ",", "hunksize", ",", "totalsectors", ",", "offset", ";", "const", "char", "*", "inputfile", ",", "*", "outputfile", "=", "NULL", ";", "chd_error", "err", "=", "CHDERR_NONE", ";", "UINT32", "identdatasize", "=", "0", ";", "UINT8", "*", "identdata", "=", "NULL", ";", "chd_file", "*", "chd", "=", "NULL", ";", "char", "metadata", "[", "256", "]", ";", "if", "(", "argc", ">=", "5", ")", "{", "char", "*", "scan", ";", "for", "(", "scan", "=", "argv", "[", "4", "]", ";", "*", "scan", "!=", "0", ";", "scan", "++", ")", "if", "(", "!", "isdigit", "(", "(", "UINT8", ")", "*", "scan", ")", ")", "break", ";", "if", "(", "*", "scan", "!=", "0", ")", "{", "file_error", "filerr", "=", "core_fload", "(", "argv", "[", "4", "]", ",", "(", "void", "*", "*", ")", "&", "identdata", ",", "&", "identdatasize", ")", ";", "if", "(", "filerr", "!=", "FILERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "argv", "[", "4", "]", ")", ";", "return", "1", ";", "}", "if", "(", "argc", ">", "5", ")", "memmove", "(", "&", "argv", "[", "4", "]", ",", "&", "argv", "[", "5", "]", ",", "(", "argc", "-", "5", ")", "*", "sizeof", "(", "argv", "[", "0", "]", ")", ")", ";", "argc", "--", ";", "}", "}", "if", "(", "argc", "!=", "4", "&&", "argc", "!=", "5", "&&", "argc", "!=", "8", "&&", "argc", "!=", "9", "&&", "argc", "!=", "10", ")", "return", "usage", "(", ")", ";", "inputfile", "=", "argv", "[", "2", "]", ";", "outputfile", "=", "argv", "[", "3", "]", ";", "offset", "=", "(", "argc", ">=", "5", ")", "?", "atoi", "(", "argv", "[", "4", "]", ")", ":", "(", "get_file_size", "(", "inputfile", ")", "%", "IDE_SECTOR_SIZE", ")", ";", "if", "(", "argc", "<", "8", ")", "{", "if", "(", "identdata", "!=", "NULL", ")", "err", "=", "get_chs_from_ident", "(", "inputfile", ",", "offset", ",", "identdata", ",", "identdatasize", ",", "&", "guess_cylinders", ",", "&", "guess_heads", ",", "&", "guess_sectors", ",", "&", "guess_sectorsize", ")", ";", "else", "err", "=", "guess_chs", "(", "inputfile", ",", "offset", ",", "IDE_SECTOR_SIZE", ",", "&", "guess_cylinders", ",", "&", "guess_heads", ",", "&", "guess_sectors", ",", "&", "guess_sectorsize", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "goto", "cleanup", ";", "}", "cylinders", "=", "(", "argc", ">=", "6", ")", "?", "atoi", "(", "argv", "[", "5", "]", ")", ":", "guess_cylinders", ";", "heads", "=", "(", "argc", ">=", "7", ")", "?", "atoi", "(", "argv", "[", "6", "]", ")", ":", "guess_heads", ";", "sectors", "=", "(", "argc", ">=", "8", ")", "?", "atoi", "(", "argv", "[", "7", "]", ")", ":", "guess_sectors", ";", "sectorsize", "=", "(", "argc", ">=", "9", ")", "?", "atoi", "(", "argv", "[", "8", "]", ")", ":", "guess_sectorsize", ";", "if", "(", "sectorsize", "==", "0", ")", "sectorsize", "=", "IDE_SECTOR_SIZE", ";", "hunksize", "=", "(", "argc", ">=", "10", ")", "?", "atoi", "(", "argv", "[", "9", "]", ")", ":", "(", "sectorsize", ">", "4096", ")", "?", "sectorsize", ":", "(", "(", "4096", "/", "sectorsize", ")", "*", "sectorsize", ")", ";", "totalsectors", "=", "cylinders", "*", "heads", "*", "sectors", ";", "printf", "(", "\"", "\\n", "\"", ",", "inputfile", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "outputfile", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "offset", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "cylinders", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "heads", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "sectors", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "sectorsize", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "hunksize", "/", "sectorsize", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "big_int_string", "(", "(", "UINT64", ")", "totalsectors", "*", "(", "UINT64", ")", "sectorsize", ")", ")", ";", "err", "=", "chd_create", "(", "outputfile", ",", "(", "UINT64", ")", "totalsectors", "*", "(", "UINT64", ")", "sectorsize", ",", "hunksize", ",", "CHDCOMPRESSION_ZLIB_PLUS", ",", "NULL", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chd_open", "(", "outputfile", ",", "CHD_OPEN_READWRITE", ",", "NULL", ",", "&", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "sprintf", "(", "metadata", ",", "HARD_DISK_METADATA_FORMAT", ",", "cylinders", ",", "heads", ",", "sectors", ",", "sectorsize", ")", ";", "err", "=", "chd_set_metadata", "(", "chd", ",", "HARD_DISK_METADATA_TAG", ",", "0", ",", "metadata", ",", "strlen", "(", "metadata", ")", "+", "1", ",", "CHD_MDFLAGS_CHECKSUM", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "if", "(", "identdata", "!=", "NULL", ")", "{", "err", "=", "chd_set_metadata", "(", "chd", ",", "HARD_DISK_IDENT_METADATA_TAG", ",", "0", ",", "identdata", ",", "identdatasize", ",", "CHD_MDFLAGS_CHECKSUM", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "}", "err", "=", "chdman_compress_file", "(", "chd", ",", "inputfile", ",", "offset", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "cleanup", ":", "if", "(", "chd", "!=", "NULL", ")", "chd_close", "(", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "osd_rmfile", "(", "outputfile", ")", ";", "if", "(", "identdata", "!=", "NULL", ")", "free", "(", "identdata", ")", ";", "return", "(", "err", "!=", "CHDERR_NONE", ")", ";", "}" ]

[ "do_createhd", "-", "create", "a", "new", "compressed", "hard", "disk", "image", "from", "a", "raw", "file" ]

[ "/* if a file is provided for argument 4 (ident filename), then shift the remaining arguments down */", "/* if there are any non-digits in the 'offset', then treat it as a ident file */", "/* attempt to load the file */", "/* shift the remaining arguments down */", "/* require 4-5, or 8-10 args total */", "/* extract the first few parameters */", "/* if less than 8 parameters, we need to guess the CHS values */", "/* parse the remaining parameters */", "/* print some info */", "/* create the new hard drive */", "/* open the new hard drive */", "/* write the metadata */", "/* write the ident if present */", "/* compress the hard drive */", "/* close everything down */" ]

[ { "param": "argc", "type": "int" }, { "param": "argv", "type": "char" }, { "param": "param", "type": "int" } ]

[ "Unlicense" ]

[ "create", "a", "new", "compressed", "raw", "image", "from", "a", "raw", "file" ]

[ "static", "int", "do_createraw", "(", "int", "argc", ",", "char", "*", "argv", "[", "]", ",", "int", "param", ")", "{", "const", "char", "*", "inputfile", ",", "*", "outputfile", ";", "UINT32", "hunksize", ",", "offset", ";", "UINT64", "logicalbytes", ";", "chd_file", "*", "chd", "=", "NULL", ";", "chd_error", "err", ";", "if", "(", "argc", "!=", "4", "&&", "argc", "!=", "5", "&&", "argc", "!=", "6", ")", "return", "usage", "(", ")", ";", "inputfile", "=", "argv", "[", "2", "]", ";", "outputfile", "=", "argv", "[", "3", "]", ";", "offset", "=", "(", "argc", ">=", "5", ")", "?", "atoi", "(", "argv", "[", "4", "]", ")", ":", "0", ";", "hunksize", "=", "(", "argc", ">=", "6", ")", "?", "atoi", "(", "argv", "[", "5", "]", ")", ":", "4096", ";", "logicalbytes", "=", "get_file_size", "(", "inputfile", ")", "-", "offset", ";", "printf", "(", "\"", "\\n", "\"", ",", "inputfile", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "outputfile", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "offset", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "hunksize", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "big_int_string", "(", "logicalbytes", ")", ")", ";", "err", "=", "chd_create", "(", "outputfile", ",", "logicalbytes", ",", "hunksize", ",", "CHDCOMPRESSION_ZLIB_PLUS", ",", "NULL", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chd_open", "(", "outputfile", ",", "CHD_OPEN_READWRITE", ",", "NULL", ",", "&", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chdman_compress_file", "(", "chd", ",", "inputfile", ",", "offset", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "cleanup", ":", "if", "(", "chd", "!=", "NULL", ")", "chd_close", "(", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "osd_rmfile", "(", "outputfile", ")", ";", "return", "(", "err", "!=", "CHDERR_NONE", ")", ";", "}" ]

[ "do_createraw", "-", "create", "a", "new", "compressed", "raw", "image", "from", "a", "raw", "file" ]

[ "/* require 4, 5, or 6 args total */", "/* extract the first few parameters */", "/* print some info */", "/* create the new CHD */", "/* open the new CHD */", "/* compress the CHD */", "/* close everything down */" ]

[ { "param": "argc", "type": "int" }, { "param": "argv", "type": "char" }, { "param": "param", "type": "int" } ]

[ "Unlicense" ]

[ "create", "a", "new", "compressed", "CD", "image", "from", "a", "raw", "file" ]

[ "static", "int", "do_createcd", "(", "int", "argc", ",", "char", "*", "argv", "[", "]", ",", "int", "param", ")", "{", "static", "chdcd_track_input_info", "track_info", ";", "static", "cdrom_toc", "toc", ";", "UINT32", "hunksize", "=", "CD_FRAME_SIZE", "*", "CD_FRAMES_PER_HUNK", ";", "UINT32", "sectorsize", "=", "CD_FRAME_SIZE", ";", "const", "char", "*", "inputfile", ",", "*", "outputfile", ";", "core_file", "*", "srcfile", "=", "NULL", ";", "UINT32", "origtotalsectors", ";", "chd_file", "*", "chd", "=", "NULL", ";", "UINT8", "*", "cache", "=", "NULL", ";", "UINT32", "totalsectors", ";", "double", "ratio", "=", "1.0", ";", "UINT32", "totalhunks", ";", "file_error", "filerr", ";", "chd_error", "err", ";", "int", "i", ";", "if", "(", "argc", "!=", "4", ")", "return", "usage", "(", ")", ";", "inputfile", "=", "argv", "[", "2", "]", ";", "outputfile", "=", "argv", "[", "3", "]", ";", "cache", "=", "(", "UINT8", "*", ")", "malloc", "(", "hunksize", ")", ";", "if", "(", "cache", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "err", "=", "CHDERR_OUT_OF_MEMORY", ";", "goto", "cleanup", ";", "}", "err", "=", "chdcd_parse_toc", "(", "inputfile", ",", "&", "toc", ",", "&", "track_info", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "toc", ".", "numtrks", ";", "i", "++", ")", "{", "int", "hunks", "=", "(", "toc", ".", "tracks", "[", "i", "]", ".", "frames", "+", "CD_FRAMES_PER_HUNK", "-", "1", ")", "/", "CD_FRAMES_PER_HUNK", ";", "toc", ".", "tracks", "[", "i", "]", ".", "extraframes", "=", "hunks", "*", "CD_FRAMES_PER_HUNK", "-", "toc", ".", "tracks", "[", "i", "]", ".", "frames", ";", "}", "origtotalsectors", "=", "totalsectors", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "toc", ".", "numtrks", ";", "i", "++", ")", "{", "origtotalsectors", "+=", "toc", ".", "tracks", "[", "i", "]", ".", "frames", ";", "totalsectors", "+=", "toc", ".", "tracks", "[", "i", "]", ".", "frames", "+", "toc", ".", "tracks", "[", "i", "]", ".", "extraframes", ";", "}", "printf", "(", "\"", "\\n", "\\n", "\"", ",", "inputfile", ",", "toc", ".", "numtrks", ",", "origtotalsectors", ")", ";", "err", "=", "chd_create", "(", "outputfile", ",", "(", "UINT64", ")", "totalsectors", "*", "(", "UINT64", ")", "sectorsize", ",", "hunksize", ",", "CHDCOMPRESSION_ZLIB_PLUS", ",", "NULL", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chd_open", "(", "outputfile", ",", "CHD_OPEN_READWRITE", ",", "NULL", ",", "&", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "cdrom_write_metadata", "(", "chd", ",", "&", "toc", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chd_compress_begin", "(", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "totalhunks", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "toc", ".", "numtrks", ";", "i", "++", ")", "{", "int", "frames", "=", "0", ";", "int", "bytespersector", "=", "toc", ".", "tracks", "[", "i", "]", ".", "datasize", "+", "toc", ".", "tracks", "[", "i", "]", ".", "subsize", ";", "int", "trackhunks", "=", "(", "toc", ".", "tracks", "[", "i", "]", ".", "frames", "+", "toc", ".", "tracks", "[", "i", "]", ".", "extraframes", ")", "/", "CD_FRAMES_PER_HUNK", ";", "UINT64", "sourcefileoffset", "=", "track_info", ".", "offset", "[", "i", "]", ";", "int", "curhunk", ";", "filerr", "=", "core_fopen", "(", "track_info", ".", "fname", "[", "i", "]", ",", "OPEN_FLAG_READ", ",", "&", "srcfile", ")", ";", "if", "(", "filerr", "!=", "FILERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "track_info", ".", "fname", "[", "i", "]", ")", ";", "err", "=", "CHDERR_FILE_NOT_FOUND", ";", "goto", "cleanup", ";", "}", "printf", "(", "\"", "\\n", "\"", ",", "i", "+", "1", ",", "toc", ".", "numtrks", ",", "track_info", ".", "fname", "[", "i", "]", ",", "track_info", ".", "offset", "[", "i", "]", ",", "toc", ".", "tracks", "[", "i", "]", ".", "frames", ",", "trackhunks", ",", "track_info", ".", "swap", "[", "i", "]", ")", ";", "for", "(", "curhunk", "=", "0", ";", "curhunk", "<", "trackhunks", ";", "curhunk", "++", ",", "totalhunks", "++", ")", "{", "int", "secnum", ";", "progress", "(", "FALSE", ",", "\"", "\\r", "\"", ",", "totalhunks", ",", "chd_get_header", "(", "chd", ")", "->", "totalhunks", ",", "(", "int", ")", "(", "ratio", "*", "100", ")", ")", ";", "memset", "(", "cache", ",", "0", ",", "hunksize", ")", ";", "for", "(", "secnum", "=", "0", ";", "secnum", "<", "CD_FRAMES_PER_HUNK", ";", "secnum", "++", ")", "{", "if", "(", "frames", "<", "toc", ".", "tracks", "[", "i", "]", ".", "frames", ")", "{", "core_fseek", "(", "srcfile", ",", "sourcefileoffset", ",", "SEEK_SET", ")", ";", "core_fread", "(", "srcfile", ",", "&", "cache", "[", "secnum", "*", "CD_FRAME_SIZE", "]", ",", "bytespersector", ")", ";", "if", "(", "track_info", ".", "swap", "[", "i", "]", ")", "{", "int", "swapindex", ";", "for", "(", "swapindex", "=", "0", ";", "swapindex", "<", "2352", ";", "swapindex", "+=", "2", ")", "{", "int", "swapoffset", "=", "(", "secnum", "*", "CD_FRAME_SIZE", ")", "+", "swapindex", ";", "int", "swaptemp", "=", "cache", "[", "swapoffset", "]", ";", "cache", "[", "swapoffset", "]", "=", "cache", "[", "swapoffset", "+", "1", "]", ";", "cache", "[", "swapoffset", "+", "1", "]", "=", "swaptemp", ";", "}", "}", "}", "sourcefileoffset", "+=", "bytespersector", ";", "frames", "++", ";", "}", "err", "=", "chd_compress_hunk", "(", "chd", ",", "cache", ",", "&", "ratio", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "}", "core_fclose", "(", "srcfile", ")", ";", "srcfile", "=", "NULL", ";", "}", "err", "=", "chd_compress_finish", "(", "chd", ",", "TRUE", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "else", "progress", "(", "TRUE", ",", "\"", "\\n", "\"", ",", "(", "int", ")", "(", "100.0", "*", "ratio", ")", ")", ";", "cleanup", ":", "if", "(", "cache", "!=", "NULL", ")", "free", "(", "cache", ")", ";", "if", "(", "srcfile", "!=", "NULL", ")", "core_fclose", "(", "srcfile", ")", ";", "if", "(", "chd", "!=", "NULL", ")", "chd_close", "(", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "osd_rmfile", "(", "outputfile", ")", ";", "return", "(", "err", "!=", "CHDERR_NONE", ")", ";", "}" ]

[ "do_createcd", "-", "create", "a", "new", "compressed", "CD", "image", "from", "a", "raw", "file" ]

[ "/* require 4 args total */", "/* extract the data */", "/* allocate a cache */", "/* setup the CDROM module and get the disc info */", "/* pad each track to a hunk boundry. cdrom.c will deal with this on the read side */", "/* count up the total number of frames */", "/* create the new CHD file */", "/* open the new CHD file */", "/* write the metadata */", "/* begin state for writing */", "/* loop over tracks */", "/* open the input file for this track */", "/* loop over hunks */", "/* loop over sectors in this hunk, reading the source data into a fixed start location */", "/* relative to the start; we zero out the buffer ahead of time to ensure that unpopulated */", "/* areas are cleared */", "/* compress the current hunk */", "/* close the file */", "/* cleanup */" ]

[ { "param": "argc", "type": "int" }, { "param": "argv", "type": "char" }, { "param": "param", "type": "int" } ]

[ "Unlicense" ]

[ "create", "a", "new", "non", "-", "compressed", "hard", "disk", "image", "with", "all", "hunks", "filled", "with", "0s" ]

[ "static", "int", "do_createblankhd", "(", "int", "argc", ",", "char", "*", "argv", "[", "]", ",", "int", "param", ")", "{", "UINT32", "cylinders", ",", "heads", ",", "sectors", ",", "sectorsize", ",", "hunksize", ",", "totalsectors", ",", "hunknum", ";", "const", "char", "*", "outputfile", ";", "chd_file", "*", "chd", "=", "NULL", ";", "UINT8", "*", "cache", "=", "NULL", ";", "char", "metadata", "[", "256", "]", ";", "chd_error", "err", ";", "if", "(", "argc", "!=", "6", "&&", "argc", "!=", "7", "&&", "argc", "!=", "8", ")", "return", "usage", "(", ")", ";", "outputfile", "=", "argv", "[", "2", "]", ";", "cylinders", "=", "atoi", "(", "argv", "[", "3", "]", ")", ";", "heads", "=", "atoi", "(", "argv", "[", "4", "]", ")", ";", "sectors", "=", "atoi", "(", "argv", "[", "5", "]", ")", ";", "sectorsize", "=", "(", "argc", ">=", "7", ")", "?", "atoi", "(", "argv", "[", "6", "]", ")", ":", "IDE_SECTOR_SIZE", ";", "if", "(", "sectorsize", "==", "0", ")", "sectorsize", "=", "IDE_SECTOR_SIZE", ";", "hunksize", "=", "(", "argc", ">=", "8", ")", "?", "atoi", "(", "argv", "[", "7", "]", ")", ":", "(", "sectorsize", ">", "4096", ")", "?", "sectorsize", ":", "(", "(", "4096", "/", "sectorsize", ")", "*", "sectorsize", ")", ";", "totalsectors", "=", "cylinders", "*", "heads", "*", "sectors", ";", "printf", "(", "\"", "\\n", "\"", ",", "outputfile", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "cylinders", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "heads", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "sectors", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "sectorsize", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "hunksize", "/", "sectorsize", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "big_int_string", "(", "(", "UINT64", ")", "totalsectors", "*", "(", "UINT64", ")", "sectorsize", ")", ")", ";", "err", "=", "chd_create", "(", "outputfile", ",", "(", "UINT64", ")", "totalsectors", "*", "(", "UINT64", ")", "sectorsize", ",", "hunksize", ",", "CHDCOMPRESSION_NONE", ",", "NULL", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chd_open", "(", "outputfile", ",", "CHD_OPEN_READWRITE", ",", "NULL", ",", "&", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "sprintf", "(", "metadata", ",", "HARD_DISK_METADATA_FORMAT", ",", "cylinders", ",", "heads", ",", "sectors", ",", "sectorsize", ")", ";", "err", "=", "chd_set_metadata", "(", "chd", ",", "HARD_DISK_METADATA_TAG", ",", "0", ",", "metadata", ",", "strlen", "(", "metadata", ")", "+", "1", ",", "CHD_MDFLAGS_CHECKSUM", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "cache", "=", "(", "UINT8", "*", ")", "malloc", "(", "hunksize", ")", ";", "if", "(", "cache", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "err", "=", "CHDERR_OUT_OF_MEMORY", ";", "goto", "cleanup", ";", "}", "memset", "(", "cache", ",", "0", ",", "hunksize", ")", ";", "for", "(", "hunknum", "=", "0", ";", "hunknum", "<", "chd_get_header", "(", "chd", ")", "->", "totalhunks", ";", "hunknum", "++", ")", "{", "progress", "(", "hunknum", "==", "0", ",", "\"", "\\r", "\"", ",", "hunknum", ",", "chd_get_header", "(", "chd", ")", "->", "totalhunks", ")", ";", "err", "=", "chd_write", "(", "chd", ",", "hunknum", ",", "cache", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "}", "progress", "(", "TRUE", ",", "\"", "\\n", "\"", ")", ";", "cleanup", ":", "if", "(", "cache", "!=", "NULL", ")", "free", "(", "cache", ")", ";", "if", "(", "chd", "!=", "NULL", ")", "chd_close", "(", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "osd_rmfile", "(", "outputfile", ")", ";", "return", "(", "err", "!=", "CHDERR_NONE", ")", ";", "}" ]

[ "do_createblankhd", "-", "create", "a", "new", "non", "-", "compressed", "hard", "disk", "image", "with", "all", "hunks", "filled", "with", "0s" ]

[ "/* require 6, 7, or 8 args total */", "/* extract the data */", "/* print some info */", "/* create the new hard drive */", "/* open the new hard drive */", "/* write the metadata */", "/* alloc and zero buffer*/", "/* Zero every hunk */", "/* progress */", "/* write out the data */", "/* close everything down */" ]

[ { "param": "argc", "type": "int" }, { "param": "argv", "type": "char" }, { "param": "param", "type": "int" } ]

[ "Unlicense" ]

[ "copy", "all", "hunks", "of", "data", "from", "one", "CHD", "file", "to", "another", ".", "The", "hunk", "sizes", "do", "not", "need", "to", "match", ".", "If", "the", "source", "is", "shorter", "than", "the", "destination", "the", "source", "data", "will", "be", "padded", "with", "0s", "." ]

[ "static", "int", "do_copydata", "(", "int", "argc", ",", "char", "*", "argv", "[", "]", ",", "int", "param", ")", "{", "const", "char", "*", "inputfile", ",", "*", "outputfile", ";", "chd_file", "*", "outputchd", "=", "NULL", ";", "chd_file", "*", "inputchd", "=", "NULL", ";", "chd_error", "err", ";", "if", "(", "argc", "!=", "4", ")", "return", "usage", "(", ")", ";", "inputfile", "=", "argv", "[", "2", "]", ";", "outputfile", "=", "argv", "[", "3", "]", ";", "printf", "(", "\"", "\\n", "\"", ",", "inputfile", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "outputfile", ")", ";", "err", "=", "chd_open", "(", "inputfile", ",", "CHD_OPEN_READ", ",", "NULL", ",", "&", "inputchd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chd_open", "(", "outputfile", ",", "CHD_OPEN_READWRITE", ",", "NULL", ",", "&", "outputchd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chdman_compress_chd", "(", "outputchd", ",", "inputchd", ",", "0", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "cleanup", ":", "if", "(", "outputchd", "!=", "NULL", ")", "chd_close", "(", "outputchd", ")", ";", "if", "(", "inputchd", "!=", "NULL", ")", "chd_close", "(", "inputchd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "osd_rmfile", "(", "outputfile", ")", ";", "return", "(", "err", "!=", "CHDERR_NONE", ")", ";", "}" ]

[ "do_copydata", "-", "copy", "all", "hunks", "of", "data", "from", "one", "CHD", "file", "to", "another", "." ]

[ "/* require 4 args total */", "/* extract the data */", "/* print some info */", "/* open the src hard drive */", "/* open the dest hard drive */", "/* compress the source into the dest */", "/* close everything down */" ]

[ { "param": "argc", "type": "int" }, { "param": "argv", "type": "char" }, { "param": "param", "type": "int" } ]

[ "Unlicense" ]

[ "extract", "a", "raw", "file", "from", "a", "CHD", "image" ]

[ "static", "int", "do_extract", "(", "int", "argc", ",", "char", "*", "argv", "[", "]", ",", "int", "param", ")", "{", "const", "char", "*", "inputfile", ",", "*", "outputfile", ";", "core_file", "*", "outfile", "=", "NULL", ";", "chd_file", "*", "infile", "=", "NULL", ";", "const", "chd_header", "*", "header", ";", "UINT64", "bytesremaining", ";", "void", "*", "hunk", "=", "NULL", ";", "file_error", "filerr", ";", "chd_error", "err", ";", "int", "hunknum", ";", "if", "(", "argc", "!=", "4", ")", "return", "usage", "(", ")", ";", "inputfile", "=", "argv", "[", "2", "]", ";", "outputfile", "=", "argv", "[", "3", "]", ";", "printf", "(", "\"", "\\n", "\"", ",", "inputfile", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "outputfile", ")", ";", "err", "=", "chd_open", "(", "inputfile", ",", "CHD_OPEN_READ", ",", "NULL", ",", "&", "infile", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "inputfile", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "header", "=", "chd_get_header", "(", "infile", ")", ";", "hunk", "=", "malloc", "(", "header", "->", "hunkbytes", ")", ";", "if", "(", "hunk", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "err", "=", "CHDERR_OUT_OF_MEMORY", ";", "goto", "cleanup", ";", "}", "filerr", "=", "core_fopen", "(", "outputfile", ",", "OPEN_FLAG_WRITE", "|", "OPEN_FLAG_CREATE", ",", "&", "outfile", ")", ";", "if", "(", "filerr", "!=", "FILERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "outputfile", ")", ";", "err", "=", "CHDERR_CANT_CREATE_FILE", ";", "goto", "cleanup", ";", "}", "bytesremaining", "=", "header", "->", "logicalbytes", ";", "for", "(", "hunknum", "=", "0", ";", "hunknum", "<", "header", "->", "totalhunks", ";", "hunknum", "++", ")", "{", "UINT32", "byteswritten", ",", "bytes_to_write", ";", "progress", "(", "hunknum", "==", "0", ",", "\"", "\\r", "\"", ",", "hunknum", ",", "header", "->", "totalhunks", ")", ";", "err", "=", "chd_read", "(", "infile", ",", "hunknum", ",", "hunk", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "hunknum", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "bytes_to_write", "=", "MIN", "(", "bytesremaining", ",", "header", "->", "hunkbytes", ")", ";", "core_fseek", "(", "outfile", ",", "(", "UINT64", ")", "hunknum", "*", "(", "UINT64", ")", "header", "->", "hunkbytes", ",", "SEEK_SET", ")", ";", "byteswritten", "=", "core_fwrite", "(", "outfile", ",", "hunk", ",", "bytes_to_write", ")", ";", "if", "(", "byteswritten", "!=", "bytes_to_write", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "hunknum", ",", "chd_error_string", "(", "CHDERR_WRITE_ERROR", ")", ")", ";", "err", "=", "CHDERR_WRITE_ERROR", ";", "goto", "cleanup", ";", "}", "bytesremaining", "-=", "byteswritten", ";", "}", "progress", "(", "TRUE", ",", "\"", "\\n", "\"", ")", ";", "cleanup", ":", "if", "(", "outfile", "!=", "NULL", ")", "core_fclose", "(", "outfile", ")", ";", "if", "(", "hunk", "!=", "NULL", ")", "free", "(", "hunk", ")", ";", "if", "(", "infile", "!=", "NULL", ")", "chd_close", "(", "infile", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "osd_rmfile", "(", "outputfile", ")", ";", "return", "(", "err", "!=", "CHDERR_NONE", ")", ";", "}" ]

[ "do_extract", "-", "extract", "a", "raw", "file", "from", "a", "CHD", "image" ]

[ "/* require 4 args total */", "/* extract the data */", "/* print some info */", "/* get the header */", "/* allocate memory to hold a hunk */", "/* create the output file */", "/* loop over hunks, reading and writing */", "/* progress */", "/* read the hunk into a buffer */", "/* write the hunk to the file */", "/* clean up our mess */" ]

[ { "param": "argc", "type": "int" }, { "param": "argv", "type": "char" }, { "param": "param", "type": "int" } ]

[ "Unlicense" ]

[ "validate", "the", "MD5", "/", "SHA1", "on", "a", "drive", "image" ]

[ "static", "int", "do_verify", "(", "int", "argc", ",", "char", "*", "argv", "[", "]", ",", "int", "param", ")", "{", "chd_verify_result", "verify", ";", "const", "char", "*", "inputfile", ";", "chd_file", "*", "chd", "=", "NULL", ";", "chd_header", "header", ";", "int", "fixed", "=", "FALSE", ";", "chd_error", "err", ";", "int", "i", ";", "if", "(", "argc", "!=", "3", ")", "return", "usage", "(", ")", ";", "inputfile", "=", "argv", "[", "2", "]", ";", "printf", "(", "\"", "\\n", "\"", ",", "inputfile", ")", ";", "err", "=", "chd_open", "(", "inputfile", ",", "CHD_OPEN_READ", ",", "NULL", ",", "&", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "header", "=", "*", "chd_get_header", "(", "chd", ")", ";", "err", "=", "chd_verify_begin", "(", "chd", ")", ";", "if", "(", "err", "==", "CHDERR_NONE", ")", "{", "UINT32", "hunknum", ";", "for", "(", "hunknum", "=", "0", ";", "hunknum", "<", "header", ".", "totalhunks", ";", "hunknum", "++", ")", "{", "progress", "(", "FALSE", ",", "\"", "\\r", "\"", ",", "hunknum", ",", "header", ".", "totalhunks", ")", ";", "err", "=", "chd_verify_hunk", "(", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "break", ";", "}", "if", "(", "err", "==", "CHDERR_NONE", ")", "err", "=", "chd_verify_finish", "(", "chd", ",", "&", "verify", ")", ";", "}", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "if", "(", "err", "==", "CHDERR_CANT_VERIFY", ")", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "else", "fprintf", "(", "stderr", ",", "\"", "\\n", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "if", "(", "header", ".", "version", "<=", "3", ")", "{", "if", "(", "memcmp", "(", "header", ".", "md5", ",", "verify", ".", "md5", ",", "sizeof", "(", "header", ".", "md5", ")", ")", "==", "0", ")", "printf", "(", "\"", "\\n", "\"", ")", ";", "else", "{", "fprintf", "(", "stderr", ",", "\"", "\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CHD_MD5_BYTES", ";", "i", "++", ")", "fprintf", "(", "stderr", ",", "\"", "\"", ",", "header", ".", "md5", "[", "i", "]", ")", ";", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "fprintf", "(", "stderr", ",", "\"", "\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CHD_MD5_BYTES", ";", "i", "++", ")", "fprintf", "(", "stderr", ",", "\"", "\"", ",", "verify", ".", "md5", "[", "i", "]", ")", ";", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "if", "(", "param", ")", "{", "memcpy", "(", "header", ".", "md5", ",", "verify", ".", "md5", ",", "sizeof", "(", "header", ".", "md5", ")", ")", ";", "fixed", "=", "TRUE", ";", "}", "}", "}", "if", "(", "header", ".", "version", ">=", "3", ")", "{", "if", "(", "memcmp", "(", "header", ".", "sha1", ",", "verify", ".", "sha1", ",", "sizeof", "(", "header", ".", "sha1", ")", ")", "==", "0", ")", "printf", "(", "\"", "\\n", "\"", ")", ";", "else", "{", "fprintf", "(", "stderr", ",", "\"", "\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CHD_SHA1_BYTES", ";", "i", "++", ")", "fprintf", "(", "stderr", ",", "\"", "\"", ",", "header", ".", "sha1", "[", "i", "]", ")", ";", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "fprintf", "(", "stderr", ",", "\"", "\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CHD_SHA1_BYTES", ";", "i", "++", ")", "fprintf", "(", "stderr", ",", "\"", "\"", ",", "verify", ".", "sha1", "[", "i", "]", ")", ";", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "if", "(", "param", ")", "{", "memcpy", "(", "header", ".", "sha1", ",", "verify", ".", "sha1", ",", "sizeof", "(", "header", ".", "sha1", ")", ")", ";", "fixed", "=", "TRUE", ";", "}", "if", "(", "header", ".", "version", ">=", "4", ")", "{", "if", "(", "memcmp", "(", "header", ".", "rawsha1", ",", "verify", ".", "rawsha1", ",", "sizeof", "(", "header", ".", "rawsha1", ")", ")", "!=", "0", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CHD_SHA1_BYTES", ";", "i", "++", ")", "fprintf", "(", "stderr", ",", "\"", "\"", ",", "header", ".", "rawsha1", "[", "i", "]", ")", ";", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "fprintf", "(", "stderr", ",", "\"", "\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CHD_SHA1_BYTES", ";", "i", "++", ")", "fprintf", "(", "stderr", ",", "\"", "\"", ",", "verify", ".", "rawsha1", "[", "i", "]", ")", ";", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "if", "(", "param", ")", "{", "memcpy", "(", "header", ".", "rawsha1", ",", "verify", ".", "rawsha1", ",", "sizeof", "(", "header", ".", "rawsha1", ")", ")", ";", "fixed", "=", "TRUE", ";", "}", "}", "}", "}", "}", "chd_close", "(", "chd", ")", ";", "chd", "=", "NULL", ";", "if", "(", "fixed", ")", "{", "err", "=", "chd_set_header", "(", "inputfile", ",", "&", "header", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "else", "printf", "(", "\"", "\\n", "\"", ")", ";", "}", "cleanup", ":", "if", "(", "chd", "!=", "NULL", ")", "chd_close", "(", "chd", ")", ";", "return", "(", "err", "!=", "CHDERR_NONE", ")", ";", "}" ]

[ "do_verify", "-", "validate", "the", "MD5", "/", "SHA1", "on", "a", "drive", "image" ]

[ "/* require 3 args total */", "/* extract the data */", "/* print some info */", "/* open the CHD file */", "/* verify the CHD data */", "/* progress */", "/* verify the data */", "/* finish it */", "/* handle errors */", "/* verify the MD5 */", "/* fix it */", "/* verify the SHA1 */", "/* fix it */", "/* verify the raw SHA1 */", "/* fix it */", "/* close the drive */", "/* update the header */", "/* close everything down */" ]

[ { "param": "argc", "type": "int" }, { "param": "argv", "type": "char" }, { "param": "param", "type": "int" } ]

[ "Unlicense" ]

[ "merge", "a", "parent", "and", "its", "child", "together", "(", "also", "works", "for", "update", "&", "chomp", ")" ]

[ "static", "int", "do_merge_update_chomp", "(", "int", "argc", ",", "char", "*", "argv", "[", "]", ",", "int", "param", ")", "{", "const", "char", "*", "parentfile", ",", "*", "inputfile", ",", "*", "outputfile", ";", "const", "chd_header", "*", "inputheader", ";", "chd_file", "*", "parentchd", "=", "NULL", ";", "chd_file", "*", "outputchd", "=", "NULL", ";", "chd_file", "*", "inputchd", "=", "NULL", ";", "UINT32", "maxhunk", "=", "~", "0", ";", "chd_error", "err", ";", "if", "(", "param", "==", "OPERATION_UPDATE", "&&", "argc", "!=", "4", ")", "return", "usage", "(", ")", ";", "if", "(", "(", "param", "==", "OPERATION_MERGE", "||", "param", "==", "OPERATION_CHOMP", ")", "&&", "argc", "!=", "5", ")", "return", "usage", "(", ")", ";", "if", "(", "param", "==", "OPERATION_MERGE", ")", "{", "parentfile", "=", "argv", "[", "2", "]", ";", "inputfile", "=", "argv", "[", "3", "]", ";", "outputfile", "=", "argv", "[", "4", "]", ";", "}", "else", "{", "parentfile", "=", "NULL", ";", "inputfile", "=", "argv", "[", "2", "]", ";", "outputfile", "=", "argv", "[", "3", "]", ";", "if", "(", "param", "==", "OPERATION_CHOMP", ")", "maxhunk", "=", "atoi", "(", "argv", "[", "4", "]", ")", ";", "}", "if", "(", "parentfile", "!=", "NULL", ")", "{", "printf", "(", "\"", "\\n", "\"", ",", "parentfile", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "inputfile", ")", ";", "}", "else", "printf", "(", "\"", "\\n", "\"", ",", "inputfile", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "outputfile", ")", ";", "if", "(", "param", "==", "OPERATION_CHOMP", ")", "printf", "(", "\"", "\\n", "\"", ",", "maxhunk", ")", ";", "if", "(", "parentfile", "!=", "NULL", ")", "{", "err", "=", "chd_open", "(", "parentfile", ",", "CHD_OPEN_READ", ",", "NULL", ",", "&", "parentchd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "parentfile", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "}", "err", "=", "chd_open", "(", "inputfile", ",", "CHD_OPEN_READ", ",", "parentchd", ",", "&", "inputchd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "inputfile", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "inputheader", "=", "chd_get_header", "(", "inputchd", ")", ";", "#if", "ENABLE_CUSTOM_CHOMP", "\n", "if", "(", "param", "==", "OPERATION_CHOMP", "&&", "maxhunk", "==", "0", ")", "if", "(", "handle_custom_chomp", "(", "argv", "[", "4", "]", ",", "inputchd", ",", "&", "maxhunk", ")", "!=", "CHDERR_NONE", ")", "return", "1", ";", "#endif", "err", "=", "chd_create", "(", "outputfile", ",", "inputheader", "->", "logicalbytes", ",", "inputheader", "->", "hunkbytes", ",", "inputheader", "->", "compression", ",", "NULL", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chd_open", "(", "outputfile", ",", "CHD_OPEN_READWRITE", ",", "NULL", ",", "&", "outputchd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chdman_clone_metadata", "(", "inputchd", ",", "outputchd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chdman_compress_chd", "(", "outputchd", ",", "inputchd", ",", "(", "param", "==", "OPERATION_CHOMP", ")", "?", "(", "maxhunk", "+", "1", ")", ":", "0", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "cleanup", ":", "if", "(", "outputchd", "!=", "NULL", ")", "chd_close", "(", "outputchd", ")", ";", "if", "(", "inputchd", "!=", "NULL", ")", "chd_close", "(", "inputchd", ")", ";", "if", "(", "parentchd", "!=", "NULL", ")", "chd_close", "(", "parentchd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "osd_rmfile", "(", "outputfile", ")", ";", "return", "(", "err", "!=", "CHDERR_NONE", ")", ";", "}" ]

[ "do_merge_update_chomp", "-", "merge", "a", "parent", "and", "its", "child", "together", "(", "also", "works", "for", "update", "&", "chomp", ")" ]

[ "/* require 4-5 args total */", "/* extract the data */", "/* print some info */", "/* open the parent CHD */", "/* open the diff CHD */", "/* if we're chomping with a auto parameter, now is the time to figure it out */", "/* create the new merged CHD */", "/* open the new CHD */", "/* clone the metadata from the input file (which should have inherited from the parent) */", "/* do the compression; our interface will route reads for us */", "/* close everything down */" ]

[ { "param": "argc", "type": "int" }, { "param": "argv", "type": "char" }, { "param": "param", "type": "int" } ]

[ "Unlicense" ]

[ "generate", "a", "difference", "between", "two", "CHD", "files" ]

[ "static", "int", "do_diff", "(", "int", "argc", ",", "char", "*", "argv", "[", "]", ",", "int", "param", ")", "{", "const", "char", "*", "parentfile", "=", "NULL", ",", "*", "inputfile", "=", "NULL", ",", "*", "outputfile", "=", "NULL", ";", "chd_file", "*", "parentchd", "=", "NULL", ";", "chd_file", "*", "outputchd", "=", "NULL", ";", "chd_file", "*", "inputchd", "=", "NULL", ";", "chd_error", "err", ";", "if", "(", "argc", "!=", "5", ")", "return", "usage", "(", ")", ";", "parentfile", "=", "argv", "[", "2", "]", ";", "inputfile", "=", "argv", "[", "3", "]", ";", "outputfile", "=", "argv", "[", "4", "]", ";", "printf", "(", "\"", "\\n", "\"", ",", "parentfile", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "inputfile", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "outputfile", ")", ";", "err", "=", "chd_open", "(", "parentfile", ",", "CHD_OPEN_READ", ",", "NULL", ",", "&", "parentchd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "parentfile", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chd_open", "(", "inputfile", ",", "CHD_OPEN_READ", ",", "NULL", ",", "&", "inputchd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "inputfile", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chd_create", "(", "outputfile", ",", "0", ",", "0", ",", "chd_get_header", "(", "parentchd", ")", "->", "compression", ",", "parentchd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chd_open", "(", "outputfile", ",", "CHD_OPEN_READWRITE", ",", "parentchd", ",", "&", "outputchd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chdman_compress_chd", "(", "outputchd", ",", "inputchd", ",", "0", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "cleanup", ":", "if", "(", "outputchd", "!=", "NULL", ")", "chd_close", "(", "outputchd", ")", ";", "if", "(", "inputchd", "!=", "NULL", ")", "chd_close", "(", "inputchd", ")", ";", "if", "(", "parentchd", "!=", "NULL", ")", "chd_close", "(", "parentchd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "osd_rmfile", "(", "outputfile", ")", ";", "return", "(", "err", "!=", "CHDERR_NONE", ")", ";", "}" ]

[ "do_diff", "-", "generate", "a", "difference", "between", "two", "CHD", "files" ]

[ "/* require 5 args total */", "/* extract the data */", "/* print some info */", "/* open the soon-to-be-parent CHD */", "/* open the input CHD */", "/* create the new CHD as a diff against the parent */", "/* open the new CHD */", "/* do the compression; our interface will route reads for us */", "/* close everything down */" ]

[ { "param": "argc", "type": "int" }, { "param": "argv", "type": "char" }, { "param": "param", "type": "int" } ]

[ "Unlicense" ]

[ "change", "the", "CHS", "values", "on", "a", "hard", "disk", "image" ]

[ "static", "int", "do_setchs", "(", "int", "argc", ",", "char", "*", "argv", "[", "]", ",", "int", "param", ")", "{", "int", "oldcyls", ",", "oldhds", ",", "oldsecs", ",", "oldsecsize", ";", "UINT8", "was_readonly", "=", "FALSE", ";", "UINT64", "old_logicalbytes", ";", "const", "char", "*", "inoutfile", ";", "chd_file", "*", "chd", "=", "NULL", ";", "int", "cyls", ",", "hds", ",", "secs", ";", "char", "metadata", "[", "256", "]", ";", "chd_header", "header", ";", "chd_error", "err", ";", "if", "(", "argc", "!=", "6", ")", "return", "usage", "(", ")", ";", "inoutfile", "=", "argv", "[", "2", "]", ";", "cyls", "=", "atoi", "(", "argv", "[", "3", "]", ")", ";", "hds", "=", "atoi", "(", "argv", "[", "4", "]", ")", ";", "secs", "=", "atoi", "(", "argv", "[", "5", "]", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "inoutfile", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "cyls", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "hds", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "secs", ")", ";", "err", "=", "chd_open", "(", "inoutfile", ",", "CHD_OPEN_READ", ",", "NULL", ",", "&", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "inoutfile", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "header", "=", "*", "chd_get_header", "(", "chd", ")", ";", "chd_close", "(", "chd", ")", ";", "chd", "=", "NULL", ";", "if", "(", "!", "(", "header", ".", "flags", "&", "CHDFLAGS_IS_WRITEABLE", ")", ")", "{", "was_readonly", "=", "TRUE", ";", "header", ".", "flags", "|=", "CHDFLAGS_IS_WRITEABLE", ";", "err", "=", "chd_set_header", "(", "inoutfile", ",", "&", "header", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "}", "err", "=", "chd_open", "(", "inoutfile", ",", "CHD_OPEN_READWRITE", ",", "NULL", ",", "&", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "inoutfile", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "err", "=", "chd_get_metadata", "(", "chd", ",", "HARD_DISK_METADATA_TAG", ",", "0", ",", "metadata", ",", "sizeof", "(", "metadata", ")", ",", "NULL", ",", "NULL", ",", "NULL", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", "||", "sscanf", "(", "metadata", ",", "HARD_DISK_METADATA_FORMAT", ",", "&", "oldcyls", ",", "&", "oldhds", ",", "&", "oldsecs", ",", "&", "oldsecsize", ")", "!=", "4", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "inoutfile", ")", ";", "err", "=", "CHDERR_INVALID_FILE", ";", "goto", "cleanup", ";", "}", "sprintf", "(", "metadata", ",", "HARD_DISK_METADATA_FORMAT", ",", "cyls", ",", "hds", ",", "secs", ",", "oldsecsize", ")", ";", "err", "=", "chd_set_metadata", "(", "chd", ",", "HARD_DISK_METADATA_TAG", ",", "0", ",", "metadata", ",", "strlen", "(", "metadata", ")", "+", "1", ",", "CHD_MDFLAGS_CHECKSUM", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "header", "=", "*", "chd_get_header", "(", "chd", ")", ";", "old_logicalbytes", "=", "header", ".", "logicalbytes", ";", "header", ".", "logicalbytes", "=", "(", "UINT64", ")", "cyls", "*", "(", "UINT64", ")", "hds", "*", "(", "UINT64", ")", "secs", "*", "(", "UINT64", ")", "oldsecsize", ";", "chd_close", "(", "chd", ")", ";", "chd", "=", "NULL", ";", "if", "(", "was_readonly", ")", "header", ".", "flags", "&=", "~", "CHDFLAGS_IS_WRITEABLE", ";", "if", "(", "header", ".", "logicalbytes", "!=", "old_logicalbytes", "||", "was_readonly", ")", "{", "err", "=", "chd_set_header", "(", "inoutfile", ",", "&", "header", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "}", "if", "(", "header", ".", "logicalbytes", "<", "old_logicalbytes", ")", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "else", "if", "(", "header", ".", "logicalbytes", ">", "old_logicalbytes", ")", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "cleanup", ":", "if", "(", "chd", "!=", "NULL", ")", "chd_close", "(", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", "&&", "was_readonly", ")", "{", "header", ".", "flags", "&=", "~", "CHDFLAGS_IS_WRITEABLE", ";", "chd_set_header", "(", "inoutfile", ",", "&", "header", ")", ";", "}", "return", "(", "err", "!=", "CHDERR_NONE", ")", ";", "}" ]

[ "do_setchs", "-", "change", "the", "CHS", "values", "on", "a", "hard", "disk", "image" ]

[ "/* require 6 args total */", "/* extract the data */", "/* print some info */", "/* open the file read-only and get the header */", "/* if the drive is not writeable, note that, and make it so */", "/* write the new header */", "/* open the file read/write */", "/* get the hard disk metadata */", "/* write our own */", "/* get the header and compute the new logical size */", "/* close the file */", "/* restore the read-only state */", "/* set the new logical size */", "/* print a warning if the size is different */" ]

[ { "param": "argc", "type": "int" }, { "param": "argv", "type": "char" }, { "param": "param", "type": "int" } ]

[ "Unlicense" ]

[ "add", "metadata", "to", "a", "CHD", "from", "a", "file" ]

[ "static", "int", "do_addmeta", "(", "int", "argc", ",", "char", "*", "argv", "[", "]", ",", "int", "param", ")", "{", "const", "char", "*", "inoutfile", ",", "*", "srcfile", ",", "*", "tagstring", ";", "UINT8", "was_readonly", "=", "FALSE", ";", "UINT8", "*", "metadata", "=", "NULL", ";", "chd_file", "*", "chd", "=", "NULL", ";", "chd_header", "header", ";", "file_error", "filerr", ";", "UINT32", "metalength", ";", "UINT32", "metaindex", ";", "UINT32", "metatag", ";", "chd_error", "err", ";", "if", "(", "argc", "!=", "5", "&&", "argc", "!=", "6", ")", "return", "usage", "(", ")", ";", "inoutfile", "=", "argv", "[", "2", "]", ";", "tagstring", "=", "argv", "[", "3", "]", ";", "if", "(", "argc", "==", "5", ")", "{", "metaindex", "=", "0", ";", "srcfile", "=", "argv", "[", "4", "]", ";", "}", "else", "{", "metaindex", "=", "atoi", "(", "argv", "[", "4", "]", ")", ";", "srcfile", "=", "argv", "[", "5", "]", ";", "}", "if", "(", "strlen", "(", "tagstring", ")", ">", "4", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "tagstring", ")", ";", "return", "CHDERR_INVALID_PARAMETER", ";", "}", "metatag", "=", "(", "(", "tagstring", "[", "0", "]", "==", "0", ")", "?", "'", "'", ":", "tagstring", "[", "0", "]", ")", "<<", "24", ";", "metatag", "|=", "(", "(", "tagstring", "[", "1", "]", "==", "0", ")", "?", "'", "'", ":", "tagstring", "[", "1", "]", ")", "<<", "16", ";", "metatag", "|=", "(", "(", "tagstring", "[", "2", "]", "==", "0", ")", "?", "'", "'", ":", "tagstring", "[", "2", "]", ")", "<<", "8", ";", "metatag", "|=", "(", "(", "tagstring", "[", "3", "]", "==", "0", ")", "?", "'", "'", ":", "tagstring", "[", "3", "]", ")", "<<", "0", ";", "printf", "(", "\"", "\\n", "\"", ",", "inoutfile", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "(", "metatag", ">>", "24", ")", "&", "0xff", ",", "(", "metatag", ">>", "16", ")", "&", "0xff", ",", "(", "metatag", ">>", "8", ")", "&", "0xff", ",", "metatag", "&", "0xff", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "metaindex", ")", ";", "printf", "(", "\"", "\\n", "\"", ",", "srcfile", ")", ";", "err", "=", "chd_open", "(", "inoutfile", ",", "CHD_OPEN_READ", ",", "NULL", ",", "&", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "inoutfile", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "header", "=", "*", "chd_get_header", "(", "chd", ")", ";", "chd_close", "(", "chd", ")", ";", "chd", "=", "NULL", ";", "if", "(", "!", "(", "header", ".", "flags", "&", "CHDFLAGS_IS_WRITEABLE", ")", ")", "{", "was_readonly", "=", "TRUE", ";", "header", ".", "flags", "|=", "CHDFLAGS_IS_WRITEABLE", ";", "err", "=", "chd_set_header", "(", "inoutfile", ",", "&", "header", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "}", "err", "=", "chd_open", "(", "inoutfile", ",", "CHD_OPEN_READWRITE", ",", "NULL", ",", "&", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "inoutfile", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "filerr", "=", "core_fload", "(", "srcfile", ",", "(", "void", "*", "*", ")", "&", "metadata", ",", "&", "metalength", ")", ";", "if", "(", "filerr", "!=", "FILERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "srcfile", ")", ";", "err", "=", "CHDERR_FILE_NOT_FOUND", ";", "goto", "cleanup", ";", "}", "if", "(", "param", ")", "{", "metadata", "=", "(", "UINT8", "*", ")", "realloc", "(", "metadata", ",", "metalength", "+", "1", ")", ";", "if", "(", "metadata", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "err", "=", "CHDERR_OUT_OF_MEMORY", ";", "goto", "cleanup", ";", "}", "metadata", "[", "metalength", "++", "]", "=", "0", ";", "while", "(", "metalength", ">", "0", "&&", "(", "metadata", "[", "metalength", "-", "2", "]", "==", "0x0a", "||", "metadata", "[", "metalength", "-", "2", "]", "==", "0x0d", "||", "metadata", "[", "metalength", "-", "2", "]", "==", "0x1a", ")", ")", "metadata", "[", "--", "metalength", "]", "=", "0", ";", "}", "err", "=", "chd_set_metadata", "(", "chd", ",", "metatag", ",", "metaindex", ",", "metadata", ",", "metalength", ",", "CHD_MDFLAGS_CHECKSUM", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "goto", "cleanup", ";", "}", "header", "=", "*", "chd_get_header", "(", "chd", ")", ";", "chd_close", "(", "chd", ")", ";", "chd", "=", "NULL", ";", "if", "(", "was_readonly", ")", "{", "header", ".", "flags", "&=", "~", "CHDFLAGS_IS_WRITEABLE", ";", "err", "=", "chd_set_header", "(", "inoutfile", ",", "&", "header", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "chd_error_string", "(", "err", ")", ")", ";", "}", "if", "(", "err", "==", "CHDERR_NONE", ")", "printf", "(", "\"", "\\n", "\"", ",", "param", "?", "\"", "\"", ":", "\"", "\"", ")", ";", "cleanup", ":", "if", "(", "metadata", "!=", "NULL", ")", "free", "(", "metadata", ")", ";", "if", "(", "chd", "!=", "NULL", ")", "chd_close", "(", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", "&&", "was_readonly", ")", "{", "header", ".", "flags", "&=", "~", "CHDFLAGS_IS_WRITEABLE", ";", "chd_set_header", "(", "inoutfile", ",", "&", "header", ")", ";", "}", "return", "(", "err", "!=", "CHDERR_NONE", ")", ";", "}" ]

[ "do_addmeta", "-", "add", "metadata", "to", "a", "CHD", "from", "a", "file" ]

[ "/* require 5 or 6 args total */", "/* extract the data */", "/* verify the tag */", "/* print some info */", "/* open the file read-only and get the header */", "/* if the drive is not writeable, note that, and make it so */", "/* write the new header */", "/* open the file read/write */", "/* attempt to open the source file */", "/* if it's text, strip any trailing Ctrl-Z and CR/LF and add a trailing NULL */", "/* write the new metadata */", "/* close the file */", "/* restore the read-only state */" ]

[ { "param": "argc", "type": "int" }, { "param": "argv", "type": "char" }, { "param": "param", "type": "int" } ]

[ "Unlicense" ]

[ "compress", "a", "regular", "file", "via", "the", "compression", "interfaces" ]

[ "static", "chd_error", "chdman_compress_file", "(", "chd_file", "*", "chd", ",", "const", "char", "*", "rawfile", ",", "UINT32", "offset", ")", "{", "core_file", "*", "sourcefile", ";", "const", "chd_header", "*", "header", ";", "UINT64", "sourceoffset", "=", "0", ";", "UINT8", "*", "cache", "=", "NULL", ";", "double", "ratio", "=", "1.0", ";", "file_error", "filerr", ";", "chd_error", "err", ";", "int", "hunknum", ";", "filerr", "=", "core_fopen", "(", "rawfile", ",", "OPEN_FLAG_READ", ",", "&", "sourcefile", ")", ";", "if", "(", "filerr", "!=", "FILERR_NONE", ")", "{", "err", "=", "CHDERR_FILE_NOT_FOUND", ";", "goto", "cleanup", ";", "}", "header", "=", "chd_get_header", "(", "chd", ")", ";", "cache", "=", "(", "UINT8", "*", ")", "malloc", "(", "header", "->", "hunkbytes", ")", ";", "if", "(", "cache", "==", "NULL", ")", "{", "err", "=", "CHDERR_OUT_OF_MEMORY", ";", "goto", "cleanup", ";", "}", "err", "=", "chd_compress_begin", "(", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "goto", "cleanup", ";", "for", "(", "hunknum", "=", "0", ";", "hunknum", "<", "header", "->", "totalhunks", ";", "hunknum", "++", ")", "{", "UINT32", "bytesread", ";", "progress", "(", "hunknum", "==", "0", ",", "\"", "\\r", "\"", ",", "hunknum", ",", "header", "->", "totalhunks", ",", "(", "int", ")", "(", "100.0", "*", "ratio", ")", ")", ";", "core_fseek", "(", "sourcefile", ",", "sourceoffset", "+", "offset", ",", "SEEK_SET", ")", ";", "bytesread", "=", "core_fread", "(", "sourcefile", ",", "cache", ",", "header", "->", "hunkbytes", ")", ";", "if", "(", "bytesread", "<", "header", "->", "hunkbytes", ")", "memset", "(", "&", "cache", "[", "bytesread", "]", ",", "0", ",", "header", "->", "hunkbytes", "-", "bytesread", ")", ";", "err", "=", "chd_compress_hunk", "(", "chd", ",", "cache", ",", "&", "ratio", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "goto", "cleanup", ";", "sourceoffset", "+=", "header", "->", "hunkbytes", ";", "}", "err", "=", "chd_compress_finish", "(", "chd", ",", "TRUE", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "goto", "cleanup", ";", "progress", "(", "TRUE", ",", "\"", "\\n", "\"", ",", "(", "int", ")", "(", "100.0", "*", "ratio", ")", ")", ";", "cleanup", ":", "if", "(", "sourcefile", "!=", "NULL", ")", "core_fclose", "(", "sourcefile", ")", ";", "if", "(", "cache", "!=", "NULL", ")", "free", "(", "cache", ")", ";", "return", "err", ";", "}" ]

[ "chdman_compress_file", "-", "compress", "a", "regular", "file", "via", "the", "compression", "interfaces" ]

[ "/* open the raw file */", "/* get the header */", "/* begin compressing */", "/* loop over source hunks until we run out */", "/* progress */", "/* read the data */", "/* append the data */", "/* prepare for the next hunk */", "/* finish compression */", "/* final progress update */" ]

[ { "param": "chd", "type": "chd_file" }, { "param": "rawfile", "type": "char" }, { "param": "offset", "type": "UINT32" } ]

[ "Unlicense" ]

[ "(", "re", ")", "compress", "a", "CHD", "file", "via", "the", "compression", "interfaces" ]

[ "static", "chd_error", "chdman_compress_chd", "(", "chd_file", "*", "chd", ",", "chd_file", "*", "source", ",", "UINT32", "totalhunks", ")", "{", "const", "chd_header", "*", "source_header", ";", "const", "chd_header", "*", "header", ";", "UINT8", "*", "source_cache", "=", "NULL", ";", "UINT64", "source_offset", "=", "0", ";", "UINT32", "source_bytes", "=", "0", ";", "UINT8", "*", "cache", "=", "NULL", ";", "double", "ratio", "=", "1.0", ";", "chd_error", "err", ",", "verifyerr", ";", "int", "hunknum", ";", "header", "=", "chd_get_header", "(", "chd", ")", ";", "cache", "=", "(", "UINT8", "*", ")", "malloc", "(", "header", "->", "hunkbytes", ")", ";", "if", "(", "cache", "==", "NULL", ")", "{", "err", "=", "CHDERR_OUT_OF_MEMORY", ";", "goto", "cleanup", ";", "}", "source_header", "=", "chd_get_header", "(", "source", ")", ";", "source_cache", "=", "(", "UINT8", "*", ")", "malloc", "(", "source_header", "->", "hunkbytes", ")", ";", "if", "(", "source_cache", "==", "NULL", ")", "{", "err", "=", "CHDERR_OUT_OF_MEMORY", ";", "goto", "cleanup", ";", "}", "err", "=", "chd_compress_begin", "(", "chd", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "goto", "cleanup", ";", "verifyerr", "=", "chd_verify_begin", "(", "source", ")", ";", "if", "(", "totalhunks", "==", "0", ")", "totalhunks", "=", "source_header", "->", "totalhunks", ";", "for", "(", "hunknum", "=", "0", ";", "hunknum", "<", "totalhunks", ";", "hunknum", "++", ")", "{", "UINT32", "bytesremaining", "=", "header", "->", "hunkbytes", ";", "UINT8", "*", "dest", "=", "cache", ";", "progress", "(", "hunknum", "==", "0", ",", "\"", "\\r", "\"", ",", "hunknum", ",", "totalhunks", ",", "(", "int", ")", "(", "100.0", "*", "ratio", ")", ")", ";", "while", "(", "bytesremaining", ">", "0", ")", "{", "if", "(", "source_bytes", ">", "0", ")", "{", "UINT32", "bytestocopy", "=", "MIN", "(", "bytesremaining", ",", "source_bytes", ")", ";", "memcpy", "(", "dest", ",", "&", "source_cache", "[", "source_header", "->", "hunkbytes", "-", "source_bytes", "]", ",", "bytestocopy", ")", ";", "dest", "+=", "bytestocopy", ";", "source_bytes", "-=", "bytestocopy", ";", "bytesremaining", "-=", "bytestocopy", ";", "}", "else", "{", "if", "(", "verifyerr", "==", "CHDERR_NONE", ")", "err", "=", "chd_verify_hunk", "(", "source", ")", ";", "err", "=", "chd_read", "(", "source", ",", "source_offset", "/", "source_header", "->", "hunkbytes", ",", "source_cache", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "memset", "(", "source_cache", ",", "0", ",", "source_header", "->", "hunkbytes", ")", ";", "source_bytes", "=", "source_header", "->", "hunkbytes", ";", "source_offset", "+=", "source_bytes", ";", "}", "}", "err", "=", "chd_compress_hunk", "(", "chd", ",", "cache", ",", "&", "ratio", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "goto", "cleanup", ";", "}", "if", "(", "verifyerr", "==", "CHDERR_NONE", "&&", "source_offset", ">=", "source_header", "->", "logicalbytes", ")", "{", "static", "const", "UINT8", "empty_checksum", "[", "CHD_SHA1_BYTES", "]", "=", "{", "0", "}", ";", "chd_verify_result", "verify", ";", "int", "i", ";", "err", "=", "chd_verify_finish", "(", "source", ",", "&", "verify", ")", ";", "if", "(", "memcmp", "(", "source_header", "->", "md5", ",", "empty_checksum", ",", "CHD_MD5_BYTES", ")", "!=", "0", ")", "{", "if", "(", "memcmp", "(", "source_header", "->", "md5", ",", "verify", ".", "md5", ",", "CHD_MD5_BYTES", ")", "!=", "0", ")", "{", "progress", "(", "TRUE", ",", "\"", "\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CHD_MD5_BYTES", ";", "i", "++", ")", "progress", "(", "TRUE", ",", "\"", "\"", ",", "source_header", "->", "md5", "[", "i", "]", ")", ";", "progress", "(", "TRUE", ",", "\"", "\\n", "\"", ")", ";", "progress", "(", "TRUE", ",", "\"", "\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CHD_MD5_BYTES", ";", "i", "++", ")", "progress", "(", "TRUE", ",", "\"", "\"", ",", "verify", ".", "md5", "[", "i", "]", ")", ";", "progress", "(", "TRUE", ",", "\"", "\\n", "\"", ")", ";", "}", "else", "progress", "(", "TRUE", ",", "\"", "\\n", "\"", ")", ";", "}", "if", "(", "memcmp", "(", "source_header", "->", "sha1", ",", "empty_checksum", ",", "CHD_SHA1_BYTES", ")", "!=", "0", ")", "{", "if", "(", "memcmp", "(", "source_header", "->", "sha1", ",", "verify", ".", "sha1", ",", "CHD_SHA1_BYTES", ")", "!=", "0", ")", "{", "progress", "(", "TRUE", ",", "\"", "\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CHD_SHA1_BYTES", ";", "i", "++", ")", "progress", "(", "TRUE", ",", "\"", "\"", ",", "source_header", "->", "sha1", "[", "i", "]", ")", ";", "progress", "(", "TRUE", ",", "\"", "\\n", "\"", ")", ";", "progress", "(", "TRUE", ",", "\"", "\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CHD_SHA1_BYTES", ";", "i", "++", ")", "progress", "(", "TRUE", ",", "\"", "\"", ",", "verify", ".", "sha1", "[", "i", "]", ")", ";", "progress", "(", "TRUE", ",", "\"", "\\n", "\"", ")", ";", "}", "else", "progress", "(", "TRUE", ",", "\"", "\\n", "\"", ")", ";", "}", "}", "err", "=", "chd_compress_finish", "(", "chd", ",", "!", "(", "source_header", "->", "flags", "&", "CHDFLAGS_IS_WRITEABLE", ")", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "goto", "cleanup", ";", "progress", "(", "TRUE", ",", "\"", "\\n", "\"", ",", "(", "int", ")", "(", "100.0", "*", "ratio", ")", ")", ";", "cleanup", ":", "if", "(", "source_cache", "!=", "NULL", ")", "free", "(", "source_cache", ")", ";", "if", "(", "cache", "!=", "NULL", ")", "free", "(", "cache", ")", ";", "return", "err", ";", "}" ]

[ "chdman_compress_chd", "-", "(", "re", ")", "compress", "a", "CHD", "file", "via", "the", "compression", "interfaces" ]

[ "/* get the header */", "/* get the source CHD header */", "/* begin compressing */", "/* also begin verifying the source driver */", "/* a zero count means the natural number */", "/* loop over source hunks until we run out */", "/* progress */", "/* read the data */", "/* if we have data in the buffer, copy it */", "/* otherwise, read in another hunk of the source */", "/* verify the next hunk */", "/* then read it (should be the same) */", "/* append the data */", "/* if we read all the source data, verify the checksums */", "/* get the final values */", "/* check the MD5 */", "/* check the SHA1 */", "/* finish compression */", "/* final progress update */" ]

[ { "param": "chd", "type": "chd_file" }, { "param": "source", "type": "chd_file" }, { "param": "totalhunks", "type": "UINT32" } ]

[ "Unlicense" ]

[ "clone", "the", "metadata", "from", "one", "CHD", "to", "a", "second" ]

[ "static", "chd_error", "chdman_clone_metadata", "(", "chd_file", "*", "source", ",", "chd_file", "*", "dest", ")", "{", "const", "chd_header", "*", "header", "=", "chd_get_header", "(", "source", ")", ";", "UINT8", "metabuffer", "[", "MAX", "(", "4096", ",", "sizeof", "(", "cdrom_toc", ")", ")", "]", ";", "UINT32", "metatag", ",", "metasize", ",", "metaindex", ";", "UINT8", "metaflags", ";", "chd_error", "err", ";", "for", "(", "metaindex", "=", "0", ";", ";", "metaindex", "++", ")", "{", "err", "=", "chd_get_metadata", "(", "source", ",", "CHDMETATAG_WILDCARD", ",", "metaindex", ",", "metabuffer", ",", "sizeof", "(", "metabuffer", ")", ",", "&", "metasize", ",", "&", "metatag", ",", "&", "metaflags", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "if", "(", "err", "==", "CHDERR_METADATA_NOT_FOUND", ")", "err", "=", "CHDERR_NONE", ";", "break", ";", "}", "if", "(", "header", "->", "version", "<=", "3", ")", "{", "if", "(", "metatag", "==", "HARD_DISK_METADATA_TAG", "||", "metatag", "==", "CDROM_OLD_METADATA_TAG", "||", "metatag", "==", "CDROM_TRACK_METADATA_TAG", "||", "metatag", "==", "AV_METADATA_TAG", "||", "metatag", "==", "AV_LD_METADATA_TAG", ")", "{", "metaflags", "|=", "CHD_MDFLAGS_CHECKSUM", ";", "}", "if", "(", "metatag", "==", "CDROM_OLD_METADATA_TAG", ")", "{", "cdrom_toc", "*", "toc", "=", "(", "cdrom_toc", "*", ")", "metabuffer", ";", "err", "=", "cdrom_parse_metadata", "(", "source", ",", "toc", ")", ";", "if", "(", "err", "==", "CHDERR_NONE", ")", "err", "=", "cdrom_write_metadata", "(", "dest", ",", "toc", ")", ";", "if", "(", "err", "==", "CHDERR_NONE", ")", "continue", ";", "}", "}", "if", "(", "metasize", "<=", "sizeof", "(", "metabuffer", ")", ")", "{", "err", "=", "chd_set_metadata", "(", "dest", ",", "metatag", ",", "CHD_METAINDEX_APPEND", ",", "metabuffer", ",", "metasize", ",", "metaflags", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "break", ";", "}", "else", "{", "UINT8", "*", "allocbuffer", "=", "(", "UINT8", "*", ")", "malloc", "(", "metasize", ")", ";", "if", "(", "allocbuffer", "==", "NULL", ")", "{", "err", "=", "CHDERR_OUT_OF_MEMORY", ";", "break", ";", "}", "err", "=", "chd_get_metadata", "(", "source", ",", "CHDMETATAG_WILDCARD", ",", "metaindex", ",", "allocbuffer", ",", "metasize", ",", "&", "metasize", ",", "&", "metatag", ",", "&", "metaflags", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "{", "free", "(", "allocbuffer", ")", ";", "break", ";", "}", "err", "=", "chd_set_metadata", "(", "dest", ",", "metatag", ",", "CHD_METAINDEX_APPEND", ",", "allocbuffer", ",", "metasize", ",", "metaflags", ")", ";", "free", "(", "allocbuffer", ")", ";", "if", "(", "err", "!=", "CHDERR_NONE", ")", "break", ";", "}", "}", "return", "err", ";", "}" ]

[ "chdman_clone_metadata", "-", "clone", "the", "metadata", "from", "one", "CHD", "to", "a", "second" ]

[ "/* clone the metadata */", "/* fetch the next piece of metadata */", "/* promote certain bits of metadata to checksummed for older CHDs */", "/* convert old-style CD-ROM data to newer */", "/* if that fit, just write it back from the temporary buffer */", "/* write it to the target */", "/* otherwise, allocate a bigger temporary buffer */", "/* re-read the whole thing */", "/* write it to the target */" ]

[ { "param": "source", "type": "chd_file" }, { "param": "dest", "type": "chd_file" } ]

[ "Unlicense" ]

[ "-", "set", "the", "base", "of", "the", "bank", "for", "a", "given", "voice", "on", "a", "given", "chip" ]

[ "void", "okim6295_set_bank_base", "(", "const", "device_config", "*", "device", ",", "int", "base", ")", "{", "okim6295_state", "*", "info", "=", "get_safe_token", "(", "device", ")", ";", "stream_update", "(", "info", "->", "stream", ")", ";", "if", "(", "info", "->", "bank_num", "==", "-1", "&&", "base", "!=", "0", ")", "{", "info", "->", "bank_num", "=", "memory_find_unused_bank", "(", "device", "->", "machine", ")", ";", "if", "(", "info", "->", "bank_num", "==", "-1", ")", "fatalerror", "(", "\"", "\"", ",", "device", "->", "tag", ")", ";", "memory_install_read8_handler", "(", "device", "->", "space", "[", "0", "]", ",", "0x00000", ",", "0x3ffff", ",", "0", ",", "0", ",", "(", "read8_space_func", ")", "SMH_BANK", "(", "info", "->", "bank_num", ")", ")", ";", "}", "if", "(", "info", "->", "bank_num", "!=", "-1", ")", "{", "info", "->", "bank_offs", "=", "base", ";", "memory_set_bankptr", "(", "device", "->", "machine", ",", "info", "->", "bank_num", ",", "device", "->", "region", "+", "base", ")", ";", "}", "}" ]

[ "okim6295_set_bank_base", "--", "set", "the", "base", "of", "the", "bank", "for", "a", "given", "voice", "on", "a", "given", "chip" ]

[ "/* if we are setting a non-zero base, and we have no bank, allocate one */", "/* override our memory map with a bank */", "/* if we have a bank number, set the base pointer */" ]

[ { "param": "device", "type": "device_config" }, { "param": "base", "type": "int" } ]

[ "Unlicense" ]

[ "-", "adjust", "pin", "7", "which", "controls", "the", "internal", "clock", "division" ]

[ "void", "okim6295_set_pin7", "(", "const", "device_config", "*", "device", ",", "int", "pin7", ")", "{", "okim6295_state", "*", "info", "=", "get_safe_token", "(", "device", ")", ";", "int", "divisor", "=", "pin7", "?", "132", ":", "165", ";", "stream_set_sample_rate", "(", "info", "->", "stream", ",", "info", "->", "master_clock", "/", "divisor", ")", ";", "}" ]

[ "okim6295_set_pin7", "--", "adjust", "pin", "7", "which", "controls", "the", "internal", "clock", "division" ]

[]

[ { "param": "device", "type": "device_config" }, { "param": "pin7", "type": "int" } ]

[ "Unlicense" ]

[ "LIMIT", "--", "Limiter", "function", "for", "digital", "sample", "output", "." ]

[ "static", "INT16", "limit", "(", "INT16", "s", ")", "{", "#ifdef", "HIGH_QUALITY", "if", "(", "s", ">", "8191", ")", "return", "8191", ";", "if", "(", "s", "<", "-8192", ")", "return", "-8192", ";", "#else", "if", "(", "s", ">", "127", ")", "return", "127", ";", "if", "(", "s", "<", "-128", ")", "return", "-128", ";", "#endif", "return", "s", ";", "}" ]

[ "LIMIT", "--", "Limiter", "function", "for", "digital", "sample", "output", "." ]

[ "/* Higher quality than the original, but who cares? */" ]

[ { "param": "s", "type": "INT16" } ]

[ "Unlicense" ]

[ "-", "Decode", "the", "register", "set", "in", "the", "filter", "bank", "." ]

[ "static", "void", "lpc12_regdec", "(", "struct", "lpc12_t", "*", "f", ")", "{", "int", "i", ";", "f", "->", "amp", "=", "(", "f", "->", "r", "[", "0", "]", "&", "0x1F", ")", "<<", "(", "(", "(", "f", "->", "r", "[", "0", "]", "&", "0xE0", ")", ">>", "5", ")", "+", "0", ")", ";", "f", "->", "cnt", "=", "0", ";", "f", "->", "per", "=", "f", "->", "r", "[", "1", "]", ";", "for", "(", "i", "=", "0", ";", "i", "<", "6", ";", "i", "++", ")", "{", "#define", "IQ", "(", "x", ")", " (((x) & 0x80) ? qtbl[0x7F & -(x)] : -qtbl[(x)])", "\n\n", "f", "->", "b_coef", "[", "stage_map", "[", "i", "]", "]", "=", "IQ", "(", "f", "->", "r", "[", "2", "+", "2", "*", "i", "]", ")", ";", "f", "->", "f_coef", "[", "stage_map", "[", "i", "]", "]", "=", "IQ", "(", "f", "->", "r", "[", "3", "+", "2", "*", "i", "]", ")", ";", "}", "f", "->", "interp", "=", "f", "->", "r", "[", "14", "]", "||", "f", "->", "r", "[", "15", "]", ";", "return", ";", "}" ]

[ "LPC12_REGDEC", "--", "Decode", "the", "register", "set", "in", "the", "filter", "bank", "." ]

[ "/* -------------------------------------------------------------------- */", "/* Decode the Amplitude and Period registers. Force the 'cnt' to 0 */", "/* to get an initial impulse. We compensate elsewhere by setting */", "/* the repeat count to \"repeat + 1\". */", "/* -------------------------------------------------------------------- */", "/* -------------------------------------------------------------------- */", "/* Decode the filter coefficients from the quant table. */", "/* -------------------------------------------------------------------- */", "/* -------------------------------------------------------------------- */", "/* Set the Interp flag based on whether we have interpolation parms */", "/* -------------------------------------------------------------------- */" ]

[ { "param": "f", "type": "struct lpc12_t" } ]

[ "Unlicense" ]

[ "8", "-", "bit", "data", "memory", "interface" ]

[ "static", "UINT16", "m68008_read_immediate_16", "(", "const", "address_space", "*", "space", ",", "offs_t", "address", ")", "{", "offs_t", "addr", "=", "address", ";", "return", "(", "memory_decrypted_read_byte", "(", "space", ",", "addr", ")", "<<", "8", ")", "|", "(", "memory_decrypted_read_byte", "(", "space", ",", "addr", "+", "1", ")", ")", ";", "}" ]

[ "8", "-", "bit", "data", "memory", "interface" ]

[]

[ { "param": "space", "type": "address_space" }, { "param": "address", "type": "offs_t" } ]

[ "Unlicense" ]

[ "16", "-", "bit", "data", "memory", "interface" ]

[ "static", "UINT16", "read_immediate_16", "(", "const", "address_space", "*", "space", ",", "offs_t", "address", ")", "{", "m68ki_cpu_core", "*", "m68k", "=", "get_safe_token", "(", "space", "->", "cpu", ")", ";", "return", "memory_decrypted_read_word", "(", "space", ",", "(", "address", ")", "^", "m68k", "->", "memory", ".", "opcode_xor", ")", ";", "}" ]

[ "16", "-", "bit", "data", "memory", "interface" ]

[]

[ { "param": "space", "type": "address_space" }, { "param": "address", "type": "offs_t" } ]

[ "Unlicense" ]

[ "potentially", "misaligned", "16", "-", "bit", "reads", "with", "a", "32", "-", "bit", "data", "bus", "(", "and", "24", "-", "bit", "address", "bus", ")" ]

[ "static", "UINT16", "readword_d32", "(", "const", "address_space", "*", "space", ",", "offs_t", "address", ")", "{", "UINT16", "result", ";", "if", "(", "!", "(", "address", "&", "1", ")", ")", "return", "memory_read_word_32be", "(", "space", ",", "address", ")", ";", "result", "=", "memory_read_byte_32be", "(", "space", ",", "address", ")", "<<", "8", ";", "return", "result", "|", "memory_read_byte_32be", "(", "space", ",", "address", "+", "1", ")", ";", "}" ]

[ "potentially", "misaligned", "16", "-", "bit", "reads", "with", "a", "32", "-", "bit", "data", "bus", "(", "and", "24", "-", "bit", "address", "bus", ")" ]

[]

[ { "param": "space", "type": "address_space" }, { "param": "address", "type": "offs_t" } ]

[ "Unlicense" ]

[ "potentially", "misaligned", "16", "-", "bit", "writes", "with", "a", "32", "-", "bit", "data", "bus", "(", "and", "24", "-", "bit", "address", "bus", ")" ]

[ "static", "void", "writeword_d32", "(", "const", "address_space", "*", "space", ",", "offs_t", "address", ",", "UINT16", "data", ")", "{", "if", "(", "!", "(", "address", "&", "1", ")", ")", "{", "memory_write_word_32be", "(", "space", ",", "address", ",", "data", ")", ";", "return", ";", "}", "memory_write_byte_32be", "(", "space", ",", "address", ",", "data", ">>", "8", ")", ";", "memory_write_byte_32be", "(", "space", ",", "address", "+", "1", ",", "data", ")", ";", "}" ]

[ "potentially", "misaligned", "16", "-", "bit", "writes", "with", "a", "32", "-", "bit", "data", "bus", "(", "and", "24", "-", "bit", "address", "bus", ")" ]

[]

[ { "param": "space", "type": "address_space" }, { "param": "address", "type": "offs_t" }, { "param": "data", "type": "UINT16" } ]

[ "Unlicense" ]

[ "potentially", "misaligned", "32", "-", "bit", "reads", "with", "a", "32", "-", "bit", "data", "bus", "(", "and", "24", "-", "bit", "address", "bus", ")" ]

[ "static", "UINT32", "readlong_d32", "(", "const", "address_space", "*", "space", ",", "offs_t", "address", ")", "{", "UINT32", "result", ";", "if", "(", "!", "(", "address", "&", "3", ")", ")", "return", "memory_read_dword_32be", "(", "space", ",", "address", ")", ";", "else", "if", "(", "!", "(", "address", "&", "1", ")", ")", "{", "result", "=", "memory_read_word_32be", "(", "space", ",", "address", ")", "<<", "16", ";", "return", "result", "|", "memory_read_word_32be", "(", "space", ",", "address", "+", "2", ")", ";", "}", "result", "=", "memory_read_byte_32be", "(", "space", ",", "address", ")", "<<", "24", ";", "result", "|=", "memory_read_word_32be", "(", "space", ",", "address", "+", "1", ")", "<<", "8", ";", "return", "result", "|", "memory_read_byte_32be", "(", "space", ",", "address", "+", "3", ")", ";", "}" ]

[ "potentially", "misaligned", "32", "-", "bit", "reads", "with", "a", "32", "-", "bit", "data", "bus", "(", "and", "24", "-", "bit", "address", "bus", ")" ]

[]

[ { "param": "space", "type": "address_space" }, { "param": "address", "type": "offs_t" } ]

[ "Unlicense" ]

[ "potentially", "misaligned", "32", "-", "bit", "writes", "with", "a", "32", "-", "bit", "data", "bus", "(", "and", "24", "-", "bit", "address", "bus", ")" ]

[ "static", "void", "writelong_d32", "(", "const", "address_space", "*", "space", ",", "offs_t", "address", ",", "UINT32", "data", ")", "{", "if", "(", "!", "(", "address", "&", "3", ")", ")", "{", "memory_write_dword_32be", "(", "space", ",", "address", ",", "data", ")", ";", "return", ";", "}", "else", "if", "(", "!", "(", "address", "&", "1", ")", ")", "{", "memory_write_word_32be", "(", "space", ",", "address", ",", "data", ">>", "16", ")", ";", "memory_write_word_32be", "(", "space", ",", "address", "+", "2", ",", "data", ")", ";", "return", ";", "}", "memory_write_byte_32be", "(", "space", ",", "address", ",", "data", ">>", "24", ")", ";", "memory_write_word_32be", "(", "space", ",", "address", "+", "1", ",", "data", ">>", "8", ")", ";", "memory_write_byte_32be", "(", "space", ",", "address", "+", "3", ",", "data", ")", ";", "}" ]

[ "potentially", "misaligned", "32", "-", "bit", "writes", "with", "a", "32", "-", "bit", "data", "bus", "(", "and", "24", "-", "bit", "address", "bus", ")" ]

[]

[ { "param": "space", "type": "address_space" }, { "param": "address", "type": "offs_t" }, { "param": "data", "type": "UINT32" } ]

[ "Unlicense" ]

[ "interface", "for", "32", "-", "bit", "data", "bus", "with", "PMMU", "(", "68EC020", "68020", ")" ]

[ "static", "UINT8", "read_byte_32_mmu", "(", "const", "address_space", "*", "space", ",", "offs_t", "address", ")", "{", "m68ki_cpu_core", "*", "m68k", "=", "get_safe_token", "(", "space", "->", "cpu", ")", ";", "if", "(", "m68k", "->", "pmmu_enabled", ")", "{", "address", "=", "pmmu_translate_addr", "(", "m68k", ",", "address", ")", ";", "}", "return", "memory_read_byte_32be", "(", "space", ",", "address", ")", ";", "}" ]

[ "interface", "for", "32", "-", "bit", "data", "bus", "with", "PMMU", "(", "68EC020", "68020", ")" ]

[]

[ { "param": "space", "type": "address_space" }, { "param": "address", "type": "offs_t" } ]

[ "Unlicense" ]

[ "potentially", "misaligned", "16", "-", "bit", "reads", "with", "a", "32", "-", "bit", "data", "bus", "(", "and", "24", "-", "bit", "address", "bus", ")" ]

[ "static", "UINT16", "readword_d32_mmu", "(", "const", "address_space", "*", "space", ",", "offs_t", "address", ")", "{", "m68ki_cpu_core", "*", "m68k", "=", "get_safe_token", "(", "space", "->", "cpu", ")", ";", "UINT16", "result", ";", "if", "(", "m68k", "->", "pmmu_enabled", ")", "{", "address", "=", "pmmu_translate_addr", "(", "m68k", ",", "address", ")", ";", "}", "if", "(", "!", "(", "address", "&", "1", ")", ")", "return", "memory_read_word_32be", "(", "space", ",", "address", ")", ";", "result", "=", "memory_read_byte_32be", "(", "space", ",", "address", ")", "<<", "8", ";", "return", "result", "|", "memory_read_byte_32be", "(", "space", ",", "address", "+", "1", ")", ";", "}" ]

[ "potentially", "misaligned", "16", "-", "bit", "reads", "with", "a", "32", "-", "bit", "data", "bus", "(", "and", "24", "-", "bit", "address", "bus", ")" ]

[]

[ { "param": "space", "type": "address_space" }, { "param": "address", "type": "offs_t" } ]

[ "Unlicense" ]

[ "potentially", "misaligned", "16", "-", "bit", "writes", "with", "a", "32", "-", "bit", "data", "bus", "(", "and", "24", "-", "bit", "address", "bus", ")" ]

[ "static", "void", "writeword_d32_mmu", "(", "const", "address_space", "*", "space", ",", "offs_t", "address", ",", "UINT16", "data", ")", "{", "m68ki_cpu_core", "*", "m68k", "=", "get_safe_token", "(", "space", "->", "cpu", ")", ";", "if", "(", "m68k", "->", "pmmu_enabled", ")", "{", "address", "=", "pmmu_translate_addr", "(", "m68k", ",", "address", ")", ";", "}", "if", "(", "!", "(", "address", "&", "1", ")", ")", "{", "memory_write_word_32be", "(", "space", ",", "address", ",", "data", ")", ";", "return", ";", "}", "memory_write_byte_32be", "(", "space", ",", "address", ",", "data", ">>", "8", ")", ";", "memory_write_byte_32be", "(", "space", ",", "address", "+", "1", ",", "data", ")", ";", "}" ]

[ "potentially", "misaligned", "16", "-", "bit", "writes", "with", "a", "32", "-", "bit", "data", "bus", "(", "and", "24", "-", "bit", "address", "bus", ")" ]

[]

[ { "param": "space", "type": "address_space" }, { "param": "address", "type": "offs_t" }, { "param": "data", "type": "UINT16" } ]