#include "ResourceDefinitions.h"#include <ostream>#include <cassert> #include "ResourceCompiler.h"#include "Diagnostic.h"  std::ostream &operator<<(std::ostream &out, TypeSpec ts){    out << ts.getType();    if(ts.hasID())        out << " (" << ts.getID() << ")";    return out;}  FieldList::~FieldList(){ } void FieldList::addField(FieldPtr field, yy::location loc){    field->location = loc;    fields.push_back(field);} void FieldList::addLabel(std::string name, yy::location loc){    addField(std::make_shared<LabelField>(name), loc);} void FieldList::compile(ExprPtr expr, ResourceCompiler *compiler, bool prePass){    CompoundExprPtr compound = std::dynamic_pointer_cast<CompoundExpr>(expr);    assert(compound);     int i = 0;    for(FieldPtr f : fields)    {        if(f->needsValue())        {            if(i >= compound->size())                compiler->problem(Diagnostic(Diagnostic::error,"not enough values specified", compound->location));            else                f->compile(compound->getItem(i++), compiler, prePass);        }        else            f->compile(nullptr, compiler, prePass);    }    if(i < compound->size())    {        compiler->problem(Diagnostic(Diagnostic::error,"extra value specified",                                     compound->getItem(i)->location));    }}    void SimpleField::addNamedValue(std::string n){    if(lastNamedValue)        addNamedValue(n, std::make_shared<BinaryExpr>(            BinaryOp::PLUS, lastNamedValue, std::make_shared<IntExpr>(1, yy::location()), yy::location()));    else        addNamedValue(n, std::make_shared<IntExpr>(0, yy::location()));} void SimpleField::addNamedValue(std::string n, ExprPtr val){    namedValues[n] = val;    lastNamedValue = val;} ExprPtr SimpleField::lookupNamedValue(std::string n){    auto p = namedValues.find(n);    if(p != namedValues.end())        return p->second;    else        return nullptr;} bool SimpleField::needsValue(){    return !value;} void SimpleField::compile(ExprPtr expr, ResourceCompiler *compiler, bool prePass){    switch(type)    {        case Type::bitstring:        case Type::boolean:        case Type::byte:        case Type::integer:        case Type::longint:            compileInt(expr, compiler, prePass);            break;        case Type::string:        case Type::wstring:        case Type::pstring:        case Type::char_:            compileString(expr, compiler, prePass);            break;         case Type::rect:        case Type::point:            compileCompound(expr, compiler, prePass);            break;     }} void SimpleField::compileString(ExprPtr expr, ResourceCompiler *compiler, bool prePass){    std::string str;    {        ResourceCompiler::FieldScope scope(compiler, this);        str = (value ? value : expr)->evaluateString(compiler);    }     if(arrayCount || type == Type::char_)    {        unsigned requestedSize = type == Type::char_ ? 1 : arrayCount->evaluateInt(compiler);        if(requestedSize < str.size())            str.erase(str.begin() + requestedSize, str.end());        else if(requestedSize > str.size())            str.insert(str.end(),requestedSize - str.size(), '\0');    }     int count = str.size();     if(type == Type::pstring)    {        if(count > 255)        {            str.erase(str.begin() + 255, str.end());            count = 255;        }        compiler->write(8, count);    }    else if(type == Type::wstring)    {        if(count > 65535)        {            str.erase(str.begin() + 65535, str.end());            count = 65535;        }        compiler->write(16, count);    }     for(char c : str)        compiler->write(8, c);} void SimpleField::compileInt(ExprPtr expr, ResourceCompiler *compiler, bool prePass){    int bitSize = 0;     switch(type)    {        case Type::bitstring:            bitSize = arrayCount->evaluateInt(compiler);            break;        case Type::boolean:            bitSize = 1;            break;        case Type::byte:            bitSize = 8;            break;        case Type::integer:            bitSize = 16;            break;        case Type::longint:            bitSize = 32;            break;        default:            assert(false);    }     int actualValue = 0;    ResourceCompiler::FieldScope scope(compiler, this);    actualValue = (value ? value : expr)->evaluateInt(compiler);     compiler->write(bitSize, actualValue);} void SimpleField::compileCompound(ExprPtr expr, ResourceCompiler *compiler, bool prePass){    ExprPtr val = value ? value : expr;    if(IdentifierExprPtr id = std::dynamic_pointer_cast<IdentifierExpr>(val))    {        ResourceCompiler::FieldScope scope(compiler, this);        val = id->lookup(compiler);    }     int count = 0;    switch(type)    {        case Type::rect:            count = 4;            break;        case Type::point:            count = 2;            break;        default:            assert(false);    }     CompoundExprPtr compound = std::dynamic_pointer_cast<CompoundExpr>(val);    if(!compound || compound->size() != count)    {        expr->error(compiler, std::string("expected ") + (type == Type::rect ? "rect {t,l,b,r}." : "point {v,h}."));        return;    }    assert(compound);    assert(compound->size() == count);     for(int i = 0; i < count; i++)    {        int x = compound->getItem(i)->evaluateInt(compiler);        compiler->write(16, x);    }}  ArrayField::ArrayField(std::string name, ExprPtr count)    : name(name), arrayCount(count){} void ArrayField::compile(ExprPtr expr, ResourceCompiler *compiler, bool prePass){    CompoundExprPtr compound = std::dynamic_pointer_cast<CompoundExpr>(expr);    assert(compound);      int i = 0;    int n = compound->size();     int iterations = 0;    while(i < n)    {        ++iterations;        ResourceCompiler::ArrayScope scope(compiler, name, iterations);        for(FieldPtr f : fields)        {            if(f->needsValue())            {                assert(i < n);                f->compile(compound->getItem(i++), compiler, prePass);            }            else                f->compile(nullptr, compiler, prePass);        }    }     if(!prePass && arrayCount)    {        int expected = arrayCount->evaluateInt(compiler);        assert(expected == iterations);    }}  LabelField::LabelField(std::string name)    : name(name){} bool LabelField::needsValue(){    return false;} void LabelField::compile(ExprPtr expr, ResourceCompiler *compiler, bool prePass){    compiler->defineLabel(name);}  void SwitchField::addCase(const std::string name, FieldListPtr alternative){    cases[name] = alternative;} void SwitchField::compile(ExprPtr expr, ResourceCompiler *compiler, bool prePass){    CaseExprPtr caseExpr = std::dynamic_pointer_cast<CaseExpr>(expr);    assert(caseExpr);     FieldListPtr caseDefinition = cases[caseExpr->tag];    assert(caseDefinition);     caseDefinition->compile(caseExpr->expr, compiler, prePass);}  FillAlignField::FillAlignField(FillAlignField::Type type, bool isAlign, ExprPtr count)    : type(type), count(count), isAlign(isAlign){ } bool FillAlignField::needsValue(){    return false;} void FillAlignField::compile(ExprPtr expr, ResourceCompiler *compiler, bool prePass){    int bitSize;    switch(type)    {        case Type::bit:        bitSize = 1; break;        case Type::nibble:    bitSize = 4; break;        case Type::byte:    bitSize = 8; break;        case Type::word:    bitSize = 16; break;        case Type::long_:    bitSize = 32; break;    }     int actualCount = 1;    if(count)        actualCount = count->evaluateInt(compiler);     for(int i = 0; i < actualCount; i++)    {        int n;        if(isAlign)        {            int mask = bitSize - 1;            int pos = compiler->tell();            n = ((pos + mask) & ~mask) - pos;        }        else            n = bitSize;        compiler->write(n, 0);    }}