codeDog

#!/usr/bin/env python3
# CodeDog Program Maker
import subprocess
import sys;  sys.dont_write_bytecode = True
def _is_required_pyparsing_version(version):
    try:
        major, minor = version.split(".")[:2]
        return (int(major), int(minor)) >= (3, 3)
    except (ValueError, TypeError, AttributeError):
        return False

try:
    import pyparsing
    if not _is_required_pyparsing_version(getattr(pyparsing, "__version__", None)):
        raise ModuleNotFoundError
except ModuleNotFoundError:
    import depsResolve
    if subprocess.call(["which", "pip3"], stdout=subprocess.PIPE, stderr=subprocess.PIPE) == 0:
        depsResolve.installPyparsing()
    else:
        depsResolve.installPipPackage()
        depsResolve.installPyparsing()
    try:
        import pyparsing
    except Exception:
        print("Error attempting to reimport pyparsing")

import progSpec
import codeDogParser
import buildDog
import TestDog

##########  Library Shells
import libraryMngr
from codeGenerator import CodeGenerator
#import xlator_JavaScript
from xlator_Swift  import Xlator_Swift
from xlator_Java   import Xlator_Java
from xlator_CPP    import Xlator_CPP
from xlator_Kotlin import Xlator_Kotlin
import xlator

import re
import os
import errno
import platform
import copy
import atexit
import threading
from progSpec import cdlog, cdErr
from os.path import abspath

if sys.version_info.major < 3 or (sys.version_info.major == 3 and  sys.version_info.minor < 5):
    print("\n\nERROR: CodeDog must be used with Python 3.5 or newer\n")
    exit(1)

codeDogVersion = '2.0'

runArgs = sys.argv[1:]

if(len(runArgs) < 1):
    print("\n    usage: codeDog [-v] filename\n")
    exit(1)
arg1 = runArgs[0]
if arg1=="-v" or arg1=='--version':
    print("\n    CodeDog application compiler version "+ codeDogVersion+"\n")
    exit(1)
if arg1=="-b" or arg1=='--build':
    name = ''
    lastArg=1
    if(len(runArgs) >1 and runArgs[1][0]!='-'): name = runArgs[1]; lastArg=2
    buildDog.buildWithScons(name, runArgs[lastArg:])
    exit(1)
if arg1[0]=='-':
    print("Unsupported argument:", arg1)
    exit(1)
atexit.register(progSpec.whenExit)
codeGenerator = CodeGenerator()

def GenerateProgram(classes, buildTags, tagsList, libsToUse):
    result='No Language Generator Found for '+buildTags['Lang']
    langGenTag = buildTags['Lang']
    if(langGenTag == 'CPP'):
        langName='C + +'
        xlator = Xlator_CPP()
    elif(langGenTag == 'Java'):
        langName='J A V A'
        xlator = Xlator_Java()
    elif(langGenTag == 'Swift'):
        langName='S W I F T'
        xlator = Xlator_Swift()
    elif(langGenTag == 'Kotlin'):
        langName='K O T L I N'
        xlator = Xlator_Kotlin()
    else:
        cdErr( "ERROR: No language generator found for ".format( langGenTag))
        exit(1)
    xlator.codeGen = codeGenerator
    codeGenerator.xlator = xlator
    result=codeGenerator.generate(classes, tagsList, libsToUse, langName)
    return result
from timeit import default_timer as timer

def localCPU():
    machine = platform.machine().lower()
    if machine in ['x86_64', 'amd64']:
        return 'amd64'
    if machine in ['aarch64', 'arm64']:
        return 'arm64'
    return machine

def localPlatformTags():
    platformID = platform.system()
    if platformID == 'Linux':
        return {'Platform': 'Linux', 'CPU': localCPU(), 'Lang': 'CPP', 'LangVersion': 'GNU'}
    if platformID == 'Windows':
        return {'Platform': 'Windows', 'CPU': localCPU(), 'Lang': 'CPP', 'LangVersion': 'MSVC'}
    if platformID == 'Darwin':
        return {'Platform': 'MacOS', 'CPU': localCPU(), 'Lang': 'Swift'}
    cdErr("ERROR: Local platform '{}' is not supported.".format(platformID))

