int main(int argc, char* argv[])
#endif
{
WString baseDirectory;
{
#if defined VCZH_MSVC
wchar_t currentDirectory[MAX_PATH]={0};
GetCurrentDirectory(MAX_PATH, currentDirectory);
baseDirectory=currentDirectory;
#elif defined VCZHGCC
char currentDirectory[1024]={0};
getcwd(currentDirectory, 1024);
baseDirectory=atow(currentDirectory);
#endif
if(baseDirectory[baseDirectory.Length()-1]!=PATH_DELIMITER)
{
baseDirectory+=PATH_DELIMITER;
}
}
Regex regexPathSplitter(L"[///\\]");
Ptr<ParsingGeneralParser> parser=CreateBootstrapStrictParser();
Console::SetTitle(L"Vczh Parser Generator for C++");
Console::SetColor(false, true, false, true);
Console::WriteLine(L"parsing>Files : "+itow(argc-1));
for(int i=1;i<argc;i++)
{
Console::WriteLine(L"------------------------------------------------------------");
#if defined VCZH_MSVC
WString inputPath=argv[i];
#elif defined VCZH_GCC
WString inputPath=atow(argv[i]);
#endif
if(inputPath.Length()<2 || inputPath[1]!=L':')
{
inputPath=baseDirectory+inputPath;
}
Console::WriteLine(L"parsing>Making : "+inputPath);
if(inputPath.Length()<11 || inputPath.Right(11)!=L".parser.txt")
{
Console::SetColor(true, false, false, true);
Console::WriteLine(L"error> The extenion name of the input file path must be \".parser.txt\".");
Console::SetColor(false, true, false, true);
}
else
{
WString name;
{
List<Ptr<RegexMatch>> matches;
regexPathSplitter.Split(inputPath, true, matches);
name=matches[matches.Count()-1]->Result().Value();
name=name.Left(name.Length()-11);
}
WString outputMetaPath=inputPath.Left(inputPath.Length()-11);
WString outputHeaderPath=outputMetaPath+L".h";
WString outputCppPath=outputMetaPath+L".cpp";
WString logPath=outputMetaPath+L".log";
Console::WriteLine(L"parsing>Output header path : "+outputHeaderPath);
Console::WriteLine(L"parsing>Output cpp path : "+outputCppPath);
Console::WriteLine(L"parsing>Log path : "+logPath);
CodegenConfig config;
WString codeGrammar;
{
FileStream fileStream(inputPath, FileStream::ReadOnly);
if(!fileStream.IsAvailable())
{
Console::SetColor(true, false, false, true);
Console::WriteLine(L"error> Cannot open \""+inputPath+L" for read.");
Console::SetColor(false, true, false, true);
goto STOP_PARSING;
}
BomDecoder decoder;
DecoderStream decoderStream(fileStream, decoder);
StreamReader reader(decoderStream);
if(!config.ReadConfig(reader))
{
goto STOP_PARSING;
}
codeGrammar=reader.ReadToEnd();
}
Ptr<ParsingDefinition> definition;
Ptr<ParsingTable> table;
{
FileStream fileStream(logPath, FileStream::WriteOnly);
if(!fileStream.IsAvailable())
{
Console::SetColor(true, false, false, true);
Console::WriteLine(L"error> Cannot open \""+logPath+L" for write.");
Console::SetColor(false, true, false, true);
goto STOP_PARSING;
}
BomEncoder encoder(BomEncoder::Utf16);
EncoderStream encoderStream(fileStream, encoder);
StreamWriter writer(encoderStream);
if(codeGrammar==L"<bootstrap-grammar>")
{
definition=CreateParserDefinition();
MemoryStream bootstrapStream;
{
StreamWriter bootstrapWriter(bootstrapStream);
Log(definition, bootstrapWriter);
}
bootstrapStream.SeekFromBegin(0);
StreamReader bootstrapReader(bootstrapStream);
codeGrammar=bootstrapReader.ReadToEnd();
}
else
{
definition=CreateDefinition(parser, codeGrammar, writer);
}
if(!definition)
{
Console::SetColor(true, false, false, true);
Console::WriteLine(L"error> Error happened. Open \""+logPath+L" for details.");
Console::SetColor(false, true, false, true);
goto STOP_PARSING;
}
table=CreateTable(definition, writer, config.ambiguity);
if(!table)
{
Console::SetColor(true, false, false, true);
Console::WriteLine(L"error> Error happened. Open \""+logPath+L" for details.");
Console::SetColor(false, true, false, true);
goto STOP_PARSING;
}
}
{
FileStream fileStream(outputHeaderPath, FileStream::WriteOnly);
if(!fileStream.IsAvailable())
{
Console::SetColor(true, false, false, true);
Console::WriteLine(L"error> Cannot open \""+outputHeaderPath+L" for write.");
Console::SetColor(false, true, false, true);
goto STOP_PARSING;
}
BomEncoder encoder(BomEncoder::Mbcs);
EncoderStream encoderStream(fileStream, encoder);
StreamWriter writer(encoderStream);
WriteHeaderFile(name, definition, table, config, writer);
}
{
FileStream fileStream(outputCppPath, FileStream::WriteOnly);
if(!fileStream.IsAvailable())
{
Console::SetColor(true, false, false, true);
Console::WriteLine(L"error> Cannot open \""+outputCppPath+L" for write.");
Console::SetColor(false, true, false, true);
goto STOP_PARSING;
}
BomEncoder encoder(BomEncoder::Mbcs);
EncoderStream encoderStream(fileStream, encoder);
StreamWriter writer(encoderStream);
config.includes.Clear();
config.includes.Add(L"\""+name+L".h\"");
WriteCppFile(name, codeGrammar, definition, table, config, writer);
}
}
STOP_PARSING:;
}
Console::WriteLine(L"Finished!");
return 0;
}
LONG CED6AsDecompiler::DumpToFile(ED6_ACTION_SCRIPT_INFO *pAsInfo, LPWSTR pszAsFile, LPWSTR pszOutput)
{
LONG Status;
CHAR Buffer[0x400];
CFileDisk file;
Status = CreateDefinition(pszAsFile, Buffer);
AS_IF_FAIL_RETURN(Status);
Status = ASDECL_ERROR_UNKNOWN;
LOOP_ONCE
{
if (!file.Create(pszOutput))
AS_BREAK(Status, ASDECL_ERROR_CREATE_FILE);
_wsetlocale(LC_CTYPE, L"");
WriteScr(
"@_FILE \"debug_%S\"\n"
"@_INCLUDE \"%s\"\n"
"\n",
findnamew(pszAsFile), NAME_DEFINITION_FILE);
WriteScr(
"@%s %d\n"
"\n",
NAME_HEADER_UNKNOWN,
pAsInfo->Unknown);
WriteScr(
"(%s:s)\n"
"(%s:s)\n"
"(%s:s)\n"
"\n",
LABEL_CRAFT_OFFSET_TABLE,
LABEL_CRAFT_OFFSET_TABLE_END,
NAME_HEADER_UNKNOWN);
WriteScr("; Char chip pattern info CH_Index, CH_DAT_Index, CP_Index, CP_DAT_Index\n");
CHAR_CHIP_PATTERN_INFO *pChipPtn = pAsInfo->pChrChipPtnInfo;
for (ULONG Index = 0, Count = pAsInfo->ChrChipPtnCount; Count; ++Index, --Count)
{
WriteScr(
" (0x%04X:s, 0x%04X:s, 0x%04X:s, 0x%04X:s)",
pChipPtn->CHIndex,
pChipPtn->CHDatIndex,
pChipPtn->CPIndex,
pChipPtn->CPDatIndex);
++pChipPtn;
if (Index & 1)
WriteScr("\n");
}
WriteScr("\n[FF FF FF FF]\n\n");
WriteScr("; 3d model file\n");
for (LPSTR pszX3FileName = pAsInfo->pszXFileName; ; )
{
LPSTR pString;
ULONG Length;
Length = StrLengthA(pszX3FileName) + 1;
pString = *pszX3FileName == 0 ? NULL : AllocString(pszX3FileName, Length);
WriteScr("\"%s\"\n", pString == NULL ? pszX3FileName : pString);
FreeString(pString);
if (*pszX3FileName == 0)
{
if (pszX3FileName != pAsInfo->pszXFileName)
WriteScr("[%02X %02X]\n", pszX3FileName[1], pszX3FileName[2]);
break;
}
pszX3FileName += Length;
}
WriteScr("\n#%s\n", LABEL_CRAFT_OFFSET_TABLE);
ED6_AS_CRAFT_INFO *pCraft;
ED6_INSTRUCTION *pInstruction;
pCraft = pAsInfo->pCraftInfo;
for (ULONG Index = 0, Count = pAsInfo->CraftCount; Count; ++pCraft, ++Index, --Count)
{
ULONG TrueIndex;
if (pCraft->Offset == ED6_INVALID_OFFSET)
{
PBYTE p = (PBYTE)&pCraft->Offset;
WriteScr("[%02X", *p++);
for (ULONG Len = sizeof(ED6_INVALID_OFFSET) - 1; Len; --Len)
WriteScr(" %02X", *p++);
WriteScr("]\n");
continue;
}
pInstruction = UnlinkInstruction(pCraft->pInstruction);
if (pInstruction == NULL)
continue;
TrueIndex = Index;
for (ULONG i = 0; i != Index; ++i)
{
if (pInstruction->Offset == pAsInfo->pCraftInfo[i].Offset)
{
TrueIndex = i;
break;
}
}
GetCraftName(pAsInfo, TrueIndex, Buffer);
WriteScr(" (%s:s)", Buffer);
if (Index >=countof(g_szIntrinsicCraft) && (Index + 1 - countof(g_szIntrinsicCraft)) % 5 != 0)
continue;
WriteScr("\n");
}
WriteScr("\n#%s\n\n", LABEL_CRAFT_OFFSET_TABLE_END);
PBYTE pbFlags = pAsInfo->pbAsBuffer + pAsInfo->CraftOffsetTableEndOffset;
WriteScr(
"[%02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X]\n\n",
pbFlags[0], pbFlags[1], pbFlags[2], pbFlags[3], pbFlags[4],
pbFlags[5], pbFlags[6], pbFlags[7], pbFlags[8], pbFlags[9],
pbFlags[10], pbFlags[11], pbFlags[12], pbFlags[13], pbFlags[14],
pbFlags[15], pbFlags[16]);
Status = DumpCrafts(pAsInfo, file, Buffer);
AS_IF_FAIL_BREAK(Status);
Status = DumpFunctions(pAsInfo, file, Buffer);
}
return Status;
}
void CASXMLSchemaModel::IncludeSchema(Element* mergeDocumentElement)
{
// CComPtr<ILDOMDocument> ownerDocument;
// mergeDocumentElement->get_ownerDocument(&ownerDocument);
Node* child = mergeDocumentElement->get_firstChild();
while (child != NULL)
{
Node* nextSibling = child->get_nextSibling();
Element* element = dynamic_cast<Element*>(child);
if (element)
{
String tagName = element->get_tagName();
if (tagName == L"include")
{
ASSERT(0);
#if 0
CComObject<CASXMLInclude>* pEl;
CComObject<CASXMLInclude>::CreateInstance(&pEl);
if (pEl)
{
pEl->AddRef();
pEl->m_pSchema = this;
pEl->m_element = element;
CComObject<CASXMLSchemaModel>::CreateInstance(&pEl->m_asModel);
if (pEl->m_asModel)
{
pEl->m_asModel->AddRef();
m_globalElements->m_items.Add(pEl);
CComBSTR schemaLocation;
element->getAttribute(L"schemaLocation", &schemaLocation);
TCHAR absSchemaLocation[2048];
{
CComBSTR documentUrl;
ownerDocument->get_url(&documentUrl);
_bstr_t baseUrl = documentUrl;
DWORD resultLen = sizeof(absSchemaLocation);
InternetCombineUrl(baseUrl, _bstr_t(schemaLocation), absSchemaLocation, &resultLen, 0);
}
bool bloadedSchema;
pEl->m_asModel->m_xmlDocument.CoCreateInstance(CLSID_LDOMDocument);
pEl->m_asModel->m_xmlDocument->load(_variant_t(absSchemaLocation), &bloadedSchema);
if (bloadedSchema)
{
CComPtr<ILDOMElement> mergeDocumentElement;
pEl->m_asModel->m_xmlDocument->get_documentElement(&mergeDocumentElement);
if (mergeDocumentElement)
{
m_asModels->m_items.Add(pEl->m_asModel);
// AddDocument(schemadoc);
IncludeSchema(mergeDocumentElement); // Recurse
}
else
{
MessageBox(NULL, "Failed to include schema", "", MB_OK);
}
}
else
{
MessageBox(NULL, "Failed to include schema", "", MB_OK);
}
}
}
#endif
}
else
{
CDefinition/*CDefinition*/ * pDef = CreateDefinition(element);
if (pDef)
{
pDef->BuildDefs(element);
m_globalDefs.m_defs.Add(pDef);
m_globalElements->m_items.Add(dynamic_cast<IASDeclaration*>(pDef));
}
//m_schemaElement->appendChild(element, NULL);
}
}
child = nextSibling;
}
}