def localPlatformBuildName():
    platformID = platform.system()
    if platformID == 'Linux':
        return 'LinuxBuild'
    if platformID == 'Windows':
        return 'WindowsBuild'
    if platformID == 'Darwin':
        return 'MacBuild'
    cdErr("ERROR: Local platform '{}' is not supported.".format(platformID))

WEB_PLATFORM_DEFAULTS = {
    'Platform': 'Web',
    'CPU': 'wasm32',
    'Lang': 'CPP',
    'LangVersion': 'Emscripten',
}

def applyBuildSpecificDefaults(buildSpec):
    buildName = buildSpec[0]
    buildTags = buildSpec[1]
    platformTag = progSpec.fetchTagValue([buildTags], 'Platform')

    if isinstance(platformTag, str) and platformTag.lower() == 'web':
        for tagName, tagValue in WEB_PLATFORM_DEFAULTS.items():
            if not (tagName in buildTags):
                buildTags[tagName] = tagValue
        buildTags['Platform'] = 'Web'
        return [buildName, buildTags]

    localTags = localPlatformTags()
    if isinstance(platformTag, str) and platformTag.lower() == 'local':
        buildTags['Platform'] = localTags['Platform']
    if not ('Platform' in buildTags):
        buildTags['Platform'] = localTags['Platform']
    if not ('CPU' in buildTags):
        buildTags['CPU'] = localTags['CPU']
    if not ('Lang' in buildTags):
        buildTags['Lang'] = localTags['Lang']
    if buildTags['Lang'] == localTags['Lang'] and 'LangVersion' in localTags and not ('LangVersion' in buildTags):
        buildTags['LangVersion'] = localTags['LangVersion']
    return [buildName, buildTags]

def normalizeBuildSpecs(buildSpecs):
    if len(buildSpecs) == 0:
        buildSpecs = [[localPlatformBuildName(), localPlatformTags()]]
    return [applyBuildSpecificDefaults(buildSpec) for buildSpec in buildSpecs]

def tagListItems(tagValue):
    if isinstance(tagValue, list):
        return tagValue
    extracted = progSpec.extractListFromTagList(tagValue)
    if extracted:
        return extracted
    return []

def tagPlatformMap(tagValue):
    if isinstance(tagValue, dict):
        return tagValue
    return progSpec.extractMapFromTagMap(tagValue)

def interfaceItemsForPlatform(interfaceTags, tagName, platform):
    values = []
    if tagName in interfaceTags:
        values += tagListItems(interfaceTags[tagName])
    byPlatformName = tagName + 'ByPlatform'
    if byPlatformName in interfaceTags:
        platformMap = tagPlatformMap(interfaceTags[byPlatformName])
        if platform in platformMap:
            values += tagListItems(platformMap[platform])
    return values

def GenerateSystem(classes, buildSpecs, tags, macroDefs):
    cdlog(0, "\n######################   G E N E R A T I N G   P R O G R A M   S P E C I F I C A T I O N")
    count=0
    for buildSpec in buildSpecs:
        count+=1
        buildName=buildSpec[0]
        buildTags=buildSpec[1]
        buildTags['buildName']= buildName
        testMode=progSpec.fetchTagValue([tags, buildTags], 'testMode')
        progSpec.MarkItems=True
        if testMode=='makeTests' or testMode=='runTests':
            cdlog(1, "GENERATING: Test Program")
            testTagStore=TestDog.generateTestCode(classes, buildTags, tags, macroDefs)
            cdlog(1, "Test Program Finished")
            tagsList=[tags, buildTags, testTagStore]
        else:
            tagsList=[tags, buildTags]
        #print("BUILDTAGS:", buildTags)
        cdlog(0, "\n######################   G E N E R A T I N G   S O U R C E   C O D E   S Y S T E M   {}   o f   {}...   ({})".format(count, len(buildSpecs), buildName))
        startTime = timer()
        buildDog.buildStatus("Choosing libraries for {} ({})".format(buildName, buildTags.get('Platform', 'unknown platform')))
        libsToUse=libraryMngr.ChooseLibs(classes, buildTags, tags)
        chooseLibsTime = timer()-startTime
        buildDog.buildStatus("Selected {} library layer(s) in {:.1f}s".format(len(libsToUse), chooseLibsTime))
        print("Time Elapsed:", chooseLibsTime)
        codeGenStartTime = timer()
        buildDog.buildStatus("Generating source for {}".format(buildName))
        fileSpecs = GenerateProgram(classes, buildTags, tagsList, libsToUse)
        buildDog.buildStatus("Generated {} source file(s) in {:.1f}s".format(len(fileSpecs), timer() - codeGenStartTime))
        print("Marker: Code Gen Successful")

        #GenerateBuildSystem()###################################################
        fileName   = progSpec.fetchTagValue(tagsList, 'FileName')
        labelName  = progSpec.fetchTagValue(tagsList, 'Title')
        launchIconName = progSpec.fetchTagValue(tagsList, 'LaunchIcon')
        programOrLibrary = progSpec.fetchTagValue(tagsList, 'ProgramOrLibrary')
        langGenTag = buildTags['Lang']
        libFiles=[]
        tagsFromLibFiles = libraryMngr.getTagsFromLibFiles()
        packageData = []
        tools = []
        buildDog.buildStatus("Collecting link libraries and package requirements")
        for lib in libsToUse:
            if 'interface' in tagsFromLibFiles[lib]:
                interfaceTags = tagsFromLibFiles[lib]['interface']
                libFiles += interfaceItemsForPlatform(interfaceTags, 'libFiles', buildTags['Platform'])
                packageData += interfaceItemsForPlatform(interfaceTags, 'packages', buildTags['Platform'])
                tools += interfaceItemsForPlatform(interfaceTags, 'tools', buildTags['Platform'])

        #TODO: need debug mode and minimum version
        platform=progSpec.fetchTagValue([tags, buildTags], 'Platform')
        buildDog.buildStatus("Build inputs: {} link item(s), {} package(s), {} tool requirement(s)".format(len(libFiles), len(packageData), len(tools)))
        #cdlog(1, "\nWRITING {} FILE(S) AND COMPILING...".format(len(fileSpecs)))
        buildDog.build("-g", '14',  fileName, labelName, launchIconName, libFiles, buildName, platform, fileSpecs, programOrLibrary, packageData, tools, buildTags)
        print("Marker: Build Successful")
        progSpec.rollBack(classes, tags)
    # GenerateDocuments()


#############################################    L o a d / P a r s e   P r o g r a m   S p e c
def processMainProgram():
    cdlog(0, "\n######################   P R O C E S S I N G   M A I N   P R O G R A M   ######################")
    libraryMngr.findLibraryFiles()

    filename = abspath(os.getcwd()) + "/" + arg1
    [ProgSpec, objNames, macroDefs] = [ {}, [], {} ]
    [tagStore, buildSpecs, classes, newClasses] = codeGenerator.loadProgSpecFromDogFile(filename, ProgSpec, objNames, {}, macroDefs)
    print("Marker: Parse Successful")
    tagStore['dogFilename']=filename
    buildSpecs = normalizeBuildSpecs(buildSpecs)
    macroDefs= {}
    GenerateSystem(classes, buildSpecs, tagStore, macroDefs)
    cdlog(0, "\n######################   D O N E")
    progSpec.noError=True

threading.stack_size(67108864) # 64MB stack
sys.setrecursionlimit(5000)
thread = threading.Thread(target=processMainProgram)
thread.start()
thread.join()