Compare commits
No commits in common. "main" and "c_rwr" have entirely different histories.
236
.clang-format
Normal file
236
.clang-format
Normal file
|
|
@ -0,0 +1,236 @@
|
|||
---
|
||||
Language: Cpp
|
||||
# BasedOnStyle: LLVM
|
||||
AccessModifierOffset: -4
|
||||
AlignAfterOpenBracket: Align
|
||||
AlignArrayOfStructures: None
|
||||
AlignConsecutiveAssignments:
|
||||
Enabled: false
|
||||
AcrossEmptyLines: false
|
||||
AcrossComments: false
|
||||
AlignCompound: false
|
||||
PadOperators: true
|
||||
AlignConsecutiveBitFields:
|
||||
Enabled: false
|
||||
AcrossEmptyLines: false
|
||||
AcrossComments: false
|
||||
AlignCompound: false
|
||||
PadOperators: false
|
||||
AlignConsecutiveDeclarations:
|
||||
Enabled: false
|
||||
AcrossEmptyLines: false
|
||||
AcrossComments: false
|
||||
AlignCompound: false
|
||||
PadOperators: false
|
||||
AlignConsecutiveMacros:
|
||||
Enabled: false
|
||||
AcrossEmptyLines: false
|
||||
AcrossComments: false
|
||||
AlignCompound: false
|
||||
PadOperators: false
|
||||
AlignConsecutiveShortCaseStatements:
|
||||
Enabled: false
|
||||
AcrossEmptyLines: false
|
||||
AcrossComments: false
|
||||
AlignCaseColons: false
|
||||
AlignEscapedNewlines: Left
|
||||
AlignOperands: Align
|
||||
AlignTrailingComments:
|
||||
Kind: Always
|
||||
OverEmptyLines: 0
|
||||
AllowAllArgumentsOnNextLine: true
|
||||
AllowAllParametersOfDeclarationOnNextLine: true
|
||||
AllowShortBlocksOnASingleLine: Never
|
||||
AllowShortCaseLabelsOnASingleLine: false
|
||||
AllowShortEnumsOnASingleLine: true
|
||||
AllowShortFunctionsOnASingleLine: All
|
||||
AllowShortIfStatementsOnASingleLine: WithoutElse
|
||||
AllowShortLambdasOnASingleLine: All
|
||||
AllowShortLoopsOnASingleLine: false
|
||||
AlwaysBreakAfterDefinitionReturnType: None
|
||||
AlwaysBreakAfterReturnType: None
|
||||
AlwaysBreakBeforeMultilineStrings: false
|
||||
AlwaysBreakTemplateDeclarations: Yes
|
||||
AttributeMacros:
|
||||
- __capability
|
||||
BinPackArguments: true
|
||||
BinPackParameters: true
|
||||
BitFieldColonSpacing: Both
|
||||
BraceWrapping:
|
||||
AfterCaseLabel: false
|
||||
AfterClass: false
|
||||
AfterControlStatement: Never
|
||||
AfterEnum: false
|
||||
AfterExternBlock: false
|
||||
AfterFunction: false
|
||||
AfterNamespace: false
|
||||
AfterObjCDeclaration: false
|
||||
AfterStruct: false
|
||||
AfterUnion: false
|
||||
BeforeCatch: false
|
||||
BeforeElse: false
|
||||
BeforeLambdaBody: false
|
||||
BeforeWhile: false
|
||||
IndentBraces: false
|
||||
SplitEmptyFunction: true
|
||||
SplitEmptyRecord: true
|
||||
SplitEmptyNamespace: true
|
||||
BreakAfterAttributes: Never
|
||||
BreakAfterJavaFieldAnnotations: false
|
||||
BreakArrays: true
|
||||
BreakBeforeBinaryOperators: None
|
||||
BreakBeforeConceptDeclarations: Always
|
||||
BreakBeforeBraces: Attach
|
||||
BreakBeforeInlineASMColon: OnlyMultiline
|
||||
BreakBeforeTernaryOperators: true
|
||||
BreakConstructorInitializers: BeforeColon
|
||||
BreakInheritanceList: BeforeColon
|
||||
BreakStringLiterals: true
|
||||
ColumnLimit: 160
|
||||
CommentPragmas: '^ IWYU pragma:'
|
||||
CompactNamespaces: false
|
||||
ConstructorInitializerIndentWidth: 4
|
||||
ContinuationIndentWidth: 4
|
||||
Cpp11BracedListStyle: true
|
||||
DerivePointerAlignment: false
|
||||
DisableFormat: false
|
||||
EmptyLineAfterAccessModifier: Never
|
||||
EmptyLineBeforeAccessModifier: LogicalBlock
|
||||
ExperimentalAutoDetectBinPacking: false
|
||||
FixNamespaceComments: true
|
||||
ForEachMacros:
|
||||
- foreach
|
||||
- Q_FOREACH
|
||||
- BOOST_FOREACH
|
||||
IfMacros:
|
||||
- KJ_IF_MAYBE
|
||||
IncludeBlocks: Preserve
|
||||
IncludeCategories:
|
||||
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
|
||||
Priority: 2
|
||||
SortPriority: 0
|
||||
CaseSensitive: false
|
||||
- Regex: '^(<|"(gtest|gmock|isl|json)/)'
|
||||
Priority: 3
|
||||
SortPriority: 0
|
||||
CaseSensitive: false
|
||||
- Regex: '.*'
|
||||
Priority: 1
|
||||
SortPriority: 0
|
||||
CaseSensitive: false
|
||||
IncludeIsMainRegex: '(Test)?$'
|
||||
IncludeIsMainSourceRegex: ''
|
||||
IndentAccessModifiers: false
|
||||
IndentCaseBlocks: false
|
||||
IndentCaseLabels: false
|
||||
IndentExternBlock: AfterExternBlock
|
||||
IndentGotoLabels: true
|
||||
IndentPPDirectives: None
|
||||
IndentRequiresClause: true
|
||||
IndentWidth: 4
|
||||
IndentWrappedFunctionNames: false
|
||||
InsertBraces: true
|
||||
InsertNewlineAtEOF: false
|
||||
InsertTrailingCommas: None
|
||||
IntegerLiteralSeparator:
|
||||
Binary: 0
|
||||
BinaryMinDigits: 0
|
||||
Decimal: 0
|
||||
DecimalMinDigits: 0
|
||||
Hex: 0
|
||||
HexMinDigits: 0
|
||||
JavaScriptQuotes: Leave
|
||||
JavaScriptWrapImports: true
|
||||
KeepEmptyLinesAtTheStartOfBlocks: true
|
||||
KeepEmptyLinesAtEOF: false
|
||||
LambdaBodyIndentation: Signature
|
||||
LineEnding: DeriveLF
|
||||
MacroBlockBegin: ''
|
||||
MacroBlockEnd: ''
|
||||
MaxEmptyLinesToKeep: 1
|
||||
NamespaceIndentation: All
|
||||
ObjCBinPackProtocolList: Auto
|
||||
ObjCBlockIndentWidth: 2
|
||||
ObjCBreakBeforeNestedBlockParam: true
|
||||
ObjCSpaceAfterProperty: false
|
||||
ObjCSpaceBeforeProtocolList: true
|
||||
PackConstructorInitializers: BinPack
|
||||
PenaltyBreakAssignment: 2
|
||||
PenaltyBreakBeforeFirstCallParameter: 19
|
||||
PenaltyBreakComment: 300
|
||||
PenaltyBreakFirstLessLess: 120
|
||||
PenaltyBreakOpenParenthesis: 0
|
||||
PenaltyBreakString: 1000
|
||||
PenaltyBreakTemplateDeclaration: 10
|
||||
PenaltyExcessCharacter: 1000000
|
||||
PenaltyIndentedWhitespace: 0
|
||||
PenaltyReturnTypeOnItsOwnLine: 60
|
||||
PointerAlignment: Left
|
||||
PPIndentWidth: -1
|
||||
QualifierAlignment: Leave
|
||||
ReferenceAlignment: Pointer
|
||||
ReflowComments: true
|
||||
RemoveBracesLLVM: false
|
||||
RemoveParentheses: Leave
|
||||
RemoveSemicolon: false
|
||||
RequiresClausePosition: OwnLine
|
||||
RequiresExpressionIndentation: OuterScope
|
||||
SeparateDefinitionBlocks: Always
|
||||
ShortNamespaceLines: 1
|
||||
SortIncludes: CaseSensitive
|
||||
SortJavaStaticImport: Before
|
||||
SortUsingDeclarations: LexicographicNumeric
|
||||
SpaceAfterCStyleCast: false
|
||||
SpaceAfterLogicalNot: false
|
||||
SpaceAfterTemplateKeyword: true
|
||||
SpaceAroundPointerQualifiers: Default
|
||||
SpaceBeforeAssignmentOperators: true
|
||||
SpaceBeforeCaseColon: false
|
||||
SpaceBeforeCpp11BracedList: false
|
||||
SpaceBeforeCtorInitializerColon: true
|
||||
SpaceBeforeInheritanceColon: true
|
||||
SpaceBeforeJsonColon: false
|
||||
SpaceBeforeParens: ControlStatements
|
||||
SpaceBeforeParensOptions:
|
||||
AfterControlStatements: true
|
||||
AfterForeachMacros: true
|
||||
AfterFunctionDefinitionName: false
|
||||
AfterFunctionDeclarationName: false
|
||||
AfterIfMacros: true
|
||||
AfterOverloadedOperator: false
|
||||
AfterRequiresInClause: false
|
||||
AfterRequiresInExpression: false
|
||||
BeforeNonEmptyParentheses: false
|
||||
SpaceBeforeRangeBasedForLoopColon: true
|
||||
SpaceBeforeSquareBrackets: false
|
||||
SpaceInEmptyBlock: false
|
||||
SpacesBeforeTrailingComments: 1
|
||||
SpacesInAngles: Never
|
||||
SpacesInContainerLiterals: true
|
||||
SpacesInLineCommentPrefix:
|
||||
Minimum: 1
|
||||
Maximum: -1
|
||||
SpacesInParens: Never
|
||||
SpacesInParensOptions:
|
||||
InCStyleCasts: false
|
||||
InConditionalStatements: false
|
||||
InEmptyParentheses: false
|
||||
Other: false
|
||||
SpacesInSquareBrackets: false
|
||||
Standard: Latest
|
||||
StatementAttributeLikeMacros:
|
||||
- Q_EMIT
|
||||
StatementMacros:
|
||||
- Q_UNUSED
|
||||
- QT_REQUIRE_VERSION
|
||||
TabWidth: 4
|
||||
UseTab: Never
|
||||
VerilogBreakBetweenInstancePorts: true
|
||||
WhitespaceSensitiveMacros:
|
||||
- BOOST_PP_STRINGIZE
|
||||
- CF_SWIFT_NAME
|
||||
- NS_SWIFT_NAME
|
||||
- PP_STRINGIZE
|
||||
- STRINGIZE
|
||||
...
|
||||
|
||||
15
.editorconfig
Normal file
15
.editorconfig
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
# EditorConfig is awesome: https://EditorConfig.org
|
||||
|
||||
# top-most EditorConfig file
|
||||
root = true
|
||||
|
||||
[{Makefile, *.mk}]
|
||||
indent_style = tab
|
||||
|
||||
[*.{c,cpp,h,hpp}]
|
||||
indent_style = space
|
||||
indent_size = 4
|
||||
end_of_line = lf
|
||||
charset = utf-8
|
||||
trim_trailing_whitespace = false
|
||||
insert_final_newline = false
|
||||
26
.github/workflows/rust.yml
vendored
26
.github/workflows/rust.yml
vendored
|
|
@ -1,26 +0,0 @@
|
|||
name: Rust
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [ "main" ]
|
||||
pull_request:
|
||||
branches: [ "main" ]
|
||||
|
||||
env:
|
||||
CARGO_TERM_COLOR: always
|
||||
|
||||
jobs:
|
||||
build:
|
||||
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- name: Build
|
||||
run: cargo build --release --verbose
|
||||
- name: Run cargo tests
|
||||
run: cargo test --release --verbose
|
||||
- name: Run lang tests
|
||||
run: ./target/release/mcl_test_dev -m test
|
||||
- name: Check formatting with clippy
|
||||
run: cargo clippy -- -W clippy::pedantic -A clippy::struct-excessive-bools -A clippy::too_many_lines -A clippy::similar_names
|
||||
50
.gitignore
vendored
50
.gitignore
vendored
|
|
@ -1,18 +1,36 @@
|
|||
/target
|
||||
/*
|
||||
# Prerequisites
|
||||
*.d
|
||||
|
||||
# files
|
||||
!/.gitignore
|
||||
!/cargo.lock
|
||||
!/cargo.toml
|
||||
!/README.md
|
||||
# Compiled Object files
|
||||
*.slo
|
||||
*.lo
|
||||
*.o
|
||||
*.obj
|
||||
|
||||
# folders
|
||||
!/.github
|
||||
!/editor
|
||||
!/examples
|
||||
!/include
|
||||
!/playground
|
||||
!/src
|
||||
!/tests
|
||||
!/tools
|
||||
# Precompiled Headers
|
||||
*.gch
|
||||
*.pch
|
||||
|
||||
# Compiled Dynamic libraries
|
||||
*.so
|
||||
*.dylib
|
||||
*.dll
|
||||
|
||||
# Fortran module files
|
||||
*.mod
|
||||
*.smod
|
||||
|
||||
# Compiled Static libraries
|
||||
*.lai
|
||||
*.la
|
||||
*.a
|
||||
*.lib
|
||||
|
||||
# Executables
|
||||
*.exe
|
||||
*.out
|
||||
*.app
|
||||
.cache/clangd/index
|
||||
build
|
||||
temp.c
|
||||
compile_commands.json
|
||||
|
|
|
|||
336
Cargo.lock
generated
336
Cargo.lock
generated
|
|
@ -1,336 +0,0 @@
|
|||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
version = 3
|
||||
|
||||
[[package]]
|
||||
name = "anyhow"
|
||||
version = "1.0.79"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "080e9890a082662b09c1ad45f567faeeb47f22b5fb23895fbe1e651e718e25ca"
|
||||
|
||||
[[package]]
|
||||
name = "bitflags"
|
||||
version = "1.3.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
|
||||
|
||||
[[package]]
|
||||
name = "cc"
|
||||
version = "1.0.79"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
|
||||
|
||||
[[package]]
|
||||
name = "clap"
|
||||
version = "4.1.8"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c3d7ae14b20b94cb02149ed21a86c423859cbe18dc7ed69845cace50e52b40a5"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"clap_derive",
|
||||
"clap_lex",
|
||||
"is-terminal",
|
||||
"once_cell",
|
||||
"strsim",
|
||||
"termcolor",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_derive"
|
||||
version = "4.1.8"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "44bec8e5c9d09e439c4335b1af0abaab56dcf3b94999a936e1bb47b9134288f0"
|
||||
dependencies = [
|
||||
"heck",
|
||||
"proc-macro-error",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_lex"
|
||||
version = "0.3.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "350b9cf31731f9957399229e9b2adc51eeabdfbe9d71d9a0552275fd12710d09"
|
||||
dependencies = [
|
||||
"os_str_bytes",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "errno"
|
||||
version = "0.2.8"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f639046355ee4f37944e44f60642c6f3a7efa3cf6b78c78a0d989a8ce6c396a1"
|
||||
dependencies = [
|
||||
"errno-dragonfly",
|
||||
"libc",
|
||||
"winapi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "errno-dragonfly"
|
||||
version = "0.1.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
|
||||
dependencies = [
|
||||
"cc",
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "heck"
|
||||
version = "0.4.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
|
||||
|
||||
[[package]]
|
||||
name = "hermit-abi"
|
||||
version = "0.3.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fed44880c466736ef9a5c5b5facefb5ed0785676d0c02d612db14e54f0d84286"
|
||||
|
||||
[[package]]
|
||||
name = "io-lifetimes"
|
||||
version = "1.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cfa919a82ea574332e2de6e74b4c36e74d41982b335080fa59d4ef31be20fdf3"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"windows-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "is-terminal"
|
||||
version = "0.4.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "21b6b32576413a8e69b90e952e4a026476040d81017b80445deda5f2d3921857"
|
||||
dependencies = [
|
||||
"hermit-abi",
|
||||
"io-lifetimes",
|
||||
"rustix",
|
||||
"windows-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "libc"
|
||||
version = "0.2.140"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "99227334921fae1a979cf0bfdfcc6b3e5ce376ef57e16fb6fb3ea2ed6095f80c"
|
||||
|
||||
[[package]]
|
||||
name = "linux-raw-sys"
|
||||
version = "0.1.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"
|
||||
|
||||
[[package]]
|
||||
name = "mclangc"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"clap",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "once_cell"
|
||||
version = "1.17.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3"
|
||||
|
||||
[[package]]
|
||||
name = "os_str_bytes"
|
||||
version = "6.4.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9b7820b9daea5457c9f21c69448905d723fbd21136ccf521748f23fd49e723ee"
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro-error"
|
||||
version = "1.0.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
|
||||
dependencies = [
|
||||
"proc-macro-error-attr",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
"version_check",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro-error-attr"
|
||||
version = "1.0.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"version_check",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.51"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5d727cae5b39d21da60fa540906919ad737832fe0b1c165da3a34d6548c849d6"
|
||||
dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quote"
|
||||
version = "1.0.23"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rustix"
|
||||
version = "0.36.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fd5c6ff11fecd55b40746d1995a02f2eb375bf8c00d192d521ee09f42bef37bc"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"errno",
|
||||
"io-lifetimes",
|
||||
"libc",
|
||||
"linux-raw-sys",
|
||||
"windows-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "strsim"
|
||||
version = "0.10.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "1.0.109"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "termcolor"
|
||||
version = "1.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
|
||||
dependencies = [
|
||||
"winapi-util",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "unicode-ident"
|
||||
version = "1.0.8"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"
|
||||
|
||||
[[package]]
|
||||
name = "version_check"
|
||||
version = "0.9.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
|
||||
|
||||
[[package]]
|
||||
name = "winapi"
|
||||
version = "0.3.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
|
||||
dependencies = [
|
||||
"winapi-i686-pc-windows-gnu",
|
||||
"winapi-x86_64-pc-windows-gnu",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winapi-i686-pc-windows-gnu"
|
||||
version = "0.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
|
||||
|
||||
[[package]]
|
||||
name = "winapi-util"
|
||||
version = "0.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
|
||||
dependencies = [
|
||||
"winapi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winapi-x86_64-pc-windows-gnu"
|
||||
version = "0.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
|
||||
|
||||
[[package]]
|
||||
name = "windows-sys"
|
||||
version = "0.45.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
|
||||
dependencies = [
|
||||
"windows-targets",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-targets"
|
||||
version = "0.42.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8e2522491fbfcd58cc84d47aeb2958948c4b8982e9a2d8a2a35bbaed431390e7"
|
||||
dependencies = [
|
||||
"windows_aarch64_gnullvm",
|
||||
"windows_aarch64_msvc",
|
||||
"windows_i686_gnu",
|
||||
"windows_i686_msvc",
|
||||
"windows_x86_64_gnu",
|
||||
"windows_x86_64_gnullvm",
|
||||
"windows_x86_64_msvc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows_aarch64_gnullvm"
|
||||
version = "0.42.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8c9864e83243fdec7fc9c5444389dcbbfd258f745e7853198f365e3c4968a608"
|
||||
|
||||
[[package]]
|
||||
name = "windows_aarch64_msvc"
|
||||
version = "0.42.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4c8b1b673ffc16c47a9ff48570a9d85e25d265735c503681332589af6253c6c7"
|
||||
|
||||
[[package]]
|
||||
name = "windows_i686_gnu"
|
||||
version = "0.42.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "de3887528ad530ba7bdbb1faa8275ec7a1155a45ffa57c37993960277145d640"
|
||||
|
||||
[[package]]
|
||||
name = "windows_i686_msvc"
|
||||
version = "0.42.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "bf4d1122317eddd6ff351aa852118a2418ad4214e6613a50e0191f7004372605"
|
||||
|
||||
[[package]]
|
||||
name = "windows_x86_64_gnu"
|
||||
version = "0.42.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c1040f221285e17ebccbc2591ffdc2d44ee1f9186324dd3e84e99ac68d699c45"
|
||||
|
||||
[[package]]
|
||||
name = "windows_x86_64_gnullvm"
|
||||
version = "0.42.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "628bfdf232daa22b0d64fdb62b09fcc36bb01f05a3939e20ab73aaf9470d0463"
|
||||
|
||||
[[package]]
|
||||
name = "windows_x86_64_msvc"
|
||||
version = "0.42.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "447660ad36a13288b1db4d4248e857b510e8c3a225c822ba4fb748c0aafecffd"
|
||||
13
Cargo.toml
13
Cargo.toml
|
|
@ -1,13 +0,0 @@
|
|||
[package]
|
||||
name = "mclangc"
|
||||
description="The McLang Programming language compiler"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors=[
|
||||
"MCorange <mcorangecodes@gmail.com> (https://mcorangehq.xyz/)"
|
||||
]
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
anyhow = "1.0.79"
|
||||
clap = { version = "4.1.8", features = ["derive"] }
|
||||
674
LICENSE
Normal file
674
LICENSE
Normal file
|
|
@ -0,0 +1,674 @@
|
|||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 3, 29 June 2007
|
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
Preamble
|
||||
|
||||
The GNU General Public License is a free, copyleft license for
|
||||
software and other kinds of works.
|
||||
|
||||
The licenses for most software and other practical works are designed
|
||||
to take away your freedom to share and change the works. By contrast,
|
||||
the GNU General Public License is intended to guarantee your freedom to
|
||||
share and change all versions of a program--to make sure it remains free
|
||||
software for all its users. We, the Free Software Foundation, use the
|
||||
GNU General Public License for most of our software; it applies also to
|
||||
any other work released this way by its authors. You can apply it to
|
||||
your programs, too.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
them if you wish), that you receive source code or can get it if you
|
||||
want it, that you can change the software or use pieces of it in new
|
||||
free programs, and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to prevent others from denying you
|
||||
these rights or asking you to surrender the rights. Therefore, you have
|
||||
certain responsibilities if you distribute copies of the software, or if
|
||||
you modify it: responsibilities to respect the freedom of others.
|
||||
|
||||
For example, if you distribute copies of such a program, whether
|
||||
gratis or for a fee, you must pass on to the recipients the same
|
||||
freedoms that you received. You must make sure that they, too, receive
|
||||
or can get the source code. And you must show them these terms so they
|
||||
know their rights.
|
||||
|
||||
Developers that use the GNU GPL protect your rights with two steps:
|
||||
(1) assert copyright on the software, and (2) offer you this License
|
||||
giving you legal permission to copy, distribute and/or modify it.
|
||||
|
||||
For the developers' and authors' protection, the GPL clearly explains
|
||||
that there is no warranty for this free software. For both users' and
|
||||
authors' sake, the GPL requires that modified versions be marked as
|
||||
changed, so that their problems will not be attributed erroneously to
|
||||
authors of previous versions.
|
||||
|
||||
Some devices are designed to deny users access to install or run
|
||||
modified versions of the software inside them, although the manufacturer
|
||||
can do so. This is fundamentally incompatible with the aim of
|
||||
protecting users' freedom to change the software. The systematic
|
||||
pattern of such abuse occurs in the area of products for individuals to
|
||||
use, which is precisely where it is most unacceptable. Therefore, we
|
||||
have designed this version of the GPL to prohibit the practice for those
|
||||
products. If such problems arise substantially in other domains, we
|
||||
stand ready to extend this provision to those domains in future versions
|
||||
of the GPL, as needed to protect the freedom of users.
|
||||
|
||||
Finally, every program is threatened constantly by software patents.
|
||||
States should not allow patents to restrict development and use of
|
||||
software on general-purpose computers, but in those that do, we wish to
|
||||
avoid the special danger that patents applied to a free program could
|
||||
make it effectively proprietary. To prevent this, the GPL assures that
|
||||
patents cannot be used to render the program non-free.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
||||
TERMS AND CONDITIONS
|
||||
|
||||
0. Definitions.
|
||||
|
||||
"This License" refers to version 3 of the GNU General Public License.
|
||||
|
||||
"Copyright" also means copyright-like laws that apply to other kinds of
|
||||
works, such as semiconductor masks.
|
||||
|
||||
"The Program" refers to any copyrightable work licensed under this
|
||||
License. Each licensee is addressed as "you". "Licensees" and
|
||||
"recipients" may be individuals or organizations.
|
||||
|
||||
To "modify" a work means to copy from or adapt all or part of the work
|
||||
in a fashion requiring copyright permission, other than the making of an
|
||||
exact copy. The resulting work is called a "modified version" of the
|
||||
earlier work or a work "based on" the earlier work.
|
||||
|
||||
A "covered work" means either the unmodified Program or a work based
|
||||
on the Program.
|
||||
|
||||
To "propagate" a work means to do anything with it that, without
|
||||
permission, would make you directly or secondarily liable for
|
||||
infringement under applicable copyright law, except executing it on a
|
||||
computer or modifying a private copy. Propagation includes copying,
|
||||
distribution (with or without modification), making available to the
|
||||
public, and in some countries other activities as well.
|
||||
|
||||
To "convey" a work means any kind of propagation that enables other
|
||||
parties to make or receive copies. Mere interaction with a user through
|
||||
a computer network, with no transfer of a copy, is not conveying.
|
||||
|
||||
An interactive user interface displays "Appropriate Legal Notices"
|
||||
to the extent that it includes a convenient and prominently visible
|
||||
feature that (1) displays an appropriate copyright notice, and (2)
|
||||
tells the user that there is no warranty for the work (except to the
|
||||
extent that warranties are provided), that licensees may convey the
|
||||
work under this License, and how to view a copy of this License. If
|
||||
the interface presents a list of user commands or options, such as a
|
||||
menu, a prominent item in the list meets this criterion.
|
||||
|
||||
1. Source Code.
|
||||
|
||||
The "source code" for a work means the preferred form of the work
|
||||
for making modifications to it. "Object code" means any non-source
|
||||
form of a work.
|
||||
|
||||
A "Standard Interface" means an interface that either is an official
|
||||
standard defined by a recognized standards body, or, in the case of
|
||||
interfaces specified for a particular programming language, one that
|
||||
is widely used among developers working in that language.
|
||||
|
||||
The "System Libraries" of an executable work include anything, other
|
||||
than the work as a whole, that (a) is included in the normal form of
|
||||
packaging a Major Component, but which is not part of that Major
|
||||
Component, and (b) serves only to enable use of the work with that
|
||||
Major Component, or to implement a Standard Interface for which an
|
||||
implementation is available to the public in source code form. A
|
||||
"Major Component", in this context, means a major essential component
|
||||
(kernel, window system, and so on) of the specific operating system
|
||||
(if any) on which the executable work runs, or a compiler used to
|
||||
produce the work, or an object code interpreter used to run it.
|
||||
|
||||
The "Corresponding Source" for a work in object code form means all
|
||||
the source code needed to generate, install, and (for an executable
|
||||
work) run the object code and to modify the work, including scripts to
|
||||
control those activities. However, it does not include the work's
|
||||
System Libraries, or general-purpose tools or generally available free
|
||||
programs which are used unmodified in performing those activities but
|
||||
which are not part of the work. For example, Corresponding Source
|
||||
includes interface definition files associated with source files for
|
||||
the work, and the source code for shared libraries and dynamically
|
||||
linked subprograms that the work is specifically designed to require,
|
||||
such as by intimate data communication or control flow between those
|
||||
subprograms and other parts of the work.
|
||||
|
||||
The Corresponding Source need not include anything that users
|
||||
can regenerate automatically from other parts of the Corresponding
|
||||
Source.
|
||||
|
||||
The Corresponding Source for a work in source code form is that
|
||||
same work.
|
||||
|
||||
2. Basic Permissions.
|
||||
|
||||
All rights granted under this License are granted for the term of
|
||||
copyright on the Program, and are irrevocable provided the stated
|
||||
conditions are met. This License explicitly affirms your unlimited
|
||||
permission to run the unmodified Program. The output from running a
|
||||
covered work is covered by this License only if the output, given its
|
||||
content, constitutes a covered work. This License acknowledges your
|
||||
rights of fair use or other equivalent, as provided by copyright law.
|
||||
|
||||
You may make, run and propagate covered works that you do not
|
||||
convey, without conditions so long as your license otherwise remains
|
||||
in force. You may convey covered works to others for the sole purpose
|
||||
of having them make modifications exclusively for you, or provide you
|
||||
with facilities for running those works, provided that you comply with
|
||||
the terms of this License in conveying all material for which you do
|
||||
not control copyright. Those thus making or running the covered works
|
||||
for you must do so exclusively on your behalf, under your direction
|
||||
and control, on terms that prohibit them from making any copies of
|
||||
your copyrighted material outside their relationship with you.
|
||||
|
||||
Conveying under any other circumstances is permitted solely under
|
||||
the conditions stated below. Sublicensing is not allowed; section 10
|
||||
makes it unnecessary.
|
||||
|
||||
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
|
||||
|
||||
No covered work shall be deemed part of an effective technological
|
||||
measure under any applicable law fulfilling obligations under article
|
||||
11 of the WIPO copyright treaty adopted on 20 December 1996, or
|
||||
similar laws prohibiting or restricting circumvention of such
|
||||
measures.
|
||||
|
||||
When you convey a covered work, you waive any legal power to forbid
|
||||
circumvention of technological measures to the extent such circumvention
|
||||
is effected by exercising rights under this License with respect to
|
||||
the covered work, and you disclaim any intention to limit operation or
|
||||
modification of the work as a means of enforcing, against the work's
|
||||
users, your or third parties' legal rights to forbid circumvention of
|
||||
technological measures.
|
||||
|
||||
4. Conveying Verbatim Copies.
|
||||
|
||||
You may convey verbatim copies of the Program's source code as you
|
||||
receive it, in any medium, provided that you conspicuously and
|
||||
appropriately publish on each copy an appropriate copyright notice;
|
||||
keep intact all notices stating that this License and any
|
||||
non-permissive terms added in accord with section 7 apply to the code;
|
||||
keep intact all notices of the absence of any warranty; and give all
|
||||
recipients a copy of this License along with the Program.
|
||||
|
||||
You may charge any price or no price for each copy that you convey,
|
||||
and you may offer support or warranty protection for a fee.
|
||||
|
||||
5. Conveying Modified Source Versions.
|
||||
|
||||
You may convey a work based on the Program, or the modifications to
|
||||
produce it from the Program, in the form of source code under the
|
||||
terms of section 4, provided that you also meet all of these conditions:
|
||||
|
||||
a) The work must carry prominent notices stating that you modified
|
||||
it, and giving a relevant date.
|
||||
|
||||
b) The work must carry prominent notices stating that it is
|
||||
released under this License and any conditions added under section
|
||||
7. This requirement modifies the requirement in section 4 to
|
||||
"keep intact all notices".
|
||||
|
||||
c) You must license the entire work, as a whole, under this
|
||||
License to anyone who comes into possession of a copy. This
|
||||
License will therefore apply, along with any applicable section 7
|
||||
additional terms, to the whole of the work, and all its parts,
|
||||
regardless of how they are packaged. This License gives no
|
||||
permission to license the work in any other way, but it does not
|
||||
invalidate such permission if you have separately received it.
|
||||
|
||||
d) If the work has interactive user interfaces, each must display
|
||||
Appropriate Legal Notices; however, if the Program has interactive
|
||||
interfaces that do not display Appropriate Legal Notices, your
|
||||
work need not make them do so.
|
||||
|
||||
A compilation of a covered work with other separate and independent
|
||||
works, which are not by their nature extensions of the covered work,
|
||||
and which are not combined with it such as to form a larger program,
|
||||
in or on a volume of a storage or distribution medium, is called an
|
||||
"aggregate" if the compilation and its resulting copyright are not
|
||||
used to limit the access or legal rights of the compilation's users
|
||||
beyond what the individual works permit. Inclusion of a covered work
|
||||
in an aggregate does not cause this License to apply to the other
|
||||
parts of the aggregate.
|
||||
|
||||
6. Conveying Non-Source Forms.
|
||||
|
||||
You may convey a covered work in object code form under the terms
|
||||
of sections 4 and 5, provided that you also convey the
|
||||
machine-readable Corresponding Source under the terms of this License,
|
||||
in one of these ways:
|
||||
|
||||
a) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by the
|
||||
Corresponding Source fixed on a durable physical medium
|
||||
customarily used for software interchange.
|
||||
|
||||
b) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by a
|
||||
written offer, valid for at least three years and valid for as
|
||||
long as you offer spare parts or customer support for that product
|
||||
model, to give anyone who possesses the object code either (1) a
|
||||
copy of the Corresponding Source for all the software in the
|
||||
product that is covered by this License, on a durable physical
|
||||
medium customarily used for software interchange, for a price no
|
||||
more than your reasonable cost of physically performing this
|
||||
conveying of source, or (2) access to copy the
|
||||
Corresponding Source from a network server at no charge.
|
||||
|
||||
c) Convey individual copies of the object code with a copy of the
|
||||
written offer to provide the Corresponding Source. This
|
||||
alternative is allowed only occasionally and noncommercially, and
|
||||
only if you received the object code with such an offer, in accord
|
||||
with subsection 6b.
|
||||
|
||||
d) Convey the object code by offering access from a designated
|
||||
place (gratis or for a charge), and offer equivalent access to the
|
||||
Corresponding Source in the same way through the same place at no
|
||||
further charge. You need not require recipients to copy the
|
||||
Corresponding Source along with the object code. If the place to
|
||||
copy the object code is a network server, the Corresponding Source
|
||||
may be on a different server (operated by you or a third party)
|
||||
that supports equivalent copying facilities, provided you maintain
|
||||
clear directions next to the object code saying where to find the
|
||||
Corresponding Source. Regardless of what server hosts the
|
||||
Corresponding Source, you remain obligated to ensure that it is
|
||||
available for as long as needed to satisfy these requirements.
|
||||
|
||||
e) Convey the object code using peer-to-peer transmission, provided
|
||||
you inform other peers where the object code and Corresponding
|
||||
Source of the work are being offered to the general public at no
|
||||
charge under subsection 6d.
|
||||
|
||||
A separable portion of the object code, whose source code is excluded
|
||||
from the Corresponding Source as a System Library, need not be
|
||||
included in conveying the object code work.
|
||||
|
||||
A "User Product" is either (1) a "consumer product", which means any
|
||||
tangible personal property which is normally used for personal, family,
|
||||
or household purposes, or (2) anything designed or sold for incorporation
|
||||
into a dwelling. In determining whether a product is a consumer product,
|
||||
doubtful cases shall be resolved in favor of coverage. For a particular
|
||||
product received by a particular user, "normally used" refers to a
|
||||
typical or common use of that class of product, regardless of the status
|
||||
of the particular user or of the way in which the particular user
|
||||
actually uses, or expects or is expected to use, the product. A product
|
||||
is a consumer product regardless of whether the product has substantial
|
||||
commercial, industrial or non-consumer uses, unless such uses represent
|
||||
the only significant mode of use of the product.
|
||||
|
||||
"Installation Information" for a User Product means any methods,
|
||||
procedures, authorization keys, or other information required to install
|
||||
and execute modified versions of a covered work in that User Product from
|
||||
a modified version of its Corresponding Source. The information must
|
||||
suffice to ensure that the continued functioning of the modified object
|
||||
code is in no case prevented or interfered with solely because
|
||||
modification has been made.
|
||||
|
||||
If you convey an object code work under this section in, or with, or
|
||||
specifically for use in, a User Product, and the conveying occurs as
|
||||
part of a transaction in which the right of possession and use of the
|
||||
User Product is transferred to the recipient in perpetuity or for a
|
||||
fixed term (regardless of how the transaction is characterized), the
|
||||
Corresponding Source conveyed under this section must be accompanied
|
||||
by the Installation Information. But this requirement does not apply
|
||||
if neither you nor any third party retains the ability to install
|
||||
modified object code on the User Product (for example, the work has
|
||||
been installed in ROM).
|
||||
|
||||
The requirement to provide Installation Information does not include a
|
||||
requirement to continue to provide support service, warranty, or updates
|
||||
for a work that has been modified or installed by the recipient, or for
|
||||
the User Product in which it has been modified or installed. Access to a
|
||||
network may be denied when the modification itself materially and
|
||||
adversely affects the operation of the network or violates the rules and
|
||||
protocols for communication across the network.
|
||||
|
||||
Corresponding Source conveyed, and Installation Information provided,
|
||||
in accord with this section must be in a format that is publicly
|
||||
documented (and with an implementation available to the public in
|
||||
source code form), and must require no special password or key for
|
||||
unpacking, reading or copying.
|
||||
|
||||
7. Additional Terms.
|
||||
|
||||
"Additional permissions" are terms that supplement the terms of this
|
||||
License by making exceptions from one or more of its conditions.
|
||||
Additional permissions that are applicable to the entire Program shall
|
||||
be treated as though they were included in this License, to the extent
|
||||
that they are valid under applicable law. If additional permissions
|
||||
apply only to part of the Program, that part may be used separately
|
||||
under those permissions, but the entire Program remains governed by
|
||||
this License without regard to the additional permissions.
|
||||
|
||||
When you convey a copy of a covered work, you may at your option
|
||||
remove any additional permissions from that copy, or from any part of
|
||||
it. (Additional permissions may be written to require their own
|
||||
removal in certain cases when you modify the work.) You may place
|
||||
additional permissions on material, added by you to a covered work,
|
||||
for which you have or can give appropriate copyright permission.
|
||||
|
||||
Notwithstanding any other provision of this License, for material you
|
||||
add to a covered work, you may (if authorized by the copyright holders of
|
||||
that material) supplement the terms of this License with terms:
|
||||
|
||||
a) Disclaiming warranty or limiting liability differently from the
|
||||
terms of sections 15 and 16 of this License; or
|
||||
|
||||
b) Requiring preservation of specified reasonable legal notices or
|
||||
author attributions in that material or in the Appropriate Legal
|
||||
Notices displayed by works containing it; or
|
||||
|
||||
c) Prohibiting misrepresentation of the origin of that material, or
|
||||
requiring that modified versions of such material be marked in
|
||||
reasonable ways as different from the original version; or
|
||||
|
||||
d) Limiting the use for publicity purposes of names of licensors or
|
||||
authors of the material; or
|
||||
|
||||
e) Declining to grant rights under trademark law for use of some
|
||||
trade names, trademarks, or service marks; or
|
||||
|
||||
f) Requiring indemnification of licensors and authors of that
|
||||
material by anyone who conveys the material (or modified versions of
|
||||
it) with contractual assumptions of liability to the recipient, for
|
||||
any liability that these contractual assumptions directly impose on
|
||||
those licensors and authors.
|
||||
|
||||
All other non-permissive additional terms are considered "further
|
||||
restrictions" within the meaning of section 10. If the Program as you
|
||||
received it, or any part of it, contains a notice stating that it is
|
||||
governed by this License along with a term that is a further
|
||||
restriction, you may remove that term. If a license document contains
|
||||
a further restriction but permits relicensing or conveying under this
|
||||
License, you may add to a covered work material governed by the terms
|
||||
of that license document, provided that the further restriction does
|
||||
not survive such relicensing or conveying.
|
||||
|
||||
If you add terms to a covered work in accord with this section, you
|
||||
must place, in the relevant source files, a statement of the
|
||||
additional terms that apply to those files, or a notice indicating
|
||||
where to find the applicable terms.
|
||||
|
||||
Additional terms, permissive or non-permissive, may be stated in the
|
||||
form of a separately written license, or stated as exceptions;
|
||||
the above requirements apply either way.
|
||||
|
||||
8. Termination.
|
||||
|
||||
You may not propagate or modify a covered work except as expressly
|
||||
provided under this License. Any attempt otherwise to propagate or
|
||||
modify it is void, and will automatically terminate your rights under
|
||||
this License (including any patent licenses granted under the third
|
||||
paragraph of section 11).
|
||||
|
||||
However, if you cease all violation of this License, then your
|
||||
license from a particular copyright holder is reinstated (a)
|
||||
provisionally, unless and until the copyright holder explicitly and
|
||||
finally terminates your license, and (b) permanently, if the copyright
|
||||
holder fails to notify you of the violation by some reasonable means
|
||||
prior to 60 days after the cessation.
|
||||
|
||||
Moreover, your license from a particular copyright holder is
|
||||
reinstated permanently if the copyright holder notifies you of the
|
||||
violation by some reasonable means, this is the first time you have
|
||||
received notice of violation of this License (for any work) from that
|
||||
copyright holder, and you cure the violation prior to 30 days after
|
||||
your receipt of the notice.
|
||||
|
||||
Termination of your rights under this section does not terminate the
|
||||
licenses of parties who have received copies or rights from you under
|
||||
this License. If your rights have been terminated and not permanently
|
||||
reinstated, you do not qualify to receive new licenses for the same
|
||||
material under section 10.
|
||||
|
||||
9. Acceptance Not Required for Having Copies.
|
||||
|
||||
You are not required to accept this License in order to receive or
|
||||
run a copy of the Program. Ancillary propagation of a covered work
|
||||
occurring solely as a consequence of using peer-to-peer transmission
|
||||
to receive a copy likewise does not require acceptance. However,
|
||||
nothing other than this License grants you permission to propagate or
|
||||
modify any covered work. These actions infringe copyright if you do
|
||||
not accept this License. Therefore, by modifying or propagating a
|
||||
covered work, you indicate your acceptance of this License to do so.
|
||||
|
||||
10. Automatic Licensing of Downstream Recipients.
|
||||
|
||||
Each time you convey a covered work, the recipient automatically
|
||||
receives a license from the original licensors, to run, modify and
|
||||
propagate that work, subject to this License. You are not responsible
|
||||
for enforcing compliance by third parties with this License.
|
||||
|
||||
An "entity transaction" is a transaction transferring control of an
|
||||
organization, or substantially all assets of one, or subdividing an
|
||||
organization, or merging organizations. If propagation of a covered
|
||||
work results from an entity transaction, each party to that
|
||||
transaction who receives a copy of the work also receives whatever
|
||||
licenses to the work the party's predecessor in interest had or could
|
||||
give under the previous paragraph, plus a right to possession of the
|
||||
Corresponding Source of the work from the predecessor in interest, if
|
||||
the predecessor has it or can get it with reasonable efforts.
|
||||
|
||||
You may not impose any further restrictions on the exercise of the
|
||||
rights granted or affirmed under this License. For example, you may
|
||||
not impose a license fee, royalty, or other charge for exercise of
|
||||
rights granted under this License, and you may not initiate litigation
|
||||
(including a cross-claim or counterclaim in a lawsuit) alleging that
|
||||
any patent claim is infringed by making, using, selling, offering for
|
||||
sale, or importing the Program or any portion of it.
|
||||
|
||||
11. Patents.
|
||||
|
||||
A "contributor" is a copyright holder who authorizes use under this
|
||||
License of the Program or a work on which the Program is based. The
|
||||
work thus licensed is called the contributor's "contributor version".
|
||||
|
||||
A contributor's "essential patent claims" are all patent claims
|
||||
owned or controlled by the contributor, whether already acquired or
|
||||
hereafter acquired, that would be infringed by some manner, permitted
|
||||
by this License, of making, using, or selling its contributor version,
|
||||
but do not include claims that would be infringed only as a
|
||||
consequence of further modification of the contributor version. For
|
||||
purposes of this definition, "control" includes the right to grant
|
||||
patent sublicenses in a manner consistent with the requirements of
|
||||
this License.
|
||||
|
||||
Each contributor grants you a non-exclusive, worldwide, royalty-free
|
||||
patent license under the contributor's essential patent claims, to
|
||||
make, use, sell, offer for sale, import and otherwise run, modify and
|
||||
propagate the contents of its contributor version.
|
||||
|
||||
In the following three paragraphs, a "patent license" is any express
|
||||
agreement or commitment, however denominated, not to enforce a patent
|
||||
(such as an express permission to practice a patent or covenant not to
|
||||
sue for patent infringement). To "grant" such a patent license to a
|
||||
party means to make such an agreement or commitment not to enforce a
|
||||
patent against the party.
|
||||
|
||||
If you convey a covered work, knowingly relying on a patent license,
|
||||
and the Corresponding Source of the work is not available for anyone
|
||||
to copy, free of charge and under the terms of this License, through a
|
||||
publicly available network server or other readily accessible means,
|
||||
then you must either (1) cause the Corresponding Source to be so
|
||||
available, or (2) arrange to deprive yourself of the benefit of the
|
||||
patent license for this particular work, or (3) arrange, in a manner
|
||||
consistent with the requirements of this License, to extend the patent
|
||||
license to downstream recipients. "Knowingly relying" means you have
|
||||
actual knowledge that, but for the patent license, your conveying the
|
||||
covered work in a country, or your recipient's use of the covered work
|
||||
in a country, would infringe one or more identifiable patents in that
|
||||
country that you have reason to believe are valid.
|
||||
|
||||
If, pursuant to or in connection with a single transaction or
|
||||
arrangement, you convey, or propagate by procuring conveyance of, a
|
||||
covered work, and grant a patent license to some of the parties
|
||||
receiving the covered work authorizing them to use, propagate, modify
|
||||
or convey a specific copy of the covered work, then the patent license
|
||||
you grant is automatically extended to all recipients of the covered
|
||||
work and works based on it.
|
||||
|
||||
A patent license is "discriminatory" if it does not include within
|
||||
the scope of its coverage, prohibits the exercise of, or is
|
||||
conditioned on the non-exercise of one or more of the rights that are
|
||||
specifically granted under this License. You may not convey a covered
|
||||
work if you are a party to an arrangement with a third party that is
|
||||
in the business of distributing software, under which you make payment
|
||||
to the third party based on the extent of your activity of conveying
|
||||
the work, and under which the third party grants, to any of the
|
||||
parties who would receive the covered work from you, a discriminatory
|
||||
patent license (a) in connection with copies of the covered work
|
||||
conveyed by you (or copies made from those copies), or (b) primarily
|
||||
for and in connection with specific products or compilations that
|
||||
contain the covered work, unless you entered into that arrangement,
|
||||
or that patent license was granted, prior to 28 March 2007.
|
||||
|
||||
Nothing in this License shall be construed as excluding or limiting
|
||||
any implied license or other defenses to infringement that may
|
||||
otherwise be available to you under applicable patent law.
|
||||
|
||||
12. No Surrender of Others' Freedom.
|
||||
|
||||
If conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot convey a
|
||||
covered work so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you may
|
||||
not convey it at all. For example, if you agree to terms that obligate you
|
||||
to collect a royalty for further conveying from those to whom you convey
|
||||
the Program, the only way you could satisfy both those terms and this
|
||||
License would be to refrain entirely from conveying the Program.
|
||||
|
||||
13. Use with the GNU Affero General Public License.
|
||||
|
||||
Notwithstanding any other provision of this License, you have
|
||||
permission to link or combine any covered work with a work licensed
|
||||
under version 3 of the GNU Affero General Public License into a single
|
||||
combined work, and to convey the resulting work. The terms of this
|
||||
License will continue to apply to the part which is the covered work,
|
||||
but the special requirements of the GNU Affero General Public License,
|
||||
section 13, concerning interaction through a network will apply to the
|
||||
combination as such.
|
||||
|
||||
14. Revised Versions of this License.
|
||||
|
||||
The Free Software Foundation may publish revised and/or new versions of
|
||||
the GNU General Public License from time to time. Such new versions will
|
||||
be similar in spirit to the present version, but may differ in detail to
|
||||
address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the
|
||||
Program specifies that a certain numbered version of the GNU General
|
||||
Public License "or any later version" applies to it, you have the
|
||||
option of following the terms and conditions either of that numbered
|
||||
version or of any later version published by the Free Software
|
||||
Foundation. If the Program does not specify a version number of the
|
||||
GNU General Public License, you may choose any version ever published
|
||||
by the Free Software Foundation.
|
||||
|
||||
If the Program specifies that a proxy can decide which future
|
||||
versions of the GNU General Public License can be used, that proxy's
|
||||
public statement of acceptance of a version permanently authorizes you
|
||||
to choose that version for the Program.
|
||||
|
||||
Later license versions may give you additional or different
|
||||
permissions. However, no additional obligations are imposed on any
|
||||
author or copyright holder as a result of your choosing to follow a
|
||||
later version.
|
||||
|
||||
15. Disclaimer of Warranty.
|
||||
|
||||
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
|
||||
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
|
||||
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
|
||||
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
|
||||
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
|
||||
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
|
||||
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. Limitation of Liability.
|
||||
|
||||
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
|
||||
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
|
||||
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
|
||||
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
|
||||
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
|
||||
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
|
||||
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
|
||||
SUCH DAMAGES.
|
||||
|
||||
17. Interpretation of Sections 15 and 16.
|
||||
|
||||
If the disclaimer of warranty and limitation of liability provided
|
||||
above cannot be given local legal effect according to their terms,
|
||||
reviewing courts shall apply local law that most closely approximates
|
||||
an absolute waiver of all civil liability in connection with the
|
||||
Program, unless a warranty or assumption of liability accompanies a
|
||||
copy of the Program in return for a fee.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Programs
|
||||
|
||||
If you develop a new program, and you want it to be of the greatest
|
||||
possible use to the public, the best way to achieve this is to make it
|
||||
free software which everyone can redistribute and change under these terms.
|
||||
|
||||
To do so, attach the following notices to the program. It is safest
|
||||
to attach them to the start of each source file to most effectively
|
||||
state the exclusion of warranty; and each file should have at least
|
||||
the "copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If the program does terminal interaction, make it output a short
|
||||
notice like this when it starts in an interactive mode:
|
||||
|
||||
<program> Copyright (C) <year> <name of author>
|
||||
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
parts of the General Public License. Of course, your program's commands
|
||||
might be different; for a GUI interface, you would use an "about box".
|
||||
|
||||
You should also get your employer (if you work as a programmer) or school,
|
||||
if any, to sign a "copyright disclaimer" for the program, if necessary.
|
||||
For more information on this, and how to apply and follow the GNU GPL, see
|
||||
<https://www.gnu.org/licenses/>.
|
||||
|
||||
The GNU General Public License does not permit incorporating your program
|
||||
into proprietary programs. If your program is a subroutine library, you
|
||||
may consider it more useful to permit linking proprietary applications with
|
||||
the library. If this is what you want to do, use the GNU Lesser General
|
||||
Public License instead of this License. But first, please read
|
||||
<https://www.gnu.org/licenses/why-not-lgpl.html>.
|
||||
40
Makefile
Normal file
40
Makefile
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
BIN=mclangc
|
||||
|
||||
CC_FLAGS = -Isrc/include -std=c23
|
||||
CXX_FLAGS = -Isrc/include -Ilib/ -std=c++23 -fmodules-ts
|
||||
LD_FLAGS = -lm
|
||||
CC=gcc
|
||||
CXX=g++
|
||||
LD=gcc
|
||||
AR=ar
|
||||
|
||||
LIBS=
|
||||
include lib/make.mk
|
||||
|
||||
cxx_sources=$(wildcard src/*.cpp)
|
||||
c_sources=$(wildcard src/*.c)
|
||||
objects=$(patsubst src/%.cpp,build/obj/%.cpp.o,$(cxx_sources)) $(patsubst src/%.c,build/obj/%.c.o,$(c_sources)) $(LIBS)
|
||||
|
||||
|
||||
all: build/$(BIN) compile_commands.json
|
||||
@rm -r build/obj
|
||||
|
||||
keep: build/$(BIN)
|
||||
|
||||
clean:
|
||||
rm -r build/obj/
|
||||
|
||||
|
||||
build/$(BIN): $(objects)
|
||||
$(LD) -o $@ $^ $(LD_FLAGS)
|
||||
|
||||
build/obj/%.cpp.o: */%.cpp
|
||||
@mkdir -p $(dir $@)
|
||||
$(CXX) -c -o $@ $< $(CXX_FLAGS)
|
||||
|
||||
build/obj/%.c.o: */%.c
|
||||
@mkdir -p $(dir $@)
|
||||
$(CC) -c -o $@ $< $(CC_FLAGS)
|
||||
|
||||
compile_commands.json:
|
||||
compiledb -n make
|
||||
32
README.md
32
README.md
|
|
@ -1,31 +1,3 @@
|
|||
# mclang rev2
|
||||
# C/C++ template
|
||||
|
||||
This is the second revision of [MCLang](https://github.com/mc-lang/mclang) now written in rust!
|
||||
|
||||
## Goals
|
||||
|
||||
✅ - relatevely usable by normal programmers
|
||||
✅ - speed comparable to unoptimised C (sometimes)
|
||||
✅ - static typing
|
||||
❌ - self hosted (maybe better if not? Since rust is fast asf)
|
||||
❌ - multiplatform (~~windows~~, linux and mac)
|
||||
✅ - interop with other languages
|
||||
❌ - package manager
|
||||
❌ - installer
|
||||
|
||||
## Documentation
|
||||
|
||||
The docs are currently are just made in MarkDown.
|
||||
You can find the docs [here](/docs/index.md)
|
||||
|
||||
## Cheatsheet
|
||||
|
||||
Usefull things that i search for a lot in the sourcecode so i added them here
|
||||
|
||||
add them in reverse order in mclang
|
||||
|
||||
Syscall arg order: \[rax ,rdi ,rsi ,rdx ,r10 ,r8 ,r9\]
|
||||
|
||||
## Credits
|
||||
|
||||
[MCotange](https://github.com/MCorange99) - The one and only me, the creator and current maintainer or mclang rev1 and rev2
|
||||
made specifically for xor64 org
|
||||
|
|
|
|||
2
editor/vscode/.gitignore
vendored
2
editor/vscode/.gitignore
vendored
|
|
@ -1,2 +0,0 @@
|
|||
**/*.log
|
||||
**/node_modules/
|
||||
17
editor/vscode/.vscode/launch.json
vendored
17
editor/vscode/.vscode/launch.json
vendored
|
|
@ -1,17 +0,0 @@
|
|||
// A launch configuration that launches the extension inside a new window
|
||||
// Use IntelliSense to learn about possible attributes.
|
||||
// Hover to view descriptions of existing attributes.
|
||||
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
|
||||
{
|
||||
"version": "0.2.0",
|
||||
"configurations": [
|
||||
{
|
||||
"name": "Extension",
|
||||
"type": "extensionHost",
|
||||
"request": "launch",
|
||||
"args": [
|
||||
"--extensionDevelopmentPath=${workspaceFolder}"
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
.vscode/**
|
||||
.vscode-test/**
|
||||
.gitignore
|
||||
vsc-extension-quickstart.md
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
# Change Log
|
||||
|
||||
All notable changes to the "mclang" extension will be documented in this file.
|
||||
|
||||
Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
- Initial release
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
# mclang README
|
||||
|
||||
Code highlghting for mclang 1 and 2
|
||||
|
||||
## Known Issues
|
||||
|
||||
None
|
||||
|
||||
## Release Notes
|
||||
|
||||
Users appreciate release notes as you update your extension.
|
||||
|
||||
### 1.0.0
|
||||
|
||||
Initial release of mclang
|
||||
|
||||
**Enjoy!**
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
{
|
||||
"comments": {
|
||||
// symbol used for single line comment. Remove this entry if your language does not support line comments
|
||||
"lineComment": "//",
|
||||
// symbols used for start and end a block comment. Remove this entry if your language does not support block comments
|
||||
"blockComment": [ "/*", "*/" ]
|
||||
},
|
||||
// symbols used as brackets
|
||||
"brackets": [
|
||||
["{", "}"],
|
||||
["[", "]"],
|
||||
["(", ")"]
|
||||
],
|
||||
// symbols that are auto closed when typing
|
||||
"autoClosingPairs": [
|
||||
["{", "}"],
|
||||
["[", "]"],
|
||||
["(", ")"],
|
||||
["\"", "\""],
|
||||
["'", "'"]
|
||||
],
|
||||
// symbols that can be used to surround a selection
|
||||
"surroundingPairs": [
|
||||
["{", "}"],
|
||||
["[", "]"],
|
||||
["(", ")"],
|
||||
["\"", "\""],
|
||||
["'", "'"]
|
||||
]
|
||||
}
|
||||
Binary file not shown.
|
|
@ -1,42 +0,0 @@
|
|||
{
|
||||
"name": "mclang",
|
||||
"displayName": "mclang",
|
||||
"description": "Code highlighting for mclang",
|
||||
"version": "0.0.3",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git@github.com:mc-lang/mclang2.git"
|
||||
},
|
||||
"engines": {
|
||||
"vscode": "^1.54.0"
|
||||
},
|
||||
"categories": [
|
||||
"Programming Languages"
|
||||
],
|
||||
"contributes": {
|
||||
"languages": [
|
||||
{
|
||||
"id": "mclang",
|
||||
"aliases": [
|
||||
"MCLang",
|
||||
"mclang"
|
||||
],
|
||||
"extensions": [
|
||||
".mcl"
|
||||
],
|
||||
"configuration": "./language-configuration.json"
|
||||
}
|
||||
],
|
||||
"grammars": [
|
||||
{
|
||||
"language": "mclang",
|
||||
"scopeName": "source.mcl",
|
||||
"path": "./syntaxes/mclang.tmLanguage.json"
|
||||
}
|
||||
]
|
||||
},
|
||||
"dependencies": {
|
||||
"generator-code": "^1.7.4",
|
||||
"@vscode/vsce": "^2.15.0"
|
||||
}
|
||||
}
|
||||
|
|
@ -1,147 +0,0 @@
|
|||
{
|
||||
"name": "MCLang",
|
||||
"fileTypes": [
|
||||
"mcl"
|
||||
],
|
||||
"scopeName": "source.mcl",
|
||||
|
||||
"patterns": [
|
||||
{
|
||||
"include": "#errors"
|
||||
},
|
||||
{
|
||||
"include": "#keywords"
|
||||
},
|
||||
{
|
||||
"include": "#definitions"
|
||||
},
|
||||
{
|
||||
"include": "#placeholders"
|
||||
},
|
||||
{
|
||||
"include": "#strings"
|
||||
},
|
||||
{
|
||||
"include": "#comments"
|
||||
},
|
||||
{
|
||||
"include": "#intrinsics"
|
||||
},
|
||||
{
|
||||
"include": "#constants-and-special-vars"
|
||||
}
|
||||
],
|
||||
"repository": {
|
||||
"errors": {
|
||||
"patterns": [
|
||||
{
|
||||
"name": "invalid.illegal",
|
||||
"match": "(?<=^|\\s)(?:const|memory)\\s+(end)(?:$|\\s)"
|
||||
},
|
||||
{
|
||||
"name": "invalid.illegal",
|
||||
"match": "(?<=^|\\s)(?:fn)\\s+(done)(?:$|\\s)"
|
||||
},
|
||||
{
|
||||
"name": "invalid.illegal",
|
||||
"match": "(?<=^|\\s)(memory|const)\\s+\\S*(\\s+|$)end(?:\n|\\s)"
|
||||
},
|
||||
{
|
||||
"name": "invalid.illegal",
|
||||
"match": "(?<=^|\\s)(inline)\\s+(?!fn(\\s|$))"
|
||||
}
|
||||
]
|
||||
},
|
||||
"keywords": {
|
||||
"patterns": [
|
||||
|
||||
{
|
||||
"name": "keyword.declaration.mclang",
|
||||
"match": "(?<=\\s|^)(macro|memory|fn|const|in|inline|include|assert|offset|addr-of|call-like|reset|let|peek|with|returns)(?:\\s|$)"
|
||||
},
|
||||
{
|
||||
"name": "keyword.control.mclang",
|
||||
"match": "(?<=\\s|^)(if|else|elif|end|done|then|while|do|if\\*)(?:\\s|$)"
|
||||
}
|
||||
]
|
||||
},
|
||||
"definitions": {
|
||||
"patterns": [
|
||||
{
|
||||
"name": "support.class.mclang",
|
||||
"match": "(?<=(macro|memory|fn|const)\\s+)(\\S*)"
|
||||
},
|
||||
{
|
||||
"name": "support.class.mclang",
|
||||
"match": "(?<=(let|peek)\\s+)\\S+.*(?=\\s+(in))"
|
||||
}
|
||||
]
|
||||
},
|
||||
"placeholders": {
|
||||
"patterns": [
|
||||
{
|
||||
"name": "markup.italic.mclang",
|
||||
"match": "(?<=(\\s|^))_[\\S]*_(?:(\\s|$))"
|
||||
}
|
||||
]
|
||||
},
|
||||
"strings": {
|
||||
"patterns": [
|
||||
{
|
||||
"name": "string.quoted.double.mclang",
|
||||
"begin": "\"",
|
||||
"end": "\"",
|
||||
"patterns": [
|
||||
{
|
||||
"name": "constant.character.escape.mclang",
|
||||
"match": "\\\\."
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "string.quoted.single.mclang",
|
||||
"begin": "'",
|
||||
"end": "'",
|
||||
"patterns": [
|
||||
{
|
||||
"name": "constant.character.escape.mclang",
|
||||
"match": "\\\\."
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
"comments": {
|
||||
"patterns": [
|
||||
{
|
||||
"name": "constant.other.character-class.regexp",
|
||||
"match": "(?://\\s*)(TODO(O*)|FIXME).*"
|
||||
},
|
||||
{
|
||||
"name": "comment.line.double-slash.mclang",
|
||||
"match": "(//(?!\\s?(TODO(O*)|FIXME)(\\s|:|$)).*|//\\s*)"
|
||||
}
|
||||
]
|
||||
},
|
||||
"intrinsics": {
|
||||
"patterns": [
|
||||
{
|
||||
"name": "variable.name.source.mclang",
|
||||
"match": "(?<=^|\\s)(\\+|-|\\*|int|ptr|bool|addr|any|void|max|divmod|_dbg_print|=|>|<|>=|<=|!=|>>|<<|\\||&|not|dup|swap|drop|over|rot|argc|argv|here|syscall0|syscall1|syscall2|syscall3|syscall4|syscall5|syscall6|\\?\\?\\?)(?=>$|\\s)"
|
||||
}
|
||||
]
|
||||
},
|
||||
"constants-and-special-vars": {
|
||||
"patterns": [
|
||||
{
|
||||
"name": "constant.numeric.mclang",
|
||||
"match": "\\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\\.?[0-9]*)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?)\\b(?!\\$)"
|
||||
},
|
||||
{
|
||||
"name": "entity.name.function.mclang",
|
||||
"match": "(?<=^|\\s)(NULL|true|false|cast(ptr)|cast(int)|cast(bool)|sizeof\\(u64\\)|sizeof\\(u32\\)|sizeof\\(ptr\\)|sizeof\\(bool\\)|sizeof\\(int\\)|sizeof\\(addr\\)|STDIN|STDOUT|STDERR|@ptr|@@ptr|@bool|@int|@addr|!bool|!ptr|!int|!addr|AT_FDCWD|O_RDONLY|O_WRONLY|O_RDWR|O_CREAT|O_TRUNC|O_NONBLOCK|F_SETFL|F_GETFL|EAGAIN|CLOCK_MONOTONIC|TIMER_ABSTIME|MAP_PRIVATE|MAP_ANONYMOUS|PROT_READ|PROT_WRITE|SIGQUIT|timespec\\.tv_sec|timespec\\.tv_nsec|sizeof\\(timespec\\)|ptr\\+|ptr-|ptr!=|ptr=|ptr<|\\+ptr|ptr-diff|sizeof\\(stat\\)|stat\\.st_dev|stat\\.st_ino|stat\\.st_mode|stat\\.st_nlink|stat\\.st_uid|stat\\.st_gid|stat\\.st_rdev|stat\\.st_size|@stat\\.st_size|stat\\.st_blksize|stat\\.st_blocks|stat\\.st_atim|stat\\.st_mtim|stat\\.st_ctim|sizeof\\(stat\\.st_dev\\)|sizeof\\(stat\\.st_ino\\)|sizeof\\(stat\\.st_mode\\)|sizeof\\(stat\\.st_nlink\\)|sizeof\\(stat\\.st_uid\\)|sizeof\\(stat\\.st_gid\\)|sizeof\\(stat\\.st_rdev\\)|sizeof\\(stat\\.st_size\\)|sizeof\\(stat\\.st_blksize\\)|sizeof\\(stat\\.st_blocks\\)|sizeof\\(stat\\.st_atim\\)|sizeof\\(stat\\.st_mtim\\)|sizeof\\(stat\\.st_ctim\\)|write|read|openat|fstat|stat|close|exit|mmap|clock_nanosleep|clock_gettime|fork|getpid|execve|wait4|rename|fcntl|kill|dup2|/|%|mod|div|imod|idiv|emod|nth_argv|lnot|land|lor|inc64-by|inc64|dec64|inc32|dec32|inc8|dec8|swap64|cstrlen|cstreq|cstr-to-str|fputs|puts|eputs|WIFSTOPPED|WIFCONTINUED|WIFSIGNALED|WTERMSIG|WIFEXITED|WEXITSTATUS|offsetof\\(Str\\.count\\)|offsetof\\(Str\\.data\\)|sizeof\\(Str\\)|Str\\.count|Str\\.data|@Str\\.count|@Str\\.data|!Str\\.count|!Str\\.data|@Str|!Str|str-chop-one-left|str-chop-one-right|\\?space|str-trim-left|str-chop-by-predicate|str-chop-by-delim|str-starts-with|\\?str-empty|streq|\\?digit|isdigit|\\?alpha|isalpha|\\?alnum|isalnum|try-parse-int|PUTU_BUFFER_CAP|fputu|fput0u|putu|put0u|eputu|memcpy|memset|srand|RAND_A|RAND_C|rand|getenv|TMP_CAP|tmp-clean|tmp-end|tmp-rewind|tmp-alloc|tmp-str-to-cstr|tmp-append|tmp-append-ptr|execvp|append-item|tmp-utos|map-file|\\?file-exist|\\?shell-safe-char|\\?shell-safe-str|shell-escape|timeit/from-here|1e9|timeit/to-here|str-rfind|dirname|putch|remove-ext|cmd-echoed)(?:\\s|$)"
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,29 +0,0 @@
|
|||
# Welcome to your VS Code Extension
|
||||
|
||||
## What's in the folder
|
||||
|
||||
* This folder contains all of the files necessary for your extension.
|
||||
* `package.json` - this is the manifest file in which you declare your language support and define the location of the grammar file that has been copied into your extension.
|
||||
* `syntaxes/mclang.tmLanguage.json` - this is the Text mate grammar file that is used for tokenization.
|
||||
* `language-configuration.json` - this is the language configuration, defining the tokens that are used for comments and brackets.
|
||||
|
||||
## Get up and running straight away
|
||||
|
||||
* Make sure the language configuration settings in `language-configuration.json` are accurate.
|
||||
* Press `F5` to open a new window with your extension loaded.
|
||||
* Create a new file with a file name suffix matching your language.
|
||||
* Verify that syntax highlighting works and that the language configuration settings are working.
|
||||
|
||||
## Make changes
|
||||
|
||||
* You can relaunch the extension from the debug toolbar after making changes to the files listed above.
|
||||
* You can also reload (`Ctrl+R` or `Cmd+R` on Mac) the VS Code window with your extension to load your changes.
|
||||
|
||||
## Add more language features
|
||||
|
||||
* To add features such as IntelliSense, hovers and validators check out the VS Code extenders documentation at https://code.visualstudio.com/docs
|
||||
|
||||
## Install your extension
|
||||
|
||||
* To start using your extension with Visual Studio Code copy it into the `<user home>/.vscode/extensions` folder and restart Code.
|
||||
* To share your extension with the world, read on https://code.visualstudio.com/docs about publishing an extension.
|
||||
File diff suppressed because it is too large
Load Diff
3
examples/.gitignore
vendored
3
examples/.gitignore
vendored
|
|
@ -1,3 +0,0 @@
|
|||
/*
|
||||
!/.gitignore
|
||||
!/*.mcl
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
include "std.mcl"
|
||||
|
||||
"Henlo World! :3\n" puts
|
||||
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
include "std.mcl"
|
||||
|
||||
macro BOARD_SIZE 100 end
|
||||
|
||||
mem BOARD_SIZE 2 - + 1 @8
|
||||
|
||||
0 while dup BOARD_SIZE 2 - < do
|
||||
0 while dup BOARD_SIZE < do
|
||||
dup mem + !8 if
|
||||
dup mem + BOARD_SIZE + '*' @8
|
||||
else
|
||||
dup mem + BOARD_SIZE + ' ' @8
|
||||
end
|
||||
1 +
|
||||
end
|
||||
|
||||
mem + BOARD_SIZE + '\n' @8
|
||||
|
||||
BOARD_SIZE 1 + mem BOARD_SIZE + puts
|
||||
|
||||
// pattern
|
||||
mem !8 1 shl
|
||||
mem 1 + !8
|
||||
bor
|
||||
|
||||
1 while dup BOARD_SIZE 2 - < do
|
||||
swap 1 shl 7 band
|
||||
over mem + 1 + !8 bor
|
||||
2dup 110 swap shr 1 band
|
||||
swap mem + swap @8
|
||||
swap
|
||||
|
||||
1 +
|
||||
end
|
||||
drop drop
|
||||
|
||||
1 +
|
||||
end
|
||||
drop
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
|
||||
0 while dup 100 < do
|
||||
dup print
|
||||
1 +
|
||||
end
|
||||
|
|
@ -1 +0,0 @@
|
|||
// todo: add some sort of macrow
|
||||
|
|
@ -1,29 +0,0 @@
|
|||
const FS_O_RDONLY 0 end
|
||||
const FS_O_WRONLY 1 end
|
||||
const FS_O_RDWR 2 end
|
||||
|
||||
const FS_O_APPEND 1024 end // append to existing file
|
||||
const FS_O_TRUNC 512 end // if file exists, ovewrite it (careful!)
|
||||
const FS_O_CREAT 64 end // create file if it doesn’t exist
|
||||
|
||||
const FS_O_ASYNC 8192 end // use signal-driven IO
|
||||
const FS_O_CLOEXEC 524288 end // use close-on-exec (avoid race conditions and lock contentions)
|
||||
const FS_O_DIRECT 16384 end // bypass cache (slower)
|
||||
const FS_O_DIRECTORY 65536 end // fail if pathname isn’t a directory
|
||||
const FS_O_DSYNC 4096 end // ensure output is sent to hardware and metadata written before return
|
||||
const FS_O_EXCL 128 end // ensure creation of file
|
||||
const FS_O_LARGEFILE 0 end // allows use of file sizes represented by off64_t
|
||||
const FS_O_NOATIME 262144 end // do not increment access time upon open
|
||||
const FS_O_NOCTTY 256 end // if pathname is a terminal device, don’t become controlling terminal
|
||||
const FS_O_NOFOLLOW 131072 end // fail if pathname is symbolic link
|
||||
const FS_O_NONBLOCK 2048 end // if possible, open file with non-blocking IO
|
||||
const FS_O_NDELAY 2048 end // same as O_NONBLOCK
|
||||
const FS_O_PATH 2097152 end // open descriptor for obtaining permissions and status of a file but does not allow read/write operations
|
||||
const FS_O_SYNC 1052672 end // wait for IO to complete before returning
|
||||
const FS_O_TMPFILE 4259840 end // create an unnamed, unreachable (via any other open call) temporary file
|
||||
|
||||
|
||||
fn fs_read_to_string with int ptr returns int ptr then
|
||||
|
||||
|
||||
done
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
const NULL 0 end
|
||||
const false 0 end
|
||||
const true 1 end
|
||||
|
||||
inline fn div with int int returns int then divmod drop done
|
||||
inline fn mod with int int returns int then divmod swap drop done
|
||||
|
||||
|
||||
inline fn dup2 with any any returns any any any any then over over done
|
||||
inline fn drop2 with any any returns void then drop drop done
|
||||
|
||||
const sizeof(u64) 8 end
|
||||
const sizeof(u32) 4 end
|
||||
const sizeof(u16) 2 end
|
||||
const sizeof(u8) 1 end
|
||||
|
||||
const u64 8 end
|
||||
const u32 4 end
|
||||
const u16 2 end
|
||||
const u8 1 end
|
||||
|
|
@ -1,61 +0,0 @@
|
|||
|
||||
// Write to a file descriptor using the SYS_write syscall
|
||||
// args: [buff_size, buff_ptr, fd]
|
||||
// @arg buff_size: Int - number of bytes to write
|
||||
// @arg buff_ptr: Ptr - pointer to the buffer to write
|
||||
// @arg fd: Int - file descriptor
|
||||
// @ret Int
|
||||
inline fn fwrite with int ptr int returns int then
|
||||
SYS_write syscall3
|
||||
done
|
||||
|
||||
// Write to a file descriptor using the SYS_write syscall
|
||||
// args: [buff_size, buff_ptr, fd]
|
||||
// @arg buff_size: Int - number of bytes to write
|
||||
// @arg buff_ptr: Ptr - pointer to the buffer to write
|
||||
// @arg fd: Int - file descriptor
|
||||
// @ret Int
|
||||
inline fn fread with int ptr int returns int then
|
||||
SYS_read syscall3
|
||||
done
|
||||
|
||||
|
||||
// Write to a file descriptor using the SYS_write syscall
|
||||
// args: [buff_ptr, flags, mode]
|
||||
// @arg buff_ptr: Ptr - File to open
|
||||
// @arg flags: Int - Flags
|
||||
// @arg mode: Int - Mode
|
||||
// @ret Int - Fd
|
||||
inline fn fopen with int ptr int returns int then
|
||||
SYS_open syscall3
|
||||
done
|
||||
|
||||
|
||||
// Print a string to STDOUT
|
||||
// args: [str_size, str_ptr]
|
||||
// @arg buff_size: Int - number of bytes to write
|
||||
// @arg buff_ptr: Ptr - pointer to the buffer to write
|
||||
// @ret NULL
|
||||
inline fn puts with int ptr returns void then
|
||||
STDOUT fwrite drop
|
||||
done
|
||||
|
||||
// Print a string to STDERR
|
||||
// args: [str_size, str_ptr]
|
||||
// @arg buff_size: Int - number of bytes to write
|
||||
// @arg buff_ptr: Ptr - pointer to the buffer to write
|
||||
// @ret NULL
|
||||
inline fn eputs with int ptr returns void then
|
||||
STDOUT fwrite drop
|
||||
done
|
||||
|
||||
// TODO: make putc, eputc, putd, and eputd after we make local mem
|
||||
|
||||
// Exit the program with exit_code
|
||||
// args: [exit_code]
|
||||
// @arg exit_code: Int
|
||||
// @ret NULL/NEVER
|
||||
inline fn exit with int returns void then
|
||||
SYS_exit syscall1 drop
|
||||
done
|
||||
|
||||
|
|
@ -1,322 +0,0 @@
|
|||
|
||||
// file descriptors
|
||||
const STDIN 0 end
|
||||
const STDOUT 1 end
|
||||
const STDERR 2 end
|
||||
|
||||
|
||||
// syscalls
|
||||
const SYS_read 0 end
|
||||
const SYS_write 1 end
|
||||
const SYS_open 2 end
|
||||
const SYS_close 3 end
|
||||
const SYS_stat 4 end
|
||||
const SYS_fstat 5 end
|
||||
const SYS_lstat 6 end
|
||||
const SYS_poll 7 end
|
||||
const SYS_lseek 8 end
|
||||
const SYS_mmap 9 end
|
||||
const SYS_mprotect 10 end
|
||||
const SYS_munmap 11 end
|
||||
const SYS_brk 12 end
|
||||
const SYS_rt_sigaction 13 end
|
||||
const SYS_rt_sigprocmask 14 end
|
||||
const SYS_rt_sigreturn 15 end
|
||||
const SYS_ioctl 16 end
|
||||
const SYS_pread64 17 end
|
||||
const SYS_pwrite64 18 end
|
||||
const SYS_readv 19 end
|
||||
const SYS_writev 20 end
|
||||
const SYS_access 21 end
|
||||
const SYS_pipe 22 end
|
||||
const SYS_select 23 end
|
||||
const SYS_sched_yield 24 end
|
||||
const SYS_mremap 25 end
|
||||
const SYS_msync 26 end
|
||||
const SYS_mincore 27 end
|
||||
const SYS_madvise 28 end
|
||||
const SYS_shmget 29 end
|
||||
const SYS_shmat 30 end
|
||||
const SYS_shmctl 31 end
|
||||
const SYS_dup 32 end
|
||||
const SYS_dup2 33 end
|
||||
const SYS_pause 34 end
|
||||
const SYS_nanosleep 35 end
|
||||
const SYS_getitimer 36 end
|
||||
const SYS_alarm 37 end
|
||||
const SYS_setitimer 38 end
|
||||
const SYS_getpid 39 end
|
||||
const SYS_sendfile 40 end
|
||||
const SYS_socket 41 end
|
||||
const SYS_connect 42 end
|
||||
const SYS_accept 43 end
|
||||
const SYS_sendto 44 end
|
||||
const SYS_recvfrom 45 end
|
||||
const SYS_sendmsg 46 end
|
||||
const SYS_recvmsg 47 end
|
||||
const SYS_shutdown 48 end
|
||||
const SYS_bind 49 end
|
||||
const SYS_listen 50 end
|
||||
const SYS_getsockname 51 end
|
||||
const SYS_getpeername 52 end
|
||||
const SYS_socketpair 53 end
|
||||
const SYS_setsockopt 54 end
|
||||
const SYS_getsockopt 55 end
|
||||
const SYS_clone 56 end
|
||||
const SYS_fork 57 end
|
||||
const SYS_vfork 58 end
|
||||
const SYS_execve 59 end
|
||||
const SYS_exit 60 end
|
||||
const SYS_wait4 61 end
|
||||
const SYS_kill 62 end
|
||||
const SYS_uname 63 end
|
||||
const SYS_semget 64 end
|
||||
const SYS_semop 65 end
|
||||
const SYS_semctl 66 end
|
||||
const SYS_shmdt 67 end
|
||||
const SYS_msgget 68 end
|
||||
const SYS_msgsnd 69 end
|
||||
const SYS_msgrcv 70 end
|
||||
const SYS_msgctl 71 end
|
||||
const SYS_fcntl 72 end
|
||||
const SYS_flock 73 end
|
||||
const SYS_fsync 74 end
|
||||
const SYS_fdatasync 75 end
|
||||
const SYS_truncate 76 end
|
||||
const SYS_ftruncate 77 end
|
||||
const SYS_getdents 78 end
|
||||
const SYS_getcwd 79 end
|
||||
const SYS_chdir 80 end
|
||||
const SYS_fchdir 81 end
|
||||
const SYS_rename 82 end
|
||||
const SYS_mkdir 83 end
|
||||
const SYS_rmdir 84 end
|
||||
const SYS_creat 85 end
|
||||
const SYS_link 86 end
|
||||
const SYS_unlink 87 end
|
||||
const SYS_symlink 88 end
|
||||
const SYS_readlink 89 end
|
||||
const SYS_chmod 90 end
|
||||
const SYS_fchmod 91 end
|
||||
const SYS_chown 92 end
|
||||
const SYS_fchown 93 end
|
||||
const SYS_lchown 94 end
|
||||
const SYS_umask 95 end
|
||||
const SYS_gettimeofday 96 end
|
||||
const SYS_getrlimit 97 end
|
||||
const SYS_getrusage 98 end
|
||||
const SYS_sysinfo 99 end
|
||||
const SYS_times 100 end
|
||||
const SYS_ptrace 101 end
|
||||
const SYS_getuid 102 end
|
||||
const SYS_syslog 103 end
|
||||
const SYS_getgid 104 end
|
||||
const SYS_setuid 105 end
|
||||
const SYS_setgid 106 end
|
||||
const SYS_geteuid 107 end
|
||||
const SYS_getegid 108 end
|
||||
const SYS_setpgid 109 end
|
||||
const SYS_getppid 110 end
|
||||
const SYS_getpgrp 111 end
|
||||
const SYS_setsid 112 end
|
||||
const SYS_setreuid 113 end
|
||||
const SYS_setregid 114 end
|
||||
const SYS_getgroups 115 end
|
||||
const SYS_setgroups 116 end
|
||||
const SYS_setresuid 117 end
|
||||
const SYS_getresuid 118 end
|
||||
const SYS_setresgid 119 end
|
||||
const SYS_getresgid 120 end
|
||||
const SYS_getpgid 121 end
|
||||
const SYS_setfsuid 122 end
|
||||
const SYS_setfsgid 123 end
|
||||
const SYS_getsid 124 end
|
||||
const SYS_capget 125 end
|
||||
const SYS_capset 126 end
|
||||
const SYS_rt_sigpending 127 end
|
||||
const SYS_rt_sigtimedwait 128 end
|
||||
const SYS_rt_sigqueueinfo 129 end
|
||||
const SYS_rt_sigsuspend 130 end
|
||||
const SYS_sigaltstack 131 end
|
||||
const SYS_utime 132 end
|
||||
const SYS_mknod 133 end
|
||||
const SYS_uselib 134 end
|
||||
const SYS_personality 135 end
|
||||
const SYS_ustat 136 end
|
||||
const SYS_statfs 137 end
|
||||
const SYS_fstatfs 138 end
|
||||
const SYS_sysfs 139 end
|
||||
const SYS_getpriority 140 end
|
||||
const SYS_setpriority 141 end
|
||||
const SYS_sched_setparam 142 end
|
||||
const SYS_sched_getparam 143 end
|
||||
const SYS_sched_setscheduler 144 end
|
||||
const SYS_sched_getscheduler 145 end
|
||||
const SYS_sched_get_priority_max 146 end
|
||||
const SYS_sched_get_priority_min 147 end
|
||||
const SYS_sched_rr_get_interval 148 end
|
||||
const SYS_mlock 149 end
|
||||
const SYS_munlock 150 end
|
||||
const SYS_mlockall 151 end
|
||||
const SYS_munlockall 152 end
|
||||
const SYS_vhangup 153 end
|
||||
const SYS_modify_ldt 154 end
|
||||
const SYS_pivot_root 155 end
|
||||
const SYS__sysctl 156 end
|
||||
const SYS_prctl 157 end
|
||||
const SYS_arch_prctl 158 end
|
||||
const SYS_adjtimex 159 end
|
||||
const SYS_setrlimit 160 end
|
||||
const SYS_chroot 161 end
|
||||
const SYS_sync 162 end
|
||||
const SYS_acct 163 end
|
||||
const SYS_settimeofday 164 end
|
||||
const SYS_mount 165 end
|
||||
const SYS_umount2 166 end
|
||||
const SYS_swapon 167 end
|
||||
const SYS_swapoff 168 end
|
||||
const SYS_reboot 169 end
|
||||
const SYS_sethostname 170 end
|
||||
const SYS_setdomainname 171 end
|
||||
const SYS_iopl 172 end
|
||||
const SYS_ioperm 173 end
|
||||
const SYS_create_module 174 end
|
||||
const SYS_init_module 175 end
|
||||
const SYS_delete_module 176 end
|
||||
const SYS_get_kernel_syms 177 end
|
||||
const SYS_query_module 178 end
|
||||
const SYS_quotactl 179 end
|
||||
const SYS_nfsservctl 180 end
|
||||
const SYS_getpmsg 181 end
|
||||
const SYS_putpmsg 182 end
|
||||
const SYS_afs_syscall 183 end
|
||||
const SYS_tuxcall 184 end
|
||||
const SYS_security 185 end
|
||||
const SYS_gettid 186 end
|
||||
const SYS_readahead 187 end
|
||||
const SYS_setxattr 188 end
|
||||
const SYS_lsetxattr 189 end
|
||||
const SYS_fsetxattr 190 end
|
||||
const SYS_getxattr 191 end
|
||||
const SYS_lgetxattr 192 end
|
||||
const SYS_fgetxattr 193 end
|
||||
const SYS_listxattr 194 end
|
||||
const SYS_llistxattr 195 end
|
||||
const SYS_flistxattr 196 end
|
||||
const SYS_removexattr 197 end
|
||||
const SYS_lremovexattr 198 end
|
||||
const SYS_fremovexattr 199 end
|
||||
const SYS_tkill 200 end
|
||||
const SYS_time 201 end
|
||||
const SYS_futex 202 end
|
||||
const SYS_sched_setaffinity 203 end
|
||||
const SYS_sched_getaffinity 204 end
|
||||
const SYS_set_thread_area 205 end
|
||||
const SYS_io_setup 206 end
|
||||
const SYS_io_destroy 207 end
|
||||
const SYS_io_getevents 208 end
|
||||
const SYS_io_submit 209 end
|
||||
const SYS_io_cancel 210 end
|
||||
const SYS_get_thread_area 211 end
|
||||
const SYS_lookup_dcookie 212 end
|
||||
const SYS_epoll_create 213 end
|
||||
const SYS_epoll_ctl_old 214 end
|
||||
const SYS_epoll_wait_old 215 end
|
||||
const SYS_remap_file_pages 216 end
|
||||
const SYS_getdents64 217 end
|
||||
const SYS_set_tid_address 218 end
|
||||
const SYS_restart_syscall 219 end
|
||||
const SYS_semtimedop 220 end
|
||||
const SYS_fadvise64 221 end
|
||||
const SYS_timer_create 222 end
|
||||
const SYS_timer_settime 223 end
|
||||
const SYS_timer_gettime 224 end
|
||||
const SYS_timer_getoverrun 225 end
|
||||
const SYS_timer_delete 226 end
|
||||
const SYS_clock_settime 227 end
|
||||
const SYS_clock_gettime 228 end
|
||||
const SYS_clock_getres 229 end
|
||||
const SYS_clock_nanosleep 230 end
|
||||
const SYS_exit_group 231 end
|
||||
const SYS_epoll_wait 232 end
|
||||
const SYS_epoll_ctl 233 end
|
||||
const SYS_tgkill 234 end
|
||||
const SYS_utimes 235 end
|
||||
const SYS_vserver 236 end
|
||||
const SYS_mbind 237 end
|
||||
const SYS_set_mempolicy 238 end
|
||||
const SYS_get_mempolicy 239 end
|
||||
const SYS_mq_open 240 end
|
||||
const SYS_mq_unlink 241 end
|
||||
const SYS_mq_timedsend 242 end
|
||||
const SYS_mq_timedreceive 243 end
|
||||
const SYS_mq_notify 244 end
|
||||
const SYS_mq_getsetattr 245 end
|
||||
const SYS_kexec_load 246 end
|
||||
const SYS_waitid 247 end
|
||||
const SYS_add_key 248 end
|
||||
const SYS_request_key 249 end
|
||||
const SYS_keyctl 250 end
|
||||
const SYS_ioprio_set 251 end
|
||||
const SYS_ioprio_get 252 end
|
||||
const SYS_inotify_init 253 end
|
||||
const SYS_inotify_add_watch 254 end
|
||||
const SYS_inotify_rm_watch 255 end
|
||||
const SYS_migrate_pages 256 end
|
||||
const SYS_openat 257 end
|
||||
const SYS_mkdirat 258 end
|
||||
const SYS_mknodat 259 end
|
||||
const SYS_fchownat 260 end
|
||||
const SYS_futimesat 261 end
|
||||
const SYS_newfstatat 262 end
|
||||
const SYS_unlinkat 263 end
|
||||
const SYS_renameat 264 end
|
||||
const SYS_linkat 265 end
|
||||
const SYS_symlinkat 266 end
|
||||
const SYS_readlinkat 267 end
|
||||
const SYS_fchmodat 268 end
|
||||
const SYS_faccessat 269 end
|
||||
const SYS_pselect6 270 end
|
||||
const SYS_ppoll 271 end
|
||||
const SYS_unshare 272 end
|
||||
const SYS_set_robust_list 273 end
|
||||
const SYS_get_robust_list 274 end
|
||||
const SYS_splice 275 end
|
||||
const SYS_tee 276 end
|
||||
const SYS_sync_file_range 277 end
|
||||
const SYS_vmsplice 278 end
|
||||
const SYS_move_pages 279 end
|
||||
const SYS_utimensat 280 end
|
||||
const SYS_epoll_pwait 281 end
|
||||
const SYS_signalfd 282 end
|
||||
const SYS_timerfd_create 283 end
|
||||
const SYS_eventfd 284 end
|
||||
const SYS_fallocate 285 end
|
||||
const SYS_timerfd_settime 286 end
|
||||
const SYS_timerfd_gettime 287 end
|
||||
const SYS_accept4 288 end
|
||||
const SYS_signalfd4 289 end
|
||||
const SYS_eventfd2 290 end
|
||||
const SYS_epoll_create1 291 end
|
||||
const SYS_dup3 292 end
|
||||
const SYS_pipe2 293 end
|
||||
const SYS_inotify_init1 294 end
|
||||
const SYS_preadv 295 end
|
||||
const SYS_pwritev 296 end
|
||||
const SYS_rt_tgsigqueueinfo 297 end
|
||||
const SYS_perf_event_open 298 end
|
||||
const SYS_recvmmsg 299 end
|
||||
const SYS_fanotify_init 300 end
|
||||
const SYS_fanotify_mark 301 end
|
||||
const SYS_prlimit64 302 end
|
||||
const SYS_name_to_handle_at 303 end
|
||||
const SYS_open_by_handle_at 304 end
|
||||
const SYS_clock_adjtime 305 end
|
||||
const SYS_syncfs 306 end
|
||||
const SYS_sendmmsg 307 end
|
||||
const SYS_setns 308 end
|
||||
const SYS_getcpu 309 end
|
||||
const SYS_process_vm_readv 310 end
|
||||
const SYS_process_vm_writev 311 end
|
||||
const SYS_kcmp 312 end
|
||||
const SYS_finit_module 313 end
|
||||
|
|
@ -1 +0,0 @@
|
|||
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
include "linux.mcl"
|
||||
include "io.mcl"
|
||||
include "util.mcl"
|
||||
include "int.mcl"
|
||||
include "fs.mcl"
|
||||
include "compat.mcl"
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
|
||||
|
||||
fn cstr_len with ptr returns int then
|
||||
dup while dup load8 '\0' != do 1 + end swap -
|
||||
done
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
|
||||
// Assert implementation
|
||||
// args: [condition, str_len, str_ptr]
|
||||
// @arg condition: Bool
|
||||
// @arg str_len: Int
|
||||
// @arg str_ptr: Ptr
|
||||
// @ret NULL/NEVER
|
||||
fn assert with bool int ptr returns void then
|
||||
rot
|
||||
if else
|
||||
"Assert failed: \"" eputs eputs
|
||||
"\". Exiting!\n" eputs
|
||||
1 exit
|
||||
end
|
||||
done
|
||||
23
lib/make.mk
Normal file
23
lib/make.mk
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
|
||||
|
||||
#? Sample library build recipe:
|
||||
#? Prefferably put this in the lib directory
|
||||
|
||||
#? The onlu thing needed for root makefile, you can build it another way if u want
|
||||
# LIBS += bin/lib/libmc.a
|
||||
#
|
||||
# libmc_src = $(wildcard lib/libmc/src/*.c)
|
||||
# libmc_obj = $(patsubst lib/libmc/src/%.c,bin/lib/libmc/%.c.o,$(libmc_src))
|
||||
#
|
||||
# bin/lib/libmc.a: $(libmc_obj)
|
||||
# @mkdir -p $(dir $@)
|
||||
# ar rcs $@ $^
|
||||
#
|
||||
# bin/lib/libmc/%.c.o: lib/libmc/src/%.c
|
||||
# @mkdir -p $(dir $@)
|
||||
# $(CC) -c -o $@ $<
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
4
playground/.gitignore
vendored
4
playground/.gitignore
vendored
|
|
@ -1,4 +0,0 @@
|
|||
/*
|
||||
!/.gitignore
|
||||
!/*.mcl
|
||||
!/mclangc
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
#!/usr/bin/bash
|
||||
|
||||
#? This is just a passthrough for the compiled mclangc binary for ease of use
|
||||
#? It also compiles mclangc every time its ran
|
||||
|
||||
pushd ../ > /dev/null
|
||||
|
||||
cargo build --release -q
|
||||
|
||||
popd > /dev/null
|
||||
|
||||
|
||||
../target/release/mclangc -I../include ${@:1}
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
include "std.mcl"
|
||||
|
||||
|
||||
struct StatDef do
|
||||
val -> u32
|
||||
val2 -> i8
|
||||
end
|
||||
|
||||
alloc Stat StatDef end
|
||||
|
||||
fn main with int ptr returns void then
|
||||
// p l
|
||||
"Hello!\n" puts
|
||||
|
||||
Stat.val 69 write32
|
||||
|
||||
Stat.val read32 _dbg_print
|
||||
Stat.__size read32 _dbg_print
|
||||
|
||||
// memory fd 4 end
|
||||
|
||||
// NULL
|
||||
// FS_O_RDWR
|
||||
// c"/home/mcorange/@Projects/rust/programming_languages/mclang/mclangc/playground/test.mcl"
|
||||
// fopen
|
||||
// dup _dbg_print
|
||||
// fd swap write32
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
done
|
||||
|
|
@ -1,171 +0,0 @@
|
|||
|
||||
use std::path::{PathBuf, Path};
|
||||
use std::process::Stdio;
|
||||
use std::{process, fs};
|
||||
use clap::Parser;
|
||||
use anyhow::{Result, bail};
|
||||
|
||||
pub mod color {
|
||||
#![allow(dead_code)]
|
||||
pub const NONE: &str = "\x1b[0m";
|
||||
pub const RESET: &str = "\x1b[0m";
|
||||
pub const BRIGHT: &str = "\x1b[1m";
|
||||
pub const DIM: &str = "\x1b[2m";
|
||||
pub const UNDERSCORE: &str = "\x1b[4m";
|
||||
pub const BLINK: &str = "\x1b[5m";
|
||||
pub const REVERSE: &str = "\x1b[7m";
|
||||
pub const HIDDEN: &str = "\x1b[8m";
|
||||
pub const FG_BLACK: &str = "\x1b[30m";
|
||||
pub const FG_RED: &str = "\x1b[31m";
|
||||
pub const FG_GREEN: &str = "\x1b[32m";
|
||||
pub const FG_YELLOW: &str = "\x1b[33m";
|
||||
pub const FG_BLUE: &str = "\x1b[34m";
|
||||
pub const FG_MAGENTA: &str = "\x1b[35m";
|
||||
pub const FG_CYAN: &str = "\x1b[36m";
|
||||
pub const FG_WHITE: &str = "\x1b[37m";
|
||||
pub const BG_BLACK: &str = "\x1b[40m";
|
||||
pub const BG_RED: &str = "\x1b[41m";
|
||||
pub const BG_GREEN: &str = "\x1b[42m";
|
||||
pub const BG_YELLOW: &str = "\x1b[43m";
|
||||
pub const BG_BLUE: &str = "\x1b[44m";
|
||||
pub const BG_MAGENTA: &str = "\x1b[45m";
|
||||
pub const BG_CYAN: &str = "\x1b[46m";
|
||||
pub const BG_WHITE: &str = "\x1b[47m";
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
#[derive(Debug)]
|
||||
struct TestOutput {
|
||||
stdout: String,
|
||||
stderr: String,
|
||||
stdin: String,
|
||||
status: i32
|
||||
}
|
||||
|
||||
fn run_test<P: Into<PathBuf> + std::convert::AsRef<std::ffi::OsStr>>(f_in: PathBuf, f_out: &PathBuf, compiler: P, compile_mode: bool, stdin: String) -> Result<TestOutput> {
|
||||
let mut command = process::Command::new(compiler);
|
||||
command.stdout(Stdio::piped());
|
||||
command.stderr(Stdio::piped());
|
||||
if compile_mode {
|
||||
command.arg("-cqr");
|
||||
} else {
|
||||
command.arg("-sq");
|
||||
}
|
||||
|
||||
command.arg("-i");
|
||||
command.arg(f_in);
|
||||
command.arg("-o");
|
||||
command.arg(f_out);
|
||||
|
||||
let child = command.spawn()?;
|
||||
|
||||
let out = child.wait_with_output()?;
|
||||
|
||||
let stdout = out.stdout.iter().map(|c| {
|
||||
char::from_u32(u32::from(*c)).expect("Failed to parse stdout char").to_string()
|
||||
}).collect::<String>();
|
||||
|
||||
let stderr = out.stderr.iter().map(|c| {
|
||||
char::from_u32(u32::from(*c)).expect("Failed to parse stderr char").to_string()
|
||||
}).collect::<String>();
|
||||
|
||||
|
||||
Ok(TestOutput {
|
||||
stdout,
|
||||
stderr,
|
||||
stdin,
|
||||
status: out.status.code().unwrap()
|
||||
})
|
||||
}
|
||||
|
||||
fn run_tests(args: Args) -> Result<()>{
|
||||
|
||||
let files = fs::read_dir(args.input)?;
|
||||
|
||||
for file in files {
|
||||
let file = file?;
|
||||
let f_name = file.file_name().to_string_lossy().to_string();
|
||||
let f_out = PathBuf::from(&args.output).join(f_name);
|
||||
|
||||
|
||||
let intp = run_test(file.path(), &f_out, &args.compiler_path, false, String::new())?;
|
||||
let comp = run_test(file.path(), &f_out, &args.compiler_path, true, String::new())?;
|
||||
compare_results(&intp, &comp, &file.path())?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
fn compare_results(intp: &TestOutput, comp: &TestOutput, f_in: &Path) -> Result<()> {
|
||||
|
||||
if intp.stdout != comp.stdout {
|
||||
println!("{b}[ {r}ERR{rs}{b} ]{rs} {f} compiled and interpreted stdout versions differ", r=color::FG_RED, rs=color::RESET, b=color::BRIGHT, f=f_in.display());
|
||||
println!("compiled:\n{}", comp.stdout);
|
||||
println!("interpreted:\n{}", intp.stdout);
|
||||
bail!("Testing failed");
|
||||
}
|
||||
|
||||
if intp.stderr != comp.stderr {
|
||||
println!("{b}[ {r}ERR{rs}{b} ]{rs} {f} compiled and interpreted stderr versions differ", r=color::FG_RED, rs=color::RESET, b=color::BRIGHT, f=f_in.display());
|
||||
println!("compiled:\n{}", comp.stderr);
|
||||
println!("interpreted:\n{}", intp.stderr);
|
||||
bail!("Testing failed");
|
||||
}
|
||||
|
||||
if intp.status != comp.status {
|
||||
println!("{b}[ {r}ERR{rs}{b} ]{rs} {f} compiled and interpreted status codes differ", r=color::FG_RED, rs=color::RESET, b=color::BRIGHT, f=f_in.display());
|
||||
println!("compiled:\n{}", comp.status);
|
||||
println!("interpreted:\n{}", intp.status);
|
||||
bail!("Testing failed");
|
||||
}
|
||||
|
||||
println!("{b}[ {g}OK{rs}{b} ]{rs} {f} ", g=color::FG_GREEN, rs=color::RESET, b=color::BRIGHT, f=f_in.display());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[derive(Parser, Debug, Clone)]
|
||||
#[command(author, version, about, long_about = None)]
|
||||
struct Args {
|
||||
|
||||
/// Mode, allowed modes: test, record
|
||||
#[arg(long, short)]
|
||||
mode: String,
|
||||
|
||||
/// Use compile mode
|
||||
#[arg(long, short)]
|
||||
compile: bool,
|
||||
|
||||
/// Use interpret mode
|
||||
#[arg(long, short='s')]
|
||||
interpret: bool,
|
||||
|
||||
/// Output folder
|
||||
#[arg(long, short, default_value_t=String::from("./target/mcl_test_dev"))]
|
||||
output: String,
|
||||
|
||||
/// Input folder
|
||||
#[arg(long, short, default_value_t=String::from("./tests"))]
|
||||
input: String,
|
||||
|
||||
/// Compiler path
|
||||
#[arg(long, short, default_value_t=String::from("./target/release/mclangc"))]
|
||||
compiler_path: String
|
||||
|
||||
|
||||
}
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let args = Args::parse();
|
||||
fs::create_dir_all(&args.output)?;
|
||||
match args.mode.as_str() {
|
||||
"test" => run_tests(args),
|
||||
"record" => todo!("Implement test result recording"),
|
||||
s => {
|
||||
eprintln!("Unknown mode '{s}'");
|
||||
bail!("Bad subcommand");
|
||||
}
|
||||
}?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
72
src/cliargs.c
Normal file
72
src/cliargs.c
Normal file
|
|
@ -0,0 +1,72 @@
|
|||
#include "cliargs.h"
|
||||
#include "dyn_arr.h"
|
||||
#include <bits/getopt_core.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
|
||||
void print_help(char*);
|
||||
void print_version(char*);
|
||||
|
||||
DEFINE_DA_IMPL(string, char*);
|
||||
|
||||
cliargs_t* parse_cliargs(int argc, char** argv) {
|
||||
int optidx = 0;
|
||||
int opt;
|
||||
char* progname = argv[0];
|
||||
|
||||
if (argc <= 1) {
|
||||
print_help(progname);
|
||||
}
|
||||
|
||||
cliargs_t* cliargs = malloc(sizeof(cliargs_t));
|
||||
assert(cliargs && "Out of memory");
|
||||
|
||||
while ((opt = getopt_long(argc, argv, "hvo:d", cli_options, &optidx)) != -1) {
|
||||
switch (opt) {
|
||||
case 'h':
|
||||
print_help(progname);
|
||||
break;
|
||||
case 'v':
|
||||
print_version(progname);
|
||||
break;
|
||||
case 'o':
|
||||
cliargs->output = optarg;
|
||||
break;
|
||||
case 'd':
|
||||
cliargs->debug = true;
|
||||
break;
|
||||
default: /* '?' */
|
||||
print_help(progname);
|
||||
exit(EXIT_FAILURE);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = optind; i < argc; i++) {
|
||||
mcl_da_string_push(&cliargs->input, argv[i]);
|
||||
}
|
||||
|
||||
return cliargs;
|
||||
}
|
||||
|
||||
void print_help(char* progname) {
|
||||
printf(
|
||||
"Usage: %s [-v|--version] [-h|--help] [-d|--debug] [-o|--output OUTPUT] [INPUT]\n"
|
||||
" --version, -v - Prints the current version\n"
|
||||
" --help, -h - Shows this text\n"
|
||||
" --debug, -d - Prints extra information\n"
|
||||
" --output, -o - Output file for compilation\n"
|
||||
"\n"
|
||||
"%s Copyright (C) 2024 MCorange<mcorange@mcorangehq.xyz>\n"
|
||||
"This program comes with ABSOLUTELY NO WARRANTY.\n"
|
||||
"This is free software, and you are welcome to redistribute it\n"
|
||||
"under certain conditions\n"
|
||||
, progname, progname);
|
||||
exit(0);
|
||||
}
|
||||
|
||||
void print_version(char* progname) {
|
||||
printf("%s: The very epic compiler %s\n", progname, MCL_VERSION);
|
||||
exit(0);
|
||||
}
|
||||
|
|
@ -1,93 +0,0 @@
|
|||
use std::path::{PathBuf, Path};
|
||||
use std::process::{Command, Stdio};
|
||||
use anyhow::Result;
|
||||
use crate::{info, error};
|
||||
|
||||
pub fn linux_x86_64_compile_and_link(of_a: &Path, of_o: &Path, of_c: &Path, quiet: bool) -> Result<()> {
|
||||
|
||||
let nasm_args = [
|
||||
"-felf64",
|
||||
of_a.to_str().unwrap(),
|
||||
"-o",
|
||||
of_o.to_str().unwrap()
|
||||
];
|
||||
|
||||
let ld_args = [
|
||||
of_o.to_str().unwrap(),
|
||||
"-o",
|
||||
of_c.to_str().unwrap()
|
||||
];
|
||||
|
||||
|
||||
let mut proc = if cfg!(target_os = "windows") {
|
||||
return Ok(());
|
||||
} else {
|
||||
let ret = Command::new("nasm")
|
||||
.args(nasm_args)
|
||||
.stdout(Stdio::inherit())
|
||||
.stderr(Stdio::inherit())
|
||||
.spawn();
|
||||
|
||||
if ret.is_err() {
|
||||
error!("Nasm not installed")
|
||||
}
|
||||
ret?
|
||||
};
|
||||
if !quiet {
|
||||
info!("running 'nasm {}'", nasm_args.join(" "));
|
||||
}
|
||||
let exit = proc.wait()?;
|
||||
|
||||
if !quiet {
|
||||
info!("nasm process exited with code {}", exit);
|
||||
}
|
||||
|
||||
|
||||
let mut proc2 = if cfg!(target_os = "windows") {
|
||||
return Ok(());
|
||||
} else {
|
||||
Command::new("ld")
|
||||
.args(ld_args)
|
||||
.stdout(Stdio::inherit())
|
||||
.stderr(Stdio::inherit())
|
||||
.spawn()?
|
||||
};
|
||||
if !quiet {
|
||||
info!("running 'ld {}'", ld_args.join(" "));
|
||||
}
|
||||
let exit2 = proc2.wait()?;
|
||||
if !quiet {
|
||||
info!("ld process exited with code {}", exit2);
|
||||
}
|
||||
|
||||
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn linux_x86_64_run(bin: &Path, args: &[String], quiet: bool) -> Result<i32> {
|
||||
|
||||
let bin = PathBuf::from(
|
||||
format!("./{}", bin.to_string_lossy())
|
||||
);
|
||||
|
||||
let mut proc = if cfg!(target_os = "windows") {
|
||||
return Ok(0);
|
||||
} else {
|
||||
Command::new(bin.clone())
|
||||
.args(args)
|
||||
.stdout(Stdio::inherit())
|
||||
.stderr(Stdio::inherit())
|
||||
.spawn()?
|
||||
};
|
||||
// println!("{}", quiet);
|
||||
if !quiet {
|
||||
info!("running {} {}", bin.to_string_lossy(), args.join(" "));
|
||||
}
|
||||
let exit = proc.wait()?;
|
||||
if !quiet {
|
||||
info!("{} process exited with code {}", bin.to_string_lossy(), exit);
|
||||
}
|
||||
|
||||
Ok(exit.code().unwrap_or(0))
|
||||
}
|
||||
|
|
@ -1,536 +0,0 @@
|
|||
use std::{fs, path::PathBuf, io::{Write, BufWriter}, collections::HashMap};
|
||||
use crate::{definitions::*, Args, warn, lerror};
|
||||
use crate::compile::commands::linux_x86_64_compile_and_link;
|
||||
use crate::definitions::InstructionType;
|
||||
use super::{commands::linux_x86_64_run, Constant, Memory, Function};
|
||||
|
||||
use anyhow::{Result, bail};
|
||||
|
||||
|
||||
pub fn compile(program: &Program, args: &Args) -> Result<i32>{
|
||||
let debug = args.get_opt_level()? < 1;
|
||||
|
||||
let mut of_c = PathBuf::from(&args.out_file);
|
||||
let (mut of_o, mut of_a) = if args.out_file == *crate::DEFAULT_OUT_FILE {
|
||||
let of_o = PathBuf::from("/tmp/mclang_comp.o");
|
||||
let of_a = PathBuf::from("/tmp/mclang_comp.nasm");
|
||||
(of_o, of_a)
|
||||
} else {
|
||||
let of_o = PathBuf::from(&args.out_file);
|
||||
let of_a = PathBuf::from(&args.out_file);
|
||||
(of_o, of_a)
|
||||
};
|
||||
|
||||
of_c.set_extension("");
|
||||
of_o.set_extension("o");
|
||||
of_a.set_extension("nasm");
|
||||
|
||||
let mut should_push_ret = false;
|
||||
|
||||
let file = fs::File::create(&of_a)?;
|
||||
let mut writer = BufWriter::new(&file);
|
||||
let mut memories: Vec<Memory> = Vec::new();
|
||||
let mut constants: HashMap<String, Constant> = HashMap::new();
|
||||
let mut functions: Vec<Function> = Vec::new();
|
||||
|
||||
let mut alloced_structs: Vec<(String, String)> = Vec::new();
|
||||
// println!("{}", tokens.len());
|
||||
let mut strings: Vec<String> = Vec::new();
|
||||
|
||||
writeln!(writer, "BITS 64")?;
|
||||
writeln!(writer, "segment .text")?;
|
||||
|
||||
writeln!(writer, "{}", super::MACRO_DEFINITIONS)?;
|
||||
writeln!(writer, "{}", super::DBG_PRINT)?;
|
||||
|
||||
|
||||
if !crate::config::ENABLE_EXPORTED_FUNCTIONS && !args.lib_mode {
|
||||
writeln!(writer, "global _start")?;
|
||||
writeln!(writer, "_start:")?;
|
||||
writeln!(writer, " lea rbp, [rel ret_stack]")?;
|
||||
writeln!(writer, " call main")?;
|
||||
writeln!(writer, " jmp end")?;
|
||||
}
|
||||
|
||||
|
||||
let mut ti = 0;
|
||||
while ti < program.ops.len() {
|
||||
let token = &program.ops[ti];
|
||||
if debug {
|
||||
writeln!(writer, "addr_{ti}:")?;
|
||||
if token.typ == OpType::Instruction(InstructionType::PushInt) {
|
||||
writeln!(writer, " ;; -- {:?} {}", token.typ, token.value)?;
|
||||
} else if token.typ == OpType::Instruction(InstructionType::PushStr) {
|
||||
writeln!(writer, " ;; -- {:?} {}", token.typ, token.text.escape_debug())?;
|
||||
} else {
|
||||
writeln!(writer, " ;; -- {:?}", token.typ)?;
|
||||
}
|
||||
} else {
|
||||
if ti > 0 {
|
||||
if program.ops[ti-1].typ == OpType::Keyword(KeywordType::Else) ||
|
||||
program.ops[ti-1].typ == OpType::Keyword(KeywordType::End){
|
||||
writeln!(writer, "addr_{ti}:")?;
|
||||
}
|
||||
}
|
||||
|
||||
if ti + 1 < program.ops.len() && program.ops[ti+1].typ == OpType::Keyword(KeywordType::End) {
|
||||
writeln!(writer, "addr_{ti}:")?;
|
||||
}
|
||||
|
||||
if let OpType::Keyword(keyword) = &token.typ {
|
||||
match keyword {
|
||||
&KeywordType::End |
|
||||
&KeywordType::While => {
|
||||
writeln!(writer, "addr_{ti}:")?;
|
||||
}
|
||||
_ => ()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
match token.typ.clone() {
|
||||
// stack
|
||||
|
||||
OpType::Instruction(instruction) => {
|
||||
match instruction {
|
||||
InstructionType::PushInt => {
|
||||
writeln!(writer, " OP_PushInt {}", token.value)?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::PushStr => {
|
||||
writeln!(writer, " OP_PushStr {}, str_{}", token.text.len(), strings.len())?;
|
||||
strings.push(token.text.clone());
|
||||
ti += 1;
|
||||
}
|
||||
InstructionType::PushCStr => {
|
||||
writeln!(writer, " OP_PushCStr str_{}", strings.len())?;
|
||||
strings.push(token.text.clone());
|
||||
ti += 1;
|
||||
}
|
||||
InstructionType::Drop => {
|
||||
writeln!(writer, " OP_Drop")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Print => {
|
||||
writeln!(writer, " OP_Print")?;
|
||||
ti += 1;
|
||||
},
|
||||
|
||||
InstructionType::Dup => {
|
||||
writeln!(writer, " OP_Dup")?;
|
||||
ti += 1;
|
||||
},
|
||||
|
||||
InstructionType::Rot => {
|
||||
writeln!(writer, " OP_Rot")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Swap => {
|
||||
writeln!(writer, " OP_Swap")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Over => {
|
||||
writeln!(writer, " OP_Over")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Read8 => {
|
||||
writeln!(writer, " OP_Load8")?;
|
||||
ti += 1;
|
||||
}
|
||||
|
||||
InstructionType::Write8 => {
|
||||
writeln!(writer, " OP_Store8")?;
|
||||
ti += 1;
|
||||
}
|
||||
InstructionType::Read32 => {
|
||||
writeln!(writer, " OP_Load32")?;
|
||||
ti += 1;
|
||||
}
|
||||
|
||||
InstructionType::Write32 => {
|
||||
writeln!(writer, " OP_Store32")?;
|
||||
ti += 1;
|
||||
}
|
||||
InstructionType::Read64 => {
|
||||
writeln!(writer, " OP_Load64")?;
|
||||
ti += 1;
|
||||
}
|
||||
|
||||
InstructionType::Write64 => {
|
||||
writeln!(writer, " OP_Store64")?;
|
||||
ti += 1;
|
||||
}
|
||||
|
||||
// math
|
||||
InstructionType::Plus => {
|
||||
writeln!(writer, " OP_Plus")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Minus => {
|
||||
writeln!(writer, " OP_Minus")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Equals => {
|
||||
writeln!(writer, " OP_Equals")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Lt => {
|
||||
writeln!(writer, " OP_Lt")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Gt => {
|
||||
writeln!(writer, " OP_Gt")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::NotEquals => {
|
||||
writeln!(writer, " OP_NotEquals")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Le => {
|
||||
writeln!(writer, " OP_Le")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Ge => {
|
||||
writeln!(writer, " OP_Ge")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Band => {
|
||||
writeln!(writer, " OP_Band")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Bor => {
|
||||
writeln!(writer, " OP_Bor")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Shr => {
|
||||
writeln!(writer, " OP_Shr")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Shl => {
|
||||
writeln!(writer, " OP_Shl")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::DivMod => {
|
||||
writeln!(writer, " OP_DivMod")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Mul => {
|
||||
writeln!(writer, " OP_Mul")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Syscall0 => {
|
||||
writeln!(writer, " OP_Syscall0")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Syscall1 => {
|
||||
writeln!(writer, " OP_Syscall1")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Syscall2 => {
|
||||
writeln!(writer, " OP_Syscall2")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Syscall3 => {
|
||||
writeln!(writer, " OP_Syscall3")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Syscall4 => {
|
||||
writeln!(writer, " OP_Syscall4")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Syscall5 => {
|
||||
writeln!(writer, " OP_Syscall5")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Syscall6 => {
|
||||
writeln!(writer, " OP_Syscall6")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::MemUse => {
|
||||
writeln!(writer, " OP_MemUse {}", token.addr.unwrap())?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::None => {
|
||||
println!("{token:?}");
|
||||
unreachable!()
|
||||
},
|
||||
InstructionType::FnCall => {
|
||||
writeln!(writer, " OP_FnCall {}", token.text)?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::Return => {
|
||||
|
||||
// Experimental feature exported functions
|
||||
if crate::config::ENABLE_EXPORTED_FUNCTIONS && should_push_ret {
|
||||
writeln!(writer, " pop rdx")?;
|
||||
should_push_ret = false;
|
||||
}
|
||||
|
||||
writeln!(writer, " sub rbp, 8")?;
|
||||
writeln!(writer, " mov rbx, qword [rbp]")?;
|
||||
writeln!(writer, " push rbx")?;
|
||||
writeln!(writer, " ret")?;
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::CastBool |
|
||||
InstructionType::CastPtr |
|
||||
InstructionType::CastInt |
|
||||
InstructionType::CastVoid |
|
||||
InstructionType::TypeBool |
|
||||
InstructionType::TypePtr |
|
||||
InstructionType::TypeInt |
|
||||
InstructionType::TypeVoid |
|
||||
InstructionType::TypeAny |
|
||||
InstructionType::Returns |
|
||||
InstructionType::With => {
|
||||
ti += 1;
|
||||
}
|
||||
InstructionType::ConstUse => {
|
||||
writeln!(writer, " OP_ConstUse {}", token.text)?;
|
||||
|
||||
let mut c = constants.get(&token.text).unwrap().clone();
|
||||
c.used = true;
|
||||
constants.remove(&token.text);
|
||||
constants.insert(token.text.clone(), c);
|
||||
ti += 1;
|
||||
},
|
||||
InstructionType::StructUse => {
|
||||
writeln!(writer, " OP_StructUse {}", token.text)?;
|
||||
ti += 1;
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
OpType::Keyword(keyword) => {
|
||||
match keyword {
|
||||
|
||||
// block
|
||||
KeywordType::If |
|
||||
KeywordType::Do => {
|
||||
writeln!(writer, " pop rax")?;
|
||||
writeln!(writer, " test rax, rax")?;
|
||||
writeln!(writer, " jz addr_{}", token.jmp)?;
|
||||
ti += 1;
|
||||
}
|
||||
KeywordType::Else => {
|
||||
writeln!(writer, " jmp addr_{}", token.jmp)?;
|
||||
ti += 1;
|
||||
},
|
||||
KeywordType::While => {
|
||||
ti += 1;
|
||||
}
|
||||
KeywordType::End => {
|
||||
if ti + 1 != token.jmp {
|
||||
writeln!(writer, " jmp addr_{}", token.jmp)?;
|
||||
}
|
||||
ti += 1;
|
||||
},
|
||||
KeywordType::Memory => {
|
||||
memories.push(Memory { size: token.value, loc: token.loc.clone(), id: token.addr.unwrap() });
|
||||
ti += 1;
|
||||
}
|
||||
KeywordType::ConstantDef => {
|
||||
// TODO: after we add c style strings add supoort for them in constants
|
||||
let a = args.get_opt_level()? < 1;
|
||||
let c = Constant{
|
||||
loc: token.loc.clone(),
|
||||
name: token.text.clone(),
|
||||
value_i: Some(token.value),
|
||||
value_s: None,
|
||||
used: a,
|
||||
};
|
||||
|
||||
constants.insert(token.text.clone(), c);
|
||||
ti += 1;
|
||||
},
|
||||
KeywordType::FunctionDef => {
|
||||
writeln!(writer, "{}:", token.text)?;
|
||||
writeln!(writer, " pop rbx")?;
|
||||
writeln!(writer, " mov qword [rbp], rbx")?;
|
||||
writeln!(writer, " add rbp, 8")?;
|
||||
functions.push(Function { loc: token.loc.clone(), name: token.text.clone(), exter: false});
|
||||
ti += 1;
|
||||
},
|
||||
KeywordType::FunctionDone => {
|
||||
|
||||
if crate::config::ENABLE_EXPORTED_FUNCTIONS && should_push_ret {
|
||||
writeln!(writer, " pop rdx")?;
|
||||
should_push_ret = false;
|
||||
}
|
||||
|
||||
writeln!(writer, " sub rbp, 8")?;
|
||||
writeln!(writer, " mov rbx, qword [rbp]")?;
|
||||
writeln!(writer, " push rbx")?;
|
||||
writeln!(writer, " ret")?;
|
||||
ti += 1;
|
||||
}
|
||||
KeywordType::FunctionThen => ti += 1,
|
||||
KeywordType::FunctionDefExported => {
|
||||
|
||||
if !crate::config::ENABLE_EXPORTED_FUNCTIONS {
|
||||
lerror!(&token.loc, "Experimental feature 'exported functions' is not enabled");
|
||||
bail!("");
|
||||
}
|
||||
|
||||
writeln!(writer, "global {}", token.text)?;
|
||||
writeln!(writer, "{}:", token.text)?;
|
||||
|
||||
writeln!(writer, " pop rbx")?;
|
||||
writeln!(writer, " mov qword [rbp], rbx")?;
|
||||
writeln!(writer, " add rbp, 8")?;
|
||||
warn!("External functions are highly experimental and should be treated as such");
|
||||
if token.types.0 == 0 {
|
||||
writeln!(writer, " ; no arguments")?;
|
||||
} else {
|
||||
if token.types.0 >= 1 {
|
||||
writeln!(writer, " push rdi")?;
|
||||
}
|
||||
if token.types.0 >= 2 {
|
||||
writeln!(writer, " push rsi")?;
|
||||
}
|
||||
if token.types.0 >= 3 {
|
||||
writeln!(writer, " push rdx")?;
|
||||
}
|
||||
if token.types.0 >= 4 {
|
||||
writeln!(writer, " push rcx")?;
|
||||
}
|
||||
if token.types.0 >= 5 {
|
||||
writeln!(writer, " push r8")?;
|
||||
}
|
||||
if token.types.0 >= 6 {
|
||||
writeln!(writer, " push r9")?;
|
||||
}
|
||||
if token.types.0 >= 7 {
|
||||
lerror!(&token.loc, "More than 6 arguments in an external function is not supported");
|
||||
bail!("");
|
||||
}
|
||||
}
|
||||
|
||||
if token.types.1 == 1 {
|
||||
should_push_ret = true;
|
||||
} else if token.types.1 > 1 {
|
||||
lerror!(&token.loc, "More than 1 return arguments in an external function is not supported");
|
||||
bail!("");
|
||||
}
|
||||
|
||||
functions.push(Function { loc: token.loc.clone(), name: token.text.clone(), exter: false});
|
||||
ti += 1;
|
||||
},
|
||||
KeywordType::Function |
|
||||
KeywordType::Include |
|
||||
KeywordType::Inline |
|
||||
KeywordType::Export |
|
||||
KeywordType::Struct |
|
||||
KeywordType::Constant => unreachable!(),
|
||||
}
|
||||
}
|
||||
OpType::Internal(t) => {
|
||||
match t {
|
||||
InternalType::StructAlloc{name} => {
|
||||
alloced_structs.push((name, token.text.clone()));
|
||||
ti += 1;
|
||||
},
|
||||
InternalType::Arrow => panic!("{t:?}"),
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
writeln!(writer, "addr_{ti}:")?;
|
||||
if !crate::config::ENABLE_EXPORTED_FUNCTIONS && !args.lib_mode {
|
||||
writeln!(writer, "end:")?;
|
||||
writeln!(writer, " mov rax, 60")?;
|
||||
writeln!(writer, " mov rdi, 0")?;
|
||||
writeln!(writer, " syscall")?;
|
||||
}
|
||||
writeln!(writer, "segment .data")?;
|
||||
for (i, s) in strings.iter().enumerate() {
|
||||
let s_chars = s.chars().map(|c| (c as u32).to_string()).collect::<Vec<String>>();
|
||||
let s_list = s_chars.join(",");
|
||||
writeln!(writer, " str_{}: db {} ; {}", i, s_list, s.escape_default())?;
|
||||
}
|
||||
|
||||
for (_, c) in constants {
|
||||
if !c.used {
|
||||
continue;
|
||||
}
|
||||
|
||||
if let Some(v) = &c.value_i {
|
||||
writeln!(writer, " const_{}: dq {}", c.name, v)?;
|
||||
} else if let Some(_v) = &c.value_s {
|
||||
todo!();
|
||||
} else {
|
||||
unreachable!();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
writeln!(writer, "segment .bss")?;
|
||||
for m in memories {
|
||||
writeln!(writer, " mem_{}: resb {}", m.id, m.size)?;
|
||||
}
|
||||
|
||||
|
||||
for s in alloced_structs {
|
||||
let Some(st) = program.struct_defs.get(&s.0) else {
|
||||
// TODO: Make better error
|
||||
panic!("Couldn find struct in struct defs");
|
||||
};
|
||||
|
||||
let name = &s.1;
|
||||
let mut st_size = 0;
|
||||
|
||||
writeln!(writer, " struct_{name}:")?;
|
||||
for f in &st.fields {
|
||||
let size = f.1.get_size();
|
||||
writeln!(writer, " struct_{name}.{}: resb {}", f.0, size)?;
|
||||
st_size += size;
|
||||
}
|
||||
|
||||
writeln!(writer, " struct_{name}.__size: db {}", st_size)?;
|
||||
|
||||
}
|
||||
|
||||
|
||||
writeln!(writer, " ret_stack: resq 256")?;
|
||||
// for t in tokens {
|
||||
// println!("{t:?}");
|
||||
// }
|
||||
|
||||
writer.flush()?;
|
||||
|
||||
|
||||
pre_compile_steps(
|
||||
String::from_utf8_lossy(writer.buffer()).to_string().as_str(),
|
||||
functions
|
||||
)?;
|
||||
|
||||
linux_x86_64_compile_and_link(&of_a, &of_o, &of_c, args.quiet);
|
||||
|
||||
if args.run {
|
||||
let c = linux_x86_64_run(&of_c, &[], args.quiet)?;
|
||||
return Ok(c);
|
||||
}
|
||||
|
||||
|
||||
Ok(0)
|
||||
}
|
||||
|
||||
|
||||
fn pre_compile_steps(_code: &str, functions: Vec<Function>) -> Result<()> {
|
||||
let mut has_main = false;
|
||||
|
||||
for func in functions {
|
||||
if func.name == "main" {
|
||||
has_main = true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if !has_main {
|
||||
crate::errors::missing_main_fn();
|
||||
bail!("");
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
|
@ -1,362 +0,0 @@
|
|||
use crate::definitions::Loc;
|
||||
|
||||
pub mod linux_x86_64;
|
||||
pub mod commands;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Constant {
|
||||
pub loc: Loc,
|
||||
pub name: String,
|
||||
pub value_i: Option<usize>,
|
||||
pub value_s: Option<String>,
|
||||
pub used: bool
|
||||
// extern: bool
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Memory {
|
||||
pub size: usize,
|
||||
pub loc: Loc,
|
||||
pub id: usize
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Function {
|
||||
pub loc: Loc,
|
||||
pub name: String,
|
||||
pub exter: bool,
|
||||
}
|
||||
|
||||
const DBG_PRINT: &'static str = "
|
||||
_dbg_print:
|
||||
mov r9, -3689348814741910323
|
||||
sub rsp, 40
|
||||
mov BYTE [rsp+31], 10
|
||||
lea rcx, [rsp+30]
|
||||
.L2:
|
||||
mov rax, rdi
|
||||
lea r8, [rsp+32]
|
||||
mul r9
|
||||
mov rax, rdi
|
||||
sub r8, rcx
|
||||
shr rdx, 3
|
||||
lea rsi, [rdx+rdx*4]
|
||||
add rsi, rsi
|
||||
sub rax, rsi
|
||||
add eax, 48
|
||||
mov BYTE [rcx], al
|
||||
mov rax, rdi
|
||||
mov rdi, rdx
|
||||
mov rdx, rcx
|
||||
sub rcx, 1
|
||||
cmp rax, 9
|
||||
ja .L2
|
||||
lea rax, [rsp+32]
|
||||
mov edi, 1
|
||||
sub rdx, rax
|
||||
xor eax, eax
|
||||
lea rsi, [rsp+32+rdx]
|
||||
mov rdx, r8
|
||||
mov rax, 1
|
||||
syscall
|
||||
add rsp, 40
|
||||
ret
|
||||
";
|
||||
|
||||
const MACRO_DEFINITIONS: &'static str = "\
|
||||
%macro OP_PushInt 1
|
||||
mov rax, %1
|
||||
push rax
|
||||
%endmacro
|
||||
|
||||
; str_len, str_id
|
||||
%macro OP_PushStr 2
|
||||
mov rax, %1
|
||||
push rax
|
||||
mov rax, %2
|
||||
push rax
|
||||
%endmacro
|
||||
|
||||
; str_id
|
||||
%macro OP_PushCStr 1
|
||||
push rax
|
||||
mov rax, %1
|
||||
push rax
|
||||
%endmacro
|
||||
|
||||
%macro OP_Drop 0
|
||||
pop rax
|
||||
%endmacro
|
||||
|
||||
%macro OP_Print 0
|
||||
pop rdi
|
||||
call _dbg_print
|
||||
%endmacro
|
||||
|
||||
%macro OP_Dup 0
|
||||
pop rax
|
||||
push rax
|
||||
push rax
|
||||
%endmacro
|
||||
|
||||
%macro OP_Rot 0
|
||||
pop rax
|
||||
pop rbx
|
||||
pop rcx
|
||||
push rbx
|
||||
push rax
|
||||
push rcx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Swap 0
|
||||
pop rax
|
||||
pop rbx
|
||||
push rax
|
||||
push rbx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Over 0
|
||||
pop rax
|
||||
pop rbx
|
||||
push rbx
|
||||
push rax
|
||||
push rbx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Load8 0
|
||||
pop rax
|
||||
xor rbx, rbx
|
||||
mov bl, byte [rax]
|
||||
push rbx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Store8 0
|
||||
pop rbx
|
||||
pop rax
|
||||
mov byte [rax], bl
|
||||
%endmacro
|
||||
|
||||
%macro OP_Load32 0
|
||||
pop rax
|
||||
xor rbx, rbx
|
||||
mov ebx, dword [rax]
|
||||
push rbx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Store32 0
|
||||
pop rbx
|
||||
pop rax
|
||||
mov dword[rax], ebx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Load64 0
|
||||
pop rax
|
||||
xor rbx, rbx
|
||||
mov rbx, qword [rax]
|
||||
push rbx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Store64 0
|
||||
pop rbx
|
||||
pop rax
|
||||
mov qword [rax], rbx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Plus 0
|
||||
pop rax
|
||||
pop rbx
|
||||
add rax, rbx
|
||||
push rax
|
||||
%endmacro
|
||||
|
||||
%macro OP_Minus 0
|
||||
pop rax
|
||||
pop rbx
|
||||
sub rbx, rax
|
||||
push rbx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Equals 0
|
||||
mov rcx, 0
|
||||
mov rdx, 1
|
||||
pop rax
|
||||
pop rbx
|
||||
cmp rax, rbx
|
||||
cmove rcx, rdx
|
||||
push rcx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Lt 0
|
||||
mov rcx, 0
|
||||
mov rdx, 1
|
||||
pop rbx
|
||||
pop rax
|
||||
cmp rax, rbx
|
||||
cmovl rcx, rdx
|
||||
push rcx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Gt 0
|
||||
mov rcx, 0
|
||||
mov rdx, 1
|
||||
pop rbx
|
||||
pop rax
|
||||
cmp rax, rbx
|
||||
cmovg rcx, rdx
|
||||
push rcx
|
||||
%endmacro
|
||||
|
||||
%macro OP_NotEquals 0
|
||||
mov rcx, 1
|
||||
mov rdx, 0
|
||||
pop rax
|
||||
pop rbx
|
||||
cmp rax, rbx
|
||||
cmove rcx, rdx
|
||||
push rcx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Le 0
|
||||
mov rcx, 0
|
||||
mov rdx, 1
|
||||
pop rbx
|
||||
pop rax
|
||||
cmp rax, rbx
|
||||
cmovle rcx, rdx
|
||||
push rcx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Ge 0
|
||||
mov rcx, 0
|
||||
mov rdx, 1
|
||||
pop rbx
|
||||
pop rax
|
||||
cmp rax, rbx
|
||||
cmovge rcx, rdx
|
||||
push rcx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Band 0
|
||||
pop rax
|
||||
pop rbx
|
||||
and rbx, rax
|
||||
push rbx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Bor 0
|
||||
pop rax
|
||||
pop rbx
|
||||
or rbx, rax
|
||||
push rbx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Shr 0
|
||||
pop rcx
|
||||
pop rbx
|
||||
shr rbx, cl
|
||||
push rbx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Shl 0
|
||||
pop rcx
|
||||
pop rbx
|
||||
shl rbx, cl
|
||||
push rbx
|
||||
%endmacro
|
||||
|
||||
%macro OP_DivMod 0
|
||||
xor rdx, rdx
|
||||
pop rbx
|
||||
pop rax
|
||||
div rbx
|
||||
push rax
|
||||
push rdx
|
||||
%endmacro
|
||||
|
||||
%macro OP_Mul 0
|
||||
pop rax
|
||||
pop rbx
|
||||
mul rbx
|
||||
push rax
|
||||
%endmacro
|
||||
|
||||
%macro OP_Syscall0 0
|
||||
pop rax
|
||||
syscall
|
||||
push rax
|
||||
%endmacro
|
||||
|
||||
%macro OP_Syscall1 0
|
||||
pop rax
|
||||
pop rdi
|
||||
syscall
|
||||
push rax
|
||||
%endmacro
|
||||
|
||||
%macro OP_Syscall2 0
|
||||
pop rax
|
||||
pop rdi
|
||||
pop rsi
|
||||
syscall
|
||||
push rax
|
||||
%endmacro
|
||||
|
||||
%macro OP_Syscall3 0
|
||||
pop rax
|
||||
pop rdi
|
||||
pop rsi
|
||||
pop rdx
|
||||
syscall
|
||||
push rax
|
||||
%endmacro
|
||||
|
||||
%macro OP_Syscall4 0
|
||||
pop rax
|
||||
pop rdi
|
||||
pop rsi
|
||||
pop rdx
|
||||
pop r10
|
||||
syscall
|
||||
push rax
|
||||
%endmacro
|
||||
|
||||
%macro OP_Syscall5 0
|
||||
pop rax
|
||||
pop rdi
|
||||
pop rsi
|
||||
pop rdx
|
||||
pop r10
|
||||
pop r8
|
||||
syscall
|
||||
push rax
|
||||
%endmacro
|
||||
|
||||
%macro OP_Syscall6 0
|
||||
pop rax
|
||||
pop rdi
|
||||
pop rsi
|
||||
pop rdx
|
||||
pop r10
|
||||
pop r8
|
||||
pop r9
|
||||
syscall
|
||||
push rax
|
||||
%endmacro
|
||||
|
||||
%macro OP_MemUse 1
|
||||
push mem_%1
|
||||
%endmacro
|
||||
|
||||
%macro OP_FnCall 1
|
||||
call %1
|
||||
%endmacro
|
||||
|
||||
%macro OP_ConstUse 1
|
||||
mov rax, qword [const_%1]
|
||||
push rax
|
||||
%endmacro
|
||||
|
||||
%macro OP_StructUse 1
|
||||
push struct_%1
|
||||
%endmacro
|
||||
";
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
/**
|
||||
* Prints out extra information
|
||||
*/
|
||||
pub const DEV_MODE: bool = true;
|
||||
|
||||
pub const DEFAULT_OUT_FILE: &str = "a.out";
|
||||
pub const DEFAULT_INCLUDES: [&str;2] = [
|
||||
"./include",
|
||||
"~/.mclang/include",
|
||||
];
|
||||
|
||||
|
||||
/**
|
||||
* Experimental options
|
||||
*/
|
||||
pub const ENABLE_EXPORTED_FUNCTIONS: bool = false;
|
||||
283
src/constants.rs
283
src/constants.rs
|
|
@ -1,283 +0,0 @@
|
|||
|
||||
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum InstructionType {
|
||||
|
||||
// stack
|
||||
PushInt,
|
||||
PushStr,
|
||||
PushCStr,
|
||||
Drop,
|
||||
Print,
|
||||
Dup,
|
||||
Rot, // a b c => b c a
|
||||
Over, // a b => a b a
|
||||
Swap, // a b => b a
|
||||
|
||||
// math
|
||||
Minus,
|
||||
Plus,
|
||||
Equals,
|
||||
Gt,
|
||||
Lt,
|
||||
Ge,
|
||||
Le,
|
||||
NotEquals,
|
||||
Band, // &
|
||||
Bor, // |
|
||||
Shr, // >>
|
||||
Shl, // <<
|
||||
DivMod, // /
|
||||
Mul,
|
||||
|
||||
|
||||
// mem
|
||||
Read8,
|
||||
Write8,
|
||||
Read32,
|
||||
Write32,
|
||||
Read64,
|
||||
Write64,
|
||||
|
||||
// syscalls
|
||||
Syscall0,
|
||||
Syscall1,
|
||||
Syscall2,
|
||||
Syscall3,
|
||||
Syscall4,
|
||||
Syscall5,
|
||||
Syscall6,
|
||||
|
||||
CastBool,
|
||||
CastPtr,
|
||||
CastInt,
|
||||
CastVoid,
|
||||
|
||||
// typing
|
||||
TypeBool,
|
||||
TypePtr,
|
||||
TypeInt,
|
||||
TypeVoid,
|
||||
// TypeStr,
|
||||
TypeAny,
|
||||
Returns,
|
||||
With,
|
||||
|
||||
FnCall,
|
||||
MemUse,
|
||||
ConstUse,
|
||||
|
||||
Return,
|
||||
None // Used for macros and any other non built in word definitions
|
||||
|
||||
}
|
||||
#[derive(Debug, Clone, Copy, PartialEq)]
|
||||
pub enum KeywordType {
|
||||
If,
|
||||
Else,
|
||||
End,
|
||||
While,
|
||||
Do,
|
||||
Include,
|
||||
Memory,
|
||||
Constant,
|
||||
ConstantDef,
|
||||
Function,
|
||||
FunctionDef,
|
||||
FunctionDefExported,
|
||||
FunctionThen,
|
||||
FunctionDone,
|
||||
Inline,
|
||||
Export,
|
||||
Struct
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum OpType {
|
||||
Keyword(KeywordType),
|
||||
Instruction(InstructionType)
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Operator{
|
||||
pub typ: OpType,
|
||||
pub tok_typ: TokenType,
|
||||
pub value: usize,
|
||||
pub text: String, //? only used for OpType::PushStr
|
||||
pub addr: Option<usize>, //? only used for OpType::PushStr
|
||||
pub jmp: usize,
|
||||
pub loc: Loc,
|
||||
pub types: (usize, usize)
|
||||
}
|
||||
|
||||
impl Operator {
|
||||
pub fn new(typ: OpType, tok_typ: TokenType, value: usize, text: String, file: String, row: usize, col: usize) -> Self {
|
||||
Self {
|
||||
typ,
|
||||
value,
|
||||
jmp: 0,
|
||||
addr: None,
|
||||
text,
|
||||
loc: (file, row, col),
|
||||
tok_typ,
|
||||
types: (0, 0)
|
||||
}
|
||||
}
|
||||
pub fn set_addr(&mut self, addr: usize) -> Self {
|
||||
self.addr = Some(addr);
|
||||
(*self).clone()
|
||||
}
|
||||
|
||||
// pub fn set_types(&mut self, args: usize, rets: usize) -> Self {
|
||||
// self.types = (args, rets);
|
||||
// (*self).clone()
|
||||
// }
|
||||
|
||||
}
|
||||
|
||||
impl OpType {
|
||||
pub fn human(&self) -> String {
|
||||
match (*self).clone() {
|
||||
OpType::Instruction(instruction) => {
|
||||
match instruction {
|
||||
|
||||
InstructionType::PushInt => "Number",
|
||||
InstructionType::PushStr => "String",
|
||||
InstructionType::PushCStr => "CString",
|
||||
InstructionType::Print => "_dbg_print",
|
||||
InstructionType::Dup => "dup",
|
||||
InstructionType::Drop => "drop",
|
||||
InstructionType::Rot => "rot",
|
||||
InstructionType::Over => "over",
|
||||
InstructionType::Swap => "swap",
|
||||
InstructionType::Plus => "+",
|
||||
InstructionType::Minus => "-",
|
||||
InstructionType::Equals => "=",
|
||||
InstructionType::Gt => ">",
|
||||
InstructionType::Lt => "<",
|
||||
InstructionType::NotEquals => "!=",
|
||||
InstructionType::Le => "<=",
|
||||
InstructionType::Ge => ">=",
|
||||
InstructionType::Band => "band",
|
||||
InstructionType::Bor => "bor",
|
||||
InstructionType::Shr => "shr",
|
||||
InstructionType::Shl => "shl",
|
||||
InstructionType::DivMod => "divmod",
|
||||
InstructionType::Mul => "*",
|
||||
InstructionType::Read8 => "read8",
|
||||
InstructionType::Write8 => "write8",
|
||||
InstructionType::Read32 => "read32",
|
||||
InstructionType::Write32 => "write32",
|
||||
InstructionType::Read64 => "read64",
|
||||
InstructionType::Write64 => "write64",
|
||||
InstructionType::Syscall0 => "syscall0",
|
||||
InstructionType::Syscall1 => "syscall1",
|
||||
InstructionType::Syscall2 => "syscall2",
|
||||
InstructionType::Syscall3 => "syscall3",
|
||||
InstructionType::Syscall4 => "syscall4",
|
||||
InstructionType::Syscall5 => "syscall5",
|
||||
InstructionType::Syscall6 => "syscall6",
|
||||
InstructionType::CastBool => "cast(bool",
|
||||
InstructionType::CastPtr => "cast(ptr)",
|
||||
InstructionType::CastInt => "cast(int)",
|
||||
InstructionType::CastVoid => "cast(void)",
|
||||
InstructionType::None => "None",
|
||||
InstructionType::MemUse => "Memory use (internal)",
|
||||
InstructionType::FnCall => "Function Call (Internal)",
|
||||
InstructionType::ConstUse => "Constant Use (Internal)",
|
||||
InstructionType::Return => "return",
|
||||
InstructionType::TypeBool => "bool",
|
||||
InstructionType::TypePtr => "ptr",
|
||||
InstructionType::TypeInt => "int",
|
||||
InstructionType::TypeVoid => "void",
|
||||
InstructionType::Returns => "returns",
|
||||
InstructionType::With => "with",
|
||||
InstructionType::TypeAny => "any",
|
||||
}
|
||||
}
|
||||
OpType::Keyword(keyword) => {
|
||||
match keyword {
|
||||
KeywordType::If => "if",
|
||||
KeywordType::Else => "else",
|
||||
KeywordType::End => "end",
|
||||
KeywordType::While => "while",
|
||||
KeywordType::Do => "do",
|
||||
KeywordType::Include => "include",
|
||||
KeywordType::Memory => "memory",
|
||||
KeywordType::Function => "fn",
|
||||
KeywordType::Constant => "const",
|
||||
KeywordType::FunctionThen => "then",
|
||||
KeywordType::FunctionDone => "done",
|
||||
KeywordType::ConstantDef => "constant Definition (internal)",
|
||||
KeywordType::FunctionDef => "function definition (internal)",
|
||||
KeywordType::FunctionDefExported => "extern function definition (internal)",
|
||||
KeywordType::Inline => "inline",
|
||||
KeywordType::Export => "export",
|
||||
KeywordType::Struct => "struct",
|
||||
}
|
||||
}
|
||||
|
||||
}.to_string()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Token {
|
||||
pub file: String,
|
||||
pub line: usize,
|
||||
pub col: usize,
|
||||
pub text: String,
|
||||
pub typ: TokenType,
|
||||
pub value: Option<usize>, //* only used for Memories
|
||||
pub addr: Option<usize>, //* only used for Memories
|
||||
pub op_typ: OpType //* only used for Memories
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Copy)]
|
||||
pub enum TokenType {
|
||||
Word,
|
||||
Int,
|
||||
String,
|
||||
CString,
|
||||
Char
|
||||
}
|
||||
|
||||
impl Token {
|
||||
pub fn loc(&self) -> Loc {
|
||||
(
|
||||
self.file.clone(),
|
||||
self.line,
|
||||
self.col
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl TokenType {
|
||||
pub fn human(self) -> String {
|
||||
match self {
|
||||
TokenType::Word => "Word",
|
||||
TokenType::Int => "Int",
|
||||
TokenType::String => "String",
|
||||
TokenType::CString => "CString",
|
||||
TokenType::Char => "Char"
|
||||
}.to_string()
|
||||
}
|
||||
}
|
||||
|
||||
pub type Loc = (String, usize, usize);
|
||||
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
pub enum Types {
|
||||
Bool,
|
||||
Ptr,
|
||||
Int,
|
||||
Void,
|
||||
Any
|
||||
// U8,
|
||||
// U16,
|
||||
// U32,
|
||||
// U64,
|
||||
// todo: add signed numbers since we dont have them yet lol
|
||||
}
|
||||
|
||||
|
|
@ -1,392 +0,0 @@
|
|||
use std::collections::HashMap;
|
||||
|
||||
use anyhow::{Result, bail};
|
||||
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum InstructionType {
|
||||
|
||||
// stack
|
||||
PushInt,
|
||||
PushStr,
|
||||
PushCStr,
|
||||
Drop,
|
||||
Print,
|
||||
Dup,
|
||||
Rot, // a b c => b c a
|
||||
Over, // a b => a b a
|
||||
Swap, // a b => b a
|
||||
|
||||
// math
|
||||
Minus,
|
||||
Plus,
|
||||
Equals,
|
||||
Gt,
|
||||
Lt,
|
||||
Ge,
|
||||
Le,
|
||||
NotEquals,
|
||||
Band, // &
|
||||
Bor, // |
|
||||
Shr, // >>
|
||||
Shl, // <<
|
||||
DivMod, // /
|
||||
Mul,
|
||||
|
||||
|
||||
// mem
|
||||
Read8,
|
||||
Write8,
|
||||
Read32,
|
||||
Write32,
|
||||
Read64,
|
||||
Write64,
|
||||
|
||||
// syscalls
|
||||
Syscall0,
|
||||
Syscall1,
|
||||
Syscall2,
|
||||
Syscall3,
|
||||
Syscall4,
|
||||
Syscall5,
|
||||
Syscall6,
|
||||
|
||||
CastBool,
|
||||
CastPtr,
|
||||
CastInt,
|
||||
CastVoid,
|
||||
|
||||
// typing
|
||||
TypeBool,
|
||||
TypePtr,
|
||||
TypeInt,
|
||||
TypeVoid,
|
||||
// TypeStr,
|
||||
TypeAny,
|
||||
Returns,
|
||||
With,
|
||||
|
||||
FnCall,
|
||||
MemUse,
|
||||
ConstUse,
|
||||
StructUse,
|
||||
|
||||
Return,
|
||||
None // Used for macros and any other non built in word definitions
|
||||
|
||||
}
|
||||
#[derive(Debug, Clone, Copy, PartialEq)]
|
||||
pub enum KeywordType {
|
||||
If,
|
||||
Else,
|
||||
End,
|
||||
While,
|
||||
Do,
|
||||
Include,
|
||||
Memory,
|
||||
Constant,
|
||||
ConstantDef,
|
||||
Function,
|
||||
FunctionDef,
|
||||
FunctionDefExported,
|
||||
FunctionThen,
|
||||
FunctionDone,
|
||||
Inline,
|
||||
Export,
|
||||
Struct,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum InternalType {
|
||||
Arrow,
|
||||
StructAlloc {
|
||||
name: String
|
||||
}
|
||||
}
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum OpType {
|
||||
Keyword(KeywordType),
|
||||
Instruction(InstructionType),
|
||||
Internal(InternalType)
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Operator{
|
||||
pub typ: OpType,
|
||||
pub tok_typ: TokenType,
|
||||
pub value: usize,
|
||||
pub text: String, //? only used for OpType::PushStr
|
||||
pub addr: Option<usize>, //? only used for OpType::PushStr
|
||||
pub jmp: usize,
|
||||
pub loc: Loc,
|
||||
pub types: (usize, usize)
|
||||
}
|
||||
|
||||
impl Operator {
|
||||
pub fn new(typ: OpType, tok_typ: TokenType, value: usize, text: String, file: String, row: usize, col: usize) -> Self {
|
||||
Self {
|
||||
typ,
|
||||
value,
|
||||
jmp: 0,
|
||||
addr: None,
|
||||
text,
|
||||
loc: (file, row, col),
|
||||
tok_typ,
|
||||
types: (0, 0)
|
||||
}
|
||||
}
|
||||
pub fn set_addr(&mut self, addr: usize) -> Self {
|
||||
self.addr = Some(addr);
|
||||
(*self).clone()
|
||||
}
|
||||
|
||||
// pub fn set_types(&mut self, args: usize, rets: usize) -> Self {
|
||||
// self.types = (args, rets);
|
||||
// (*self).clone()
|
||||
// }
|
||||
|
||||
}
|
||||
|
||||
impl OpType {
|
||||
pub fn human(&self) -> String {
|
||||
match (*self).clone() {
|
||||
OpType::Instruction(instruction) => {
|
||||
match instruction {
|
||||
|
||||
InstructionType::PushInt => "Number",
|
||||
InstructionType::PushStr => "String",
|
||||
InstructionType::PushCStr => "CString",
|
||||
InstructionType::Print => "_dbg_print",
|
||||
InstructionType::Dup => "dup",
|
||||
InstructionType::Drop => "drop",
|
||||
InstructionType::Rot => "rot",
|
||||
InstructionType::Over => "over",
|
||||
InstructionType::Swap => "swap",
|
||||
InstructionType::Plus => "+",
|
||||
InstructionType::Minus => "-",
|
||||
InstructionType::Equals => "=",
|
||||
InstructionType::Gt => ">",
|
||||
InstructionType::Lt => "<",
|
||||
InstructionType::NotEquals => "!=",
|
||||
InstructionType::Le => "<=",
|
||||
InstructionType::Ge => ">=",
|
||||
InstructionType::Band => "band",
|
||||
InstructionType::Bor => "bor",
|
||||
InstructionType::Shr => "shr",
|
||||
InstructionType::Shl => "shl",
|
||||
InstructionType::DivMod => "divmod",
|
||||
InstructionType::Mul => "*",
|
||||
InstructionType::Read8 => "read8",
|
||||
InstructionType::Write8 => "write8",
|
||||
InstructionType::Read32 => "read32",
|
||||
InstructionType::Write32 => "write32",
|
||||
InstructionType::Read64 => "read64",
|
||||
InstructionType::Write64 => "write64",
|
||||
InstructionType::Syscall0 => "syscall0",
|
||||
InstructionType::Syscall1 => "syscall1",
|
||||
InstructionType::Syscall2 => "syscall2",
|
||||
InstructionType::Syscall3 => "syscall3",
|
||||
InstructionType::Syscall4 => "syscall4",
|
||||
InstructionType::Syscall5 => "syscall5",
|
||||
InstructionType::Syscall6 => "syscall6",
|
||||
InstructionType::CastBool => "cast(bool",
|
||||
InstructionType::CastPtr => "cast(ptr)",
|
||||
InstructionType::CastInt => "cast(int)",
|
||||
InstructionType::CastVoid => "cast(void)",
|
||||
InstructionType::None => "None",
|
||||
InstructionType::MemUse => "Memory use (internal)",
|
||||
InstructionType::FnCall => "Function Call (Internal)",
|
||||
InstructionType::ConstUse => "Constant Use (Internal)",
|
||||
InstructionType::StructUse => "Struct Use (Internal)",
|
||||
InstructionType::Return => "return",
|
||||
InstructionType::TypeBool => "bool",
|
||||
InstructionType::TypePtr => "ptr",
|
||||
InstructionType::TypeInt => "int",
|
||||
InstructionType::TypeVoid => "void",
|
||||
InstructionType::Returns => "returns",
|
||||
InstructionType::With => "with",
|
||||
InstructionType::TypeAny => "any",
|
||||
}
|
||||
}
|
||||
OpType::Keyword(keyword) => {
|
||||
match keyword {
|
||||
KeywordType::If => "if",
|
||||
KeywordType::Else => "else",
|
||||
KeywordType::End => "end",
|
||||
KeywordType::While => "while",
|
||||
KeywordType::Do => "do",
|
||||
KeywordType::Include => "include",
|
||||
KeywordType::Memory => "memory",
|
||||
KeywordType::Function => "fn",
|
||||
KeywordType::Constant => "const",
|
||||
KeywordType::FunctionThen => "then",
|
||||
KeywordType::FunctionDone => "done",
|
||||
KeywordType::ConstantDef => "constant Definition (internal)",
|
||||
KeywordType::FunctionDef => "function definition (internal)",
|
||||
KeywordType::FunctionDefExported => "extern function definition (internal)",
|
||||
KeywordType::Inline => "inline",
|
||||
KeywordType::Export => "export",
|
||||
KeywordType::Struct => "struct",
|
||||
}
|
||||
}
|
||||
OpType::Internal(t) => {
|
||||
match t {
|
||||
InternalType::Arrow => "->",
|
||||
InternalType::StructAlloc{..} => "Struct alloc ( internal )",
|
||||
}
|
||||
},
|
||||
|
||||
}.to_string()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Token {
|
||||
pub file: String,
|
||||
pub line: usize,
|
||||
pub col: usize,
|
||||
pub text: String,
|
||||
pub typ: TokenType,
|
||||
pub value: Option<usize>, //* only used for Memories
|
||||
pub addr: Option<usize>, //* only used for Memories
|
||||
pub op_typ: OpType //* only used for Memories
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Copy)]
|
||||
pub enum TokenType {
|
||||
Word,
|
||||
Int,
|
||||
String,
|
||||
CString,
|
||||
Char
|
||||
}
|
||||
|
||||
impl Token {
|
||||
pub fn loc(&self) -> Loc {
|
||||
(
|
||||
self.file.clone(),
|
||||
self.line,
|
||||
self.col
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl TokenType {
|
||||
pub fn human(self) -> String {
|
||||
match self {
|
||||
TokenType::Word => "Word",
|
||||
TokenType::Int => "Int",
|
||||
TokenType::String => "String",
|
||||
TokenType::CString => "CString",
|
||||
TokenType::Char => "Char"
|
||||
}.to_string()
|
||||
}
|
||||
}
|
||||
|
||||
pub type Loc = (String, usize, usize);
|
||||
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
pub enum Types {
|
||||
Any,
|
||||
Bool,
|
||||
Ptr,
|
||||
Void,
|
||||
U8,
|
||||
U16,
|
||||
U32,
|
||||
U64,
|
||||
I8,
|
||||
I16,
|
||||
I32,
|
||||
I64,
|
||||
|
||||
#[allow(dead_code)] //TODO: Implement custom types
|
||||
Custom{
|
||||
size: u64 // in bytes
|
||||
},
|
||||
// todo: add signed numbers since we dont have them yet lol
|
||||
}
|
||||
|
||||
impl Types {
|
||||
pub fn get_size(&self) -> u64 {
|
||||
match *self {
|
||||
Types::Any => 0, // any cant be a known size
|
||||
Types::Void => 0,
|
||||
Types::Bool => 1,
|
||||
Types::U8 |
|
||||
Types::I8 => 1,
|
||||
Types::U16 |
|
||||
Types::I16 => 2,
|
||||
Types::U32 |
|
||||
Types::I32 => 4,
|
||||
Types::Ptr |
|
||||
Types::U64 |
|
||||
Types::I64 => 8,
|
||||
Types::Custom { size } => size,
|
||||
}
|
||||
}
|
||||
pub fn from_string<S: Into<String> + std::fmt::Display>(s: &S) -> Result<Self> {
|
||||
match s.to_string().as_str() {
|
||||
"any" => Ok(Types::Any),
|
||||
"void" => Ok(Types::Void),
|
||||
"bool" => Ok(Types::Bool),
|
||||
"u8" => Ok(Types::U8),
|
||||
"i8" => Ok(Types::I8),
|
||||
"u16" => Ok(Types::U16),
|
||||
"i16" => Ok(Types::I16),
|
||||
"u32" => Ok(Types::U32),
|
||||
"i32" => Ok(Types::I32),
|
||||
"ptr" => Ok(Types::Ptr),
|
||||
"u64" => Ok(Types::U64),
|
||||
"i64" => Ok(Types::I64),
|
||||
_ => bail!("Unknown type {s}")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Function {
|
||||
pub loc: Loc,
|
||||
pub name: String,
|
||||
pub inline: bool,
|
||||
pub tokens: Option<Vec<Operator>>
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Constant {
|
||||
pub loc: Loc,
|
||||
pub name: String
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Memory {
|
||||
pub loc: Loc,
|
||||
pub id: usize
|
||||
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct StructDef {
|
||||
pub loc: Loc,
|
||||
pub name: String,
|
||||
pub fields: Vec<(String, Types)>
|
||||
}
|
||||
|
||||
pub type Functions = HashMap<String, Function>;
|
||||
pub type Memories = HashMap<String, Memory>;
|
||||
pub type Constants = HashMap<String, Constant>;
|
||||
pub type StructDefs = HashMap<String, StructDef>;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Program {
|
||||
pub ops: Vec<Operator>,
|
||||
pub functions: Functions,
|
||||
pub memories: Memories,
|
||||
pub constants: Constants,
|
||||
pub struct_defs: StructDefs,
|
||||
pub struct_allocs: HashMap<String, String>
|
||||
}
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
use crate::{error, help, code_block};
|
||||
|
||||
|
||||
|
||||
pub fn missing_main_fn() {
|
||||
error!("Main function not found, please create one lol");
|
||||
help!("Heres a basic main function with code that prints hello world:\n{}",
|
||||
code_block!(
|
||||
concat!(
|
||||
"include \"std.mcl\"\n",
|
||||
"\n",
|
||||
"fn main with void retuns void then\n",
|
||||
" \"Hello world!\\n\" puts\n",
|
||||
"done\n"
|
||||
)
|
||||
)
|
||||
);
|
||||
}
|
||||
61
src/include/ast.h
Normal file
61
src/include/ast.h
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
|
||||
#ifndef _H_MCL_AST
|
||||
#define _H_MCL_AST
|
||||
|
||||
#include "loc.h"
|
||||
#include "dyn_arr.h"
|
||||
|
||||
|
||||
DEFINE_DA(ast_node, void*);
|
||||
|
||||
|
||||
typedef enum ast_type_e {
|
||||
AT_BIN_ADD,
|
||||
AT_BIN_SUB,
|
||||
AT_BIN_DIV,
|
||||
AT_BIN_MUL,
|
||||
AT_UN_DEREF,
|
||||
AT_UN_XOR,
|
||||
AT_FUNC,
|
||||
AT_ASSIGN,
|
||||
AT_EXPR,
|
||||
} ast_type_t;
|
||||
|
||||
typedef struct ast_ident_s {
|
||||
char* name;
|
||||
loc_t loc;
|
||||
} ast_ident_t;
|
||||
|
||||
typedef struct type_s {
|
||||
ast_ident_t name;
|
||||
struct type_s* inner;
|
||||
} type_t;
|
||||
|
||||
|
||||
typedef struct ast_node_s {
|
||||
ast_type_t* type;
|
||||
loc_t loc;
|
||||
} ast_node_t;
|
||||
|
||||
|
||||
typedef struct ast_program_s {
|
||||
mcl_da_ast_node_t body;
|
||||
loc_t loc;
|
||||
} ast_program_t;
|
||||
|
||||
typedef struct ast_func_param_s {
|
||||
ast_ident_t name;
|
||||
type_t type;
|
||||
} ast_func_param_t;
|
||||
|
||||
DEFINE_DA(func_param, ast_func_param_t);
|
||||
|
||||
typedef struct ast_func_decl_s {
|
||||
ast_type_t* type;
|
||||
loc_t loc;
|
||||
ast_ident_t id;
|
||||
mcl_da_func_param_t params;
|
||||
mcl_da_ast_node_t body;
|
||||
} ast_func_decl_t;
|
||||
|
||||
#endif
|
||||
33
src/include/cliargs.h
Normal file
33
src/include/cliargs.h
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
#ifndef _H_MCL_CLIARGS
|
||||
#define _H_MCL_CLIARGS
|
||||
|
||||
#include <getopt.h>
|
||||
#include <string.h>
|
||||
#include "dyn_arr.h"
|
||||
|
||||
#ifndef MCL_VERSION
|
||||
#define MCL_VERSION "0.0.1"
|
||||
#endif
|
||||
|
||||
DEFINE_DA(string, char*)
|
||||
|
||||
static struct option cli_options[] = {
|
||||
{"help", no_argument, 0, 'h'},
|
||||
{"version", no_argument, 0, 'v'},
|
||||
{"output", required_argument, 0, 'o'},
|
||||
{"debug", no_argument, 0, 'd'},
|
||||
{0,0,0,0}
|
||||
};
|
||||
|
||||
typedef struct cliargs_s {
|
||||
bool help;
|
||||
bool version;
|
||||
bool debug;
|
||||
char* output;
|
||||
mcl_da_string_t input;
|
||||
} cliargs_t;
|
||||
|
||||
cliargs_t* parse_cliargs(int argc, char** argv);
|
||||
|
||||
|
||||
#endif
|
||||
121
src/include/dyn_arr.h
Normal file
121
src/include/dyn_arr.h
Normal file
|
|
@ -0,0 +1,121 @@
|
|||
#ifndef _H_MCL_DYN_ARR
|
||||
#define _H_MCL_DYN_ARR
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#define DEFINE_DA(name, type) \
|
||||
typedef struct mcl_da_##name##_s { \
|
||||
type* items; \
|
||||
size_t count; \
|
||||
size_t capacity; \
|
||||
} mcl_da_##name##_t; \
|
||||
type* mcl_da_##name##_pop(mcl_da_##name##_t* da); \
|
||||
type* mcl_da_##name##_peek(mcl_da_##name##_t* da); \
|
||||
type* mcl_da_##name##_pop_front(mcl_da_##name##_t* da); \
|
||||
type* mcl_da_##name##_peek_front(mcl_da_##name##_t* da); \
|
||||
void mcl_da_##name##_push(mcl_da_##name##_t* da, type item); \
|
||||
void mcl_da_##name##_free(mcl_da_##name##_t* da);
|
||||
|
||||
#define DEFINE_DA_IMPL(name, type) \
|
||||
type* mcl_da_##name##_pop(mcl_da_##name##_t* da) { \
|
||||
if (da->capacity <= 0 || da->count <= 0) \
|
||||
return NULL; \
|
||||
if (da->count < da->capacity / 2) { \
|
||||
da->capacity /= 2; \
|
||||
da->items = realloc(da->items, \
|
||||
da->capacity * sizeof(type)); \
|
||||
assert(da->items && "Out of memory"); \
|
||||
} \
|
||||
return &da->items[(da->count--) - 1]; \
|
||||
} \
|
||||
void mcl_da_##name##_push(mcl_da_##name##_t* da, type item) { \
|
||||
if (da->capacity <= da->count) { \
|
||||
if (da->capacity == 0) { \
|
||||
da->capacity = 8; \
|
||||
} else { \
|
||||
da->capacity *= 2; \
|
||||
} \
|
||||
da->items = realloc(da->items, \
|
||||
da->capacity * sizeof(type)); \
|
||||
assert(da->items && "Out of memory"); \
|
||||
} \
|
||||
da->items[da->count++] = item; \
|
||||
} \
|
||||
type* mcl_da_##name##_pop_front(mcl_da_##name##_t* da) { \
|
||||
if (da->capacity <= 0 || da->count <= 0) \
|
||||
return NULL; \
|
||||
if (da->count < da->capacity / 2) { \
|
||||
da->capacity /= 2; \
|
||||
da->items = realloc(da->items, \
|
||||
da->capacity * sizeof(type)); \
|
||||
assert(da->items && "Out of memory"); \
|
||||
} \
|
||||
type* item = malloc(sizeof(type)); \
|
||||
type* temp = malloc(sizeof(type) * da->count); \
|
||||
*item = da->items[0]; \
|
||||
memcpy(temp, &da->items[1], sizeof(type) * da->count); \
|
||||
memcpy(da->items, temp, sizeof(type) * --da->count); \
|
||||
free(temp); \
|
||||
return item; \
|
||||
} \
|
||||
type* mcl_da_##name##_peek(mcl_da_##name##_t* da) { \
|
||||
if (da->count < 1) return NULL; \
|
||||
return &da->items[da->count - 1]; \
|
||||
} \
|
||||
type* mcl_da_##name##_peek_front(mcl_da_##name##_t* da) { \
|
||||
return &da->items[0]; \
|
||||
} \
|
||||
void mc_da_##name##_free(mcl_da_##name##_t* da) { \
|
||||
free(da->items); \
|
||||
}
|
||||
|
||||
|
||||
|
||||
//#define DEFINE_PTR_DA(name, type) \
|
||||
//typedef struct mcl_ptr_da_##name##_s { \
|
||||
// type** items; \
|
||||
// size_t count; \
|
||||
// size_t capacity; \
|
||||
//} mcl_ptr_da_##name##_t; \
|
||||
//type* mcl_da_##name##_pop(mcl_da_##name##_t* da); \
|
||||
//void mcl_da_##name##_push(mcl_da_##name##_t* da, type* item);
|
||||
//
|
||||
//
|
||||
//#define DEFINE_PTR_DA_IMPL(type) \
|
||||
//type* mcl_ptr_da_##name##_pop(mcl_da_##name##_t* da) { \
|
||||
// if (da->capacity <= 0 || da->count <= 0) \
|
||||
// return NULL; \
|
||||
// if (da->count < da->capacity / 2) { \
|
||||
// da->capacity /= 2; \
|
||||
// da->items = realloc(da->items, \
|
||||
// da->capacity * sizeof(type*)); \
|
||||
// assert(da->items && "Out of memory"); \
|
||||
// } \
|
||||
// return da->items[(da->count--) - 1]; \
|
||||
//} \
|
||||
//void mcl_ptr_da_##name##_push(mcl_da_##name##_t* da, type* item) { \
|
||||
// if (da->capacity <= da->count) { \
|
||||
// if (da->capacity == 0) { \
|
||||
// da->capacity = 8; \
|
||||
// } else { \
|
||||
// da->capacity *= 2; \
|
||||
// } \
|
||||
// da->items = realloc(da->items, \
|
||||
// da->capacity * sizeof(type*)); \
|
||||
// assert(da->items && "Out of memory"); \
|
||||
// } \
|
||||
// da->items[da->count++] = item; \
|
||||
//} \
|
||||
//void mc_ptr_da_##name##_free(mcl_da_##name##_* da) { \
|
||||
// free(da->items); \
|
||||
//}
|
||||
|
||||
#define MCL_DA_FOR_IN(type, da, item, body) do { \
|
||||
type item; \
|
||||
for (int i = 0; i < (da)->count; i++) { \
|
||||
item = ((da)->items)[i]; \
|
||||
body \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#endif
|
||||
6
src/include/errors.h
Normal file
6
src/include/errors.h
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
#ifndef _H_MCL_ERRORS
|
||||
#define _H_MCL_ERRORS
|
||||
|
||||
const char* FUNC_DECL_EXMPL = "To define a function follow this example: \nmain :: fn(argc: i32, argv: string[]) {\n ...\n}";
|
||||
|
||||
#endif
|
||||
11
src/include/loc.h
Normal file
11
src/include/loc.h
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
#ifndef _H_MCL_LOC
|
||||
#define _H_MCL_LOC
|
||||
|
||||
#include <stdio.h>
|
||||
typedef struct loc_s {
|
||||
char* file;
|
||||
size_t col;
|
||||
size_t line;
|
||||
} loc_t;
|
||||
|
||||
#endif
|
||||
46
src/include/logger.h
Normal file
46
src/include/logger.h
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
#ifndef _H_MCL_LOG
|
||||
#define _H_MCL_LOG
|
||||
|
||||
#include "loc.h"
|
||||
|
||||
#ifdef _LOG_COLORS
|
||||
#define RESET "\x1b[0m"
|
||||
#define BRIGHT "\x1b[1m"
|
||||
#define DIM "\x1b[2m"
|
||||
#define UNDERSCORE "\x1b[4m"
|
||||
#define BLINK "\x1b[5m"
|
||||
#define REVERSE "\x1b[7m"
|
||||
#define HIDDEN "\x1b[8m"
|
||||
#define FG_BLACK "\x1b[30m"
|
||||
#define FG_RED "\x1b[31m"
|
||||
#define FG_GREEN "\x1b[32m"
|
||||
#define FG_YELLOW "\x1b[33m"
|
||||
#define FG_BLUE "\x1b[34m"
|
||||
#define FG_MAGENTA "\x1b[35m"
|
||||
#define FG_CYAN "\x1b[36m"
|
||||
#define FG_WHITE "\x1b[37m"
|
||||
#define BG_BLACK "\x1b[40m"
|
||||
#define BG_RED "\x1b[41m"
|
||||
#define BG_GREEN "\x1b[42m"
|
||||
#define BG_YELLOW "\x1b[43m"
|
||||
#define BG_BLUE "\x1b[44m"
|
||||
#define BG_MAGENTA "\x1b[45m"
|
||||
#define BG_CYAN "\x1b[46m"
|
||||
#define BG_WHITE "\x1b[47m"
|
||||
#endif
|
||||
|
||||
|
||||
typedef enum log_level_e {
|
||||
ERROR = 0,
|
||||
WARN,
|
||||
HELP,
|
||||
INFO,
|
||||
DEBUG,
|
||||
} log_level_t;
|
||||
|
||||
static log_level_t FILTER_LEVEL = INFO;
|
||||
|
||||
void mcl_log(log_level_t level, const char* fmt, ...);
|
||||
void mcl_log_loc(log_level_t level, loc_t* loc, const char* fmt, ...);
|
||||
|
||||
#endif
|
||||
10
src/include/parser.h
Normal file
10
src/include/parser.h
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
#ifndef _H_MCL_PARSER
|
||||
#define _H_MCL_PARSER
|
||||
|
||||
|
||||
#include "tokeniser.h"
|
||||
#include "ast.h"
|
||||
|
||||
ast_program_t* parse(mcl_da_token_t* tokens);
|
||||
|
||||
#endif
|
||||
50
src/include/token.h
Normal file
50
src/include/token.h
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
|
||||
#ifndef _H_MCL_TOKEN
|
||||
#define _H_MCL_TOKEN
|
||||
|
||||
#include "loc.h"
|
||||
typedef enum token_type_e {
|
||||
TT_IDENT, // identifier
|
||||
TT_STR, // "*"
|
||||
TT_CHR, // '*'
|
||||
TT_CURLY_R, // }
|
||||
TT_CURLY_L, // {
|
||||
TT_BRACK_R, // ]
|
||||
TT_BRACK_L, // [
|
||||
TT_PAREN_R, // )
|
||||
TT_PAREN_L, // (
|
||||
TT_COLON, // :
|
||||
TT_SEMI, // ;
|
||||
TT_COMMA, // ,
|
||||
TT_DOT, // .
|
||||
TT_AMP, // &
|
||||
TT_STAR, // *
|
||||
TT_PLUS, // +
|
||||
TT_DASH, // -
|
||||
TT_FSLASH, // /
|
||||
TT_BAR, // |
|
||||
TT_EQ, // =
|
||||
TT_LT, // <
|
||||
TT_GT, // >
|
||||
TT_KW_FN,
|
||||
TT_KW_RETURN,
|
||||
TT_KW_IF,
|
||||
TT_KW_ELSE,
|
||||
TT_KW_FOR,
|
||||
TT_KW_WHILE,
|
||||
TT_KW_STRUCT,
|
||||
TT_KW_ENUM,
|
||||
TT_KW_BREAK,
|
||||
TT_KW_CONTINUE,
|
||||
} token_type_t;
|
||||
|
||||
|
||||
typedef struct token_s {
|
||||
token_type_t type;
|
||||
char* text;
|
||||
loc_t loc;
|
||||
} token_t;
|
||||
|
||||
char* token_to_string(token_t* tt);
|
||||
|
||||
#endif
|
||||
20
src/include/tokeniser.h
Normal file
20
src/include/tokeniser.h
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
#ifndef _H_MCL_TOKENSIER
|
||||
#define _H_MCL_TOKENSIER
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "dyn_arr.h"
|
||||
#include "loc.h"
|
||||
#include "token.h"
|
||||
|
||||
DEFINE_DA(token, token_t)
|
||||
|
||||
typedef struct tokeniser_s {
|
||||
mcl_da_token_t tokens;
|
||||
loc_t loc;
|
||||
} tokeniser_t;
|
||||
|
||||
tokeniser_t* tokenise(char* file);
|
||||
|
||||
#endif
|
||||
|
|
@ -1,442 +0,0 @@
|
|||
use std::collections::HashMap;
|
||||
|
||||
use crate::{constants::{OpType, Loc, InstructionType, KeywordType, Operator}, lerror, error};
|
||||
// use crate::util::logger;
|
||||
use color_eyre::Result;
|
||||
use eyre::eyre;
|
||||
|
||||
use super::{Memory, Function, Constant};
|
||||
mod syscalls;
|
||||
|
||||
fn stack_pop(stack: &mut Vec<usize>, pos: &Loc) -> Result<usize> {
|
||||
if let Some(i) = stack.pop() { Ok(i) } else {
|
||||
lerror!(&pos.clone(), "Stack underflow");
|
||||
Err(eyre!("Stack underflow"))
|
||||
}
|
||||
}
|
||||
|
||||
pub fn run(ops: &[crate::constants::Operator]) -> Result<i32>{
|
||||
let mut stack: Vec<usize> = Vec::new();
|
||||
let mut mem: Vec<u64> = vec![0; crate::MEM_SZ + crate::STRING_SZ];
|
||||
let mut string_idx = 0;
|
||||
|
||||
let prerunned = pre_run(ops);
|
||||
let functions = prerunned.functions;
|
||||
let constants = prerunned.constants;
|
||||
let memories = prerunned.memories;
|
||||
|
||||
let mut ret_stack: Vec<usize> = Vec::new();
|
||||
|
||||
// for token in &tokens {
|
||||
// println!("{{typ: \"{:?}\", val: {}, jmp: {}}}", token.typ, token.value, token.jmp);
|
||||
// }
|
||||
|
||||
// jump to main func
|
||||
let mut ip = if let Some(i) = functions.get("main") {i.id} else {
|
||||
crate::errors::missing_main_fn();
|
||||
return Err(eyre!(""));
|
||||
};
|
||||
|
||||
while ip < ops.len() {
|
||||
let op = &ops[ip];
|
||||
let pos = op.loc.clone();
|
||||
match op.typ.clone() {
|
||||
OpType::Instruction(instruction) => {
|
||||
match instruction {
|
||||
InstructionType::PushInt => {
|
||||
stack.push(op.value);
|
||||
ip += 1;
|
||||
},
|
||||
InstructionType::PushStr => {
|
||||
if op.addr.is_none() {
|
||||
stack.push(op.text.len()); // string len
|
||||
stack.push(string_idx + crate::MEM_SZ);
|
||||
|
||||
for c in op.text.bytes() {
|
||||
mem[crate::MEM_SZ + string_idx] = u64::from(c);
|
||||
string_idx += 1;
|
||||
}
|
||||
} else {
|
||||
stack.push(op.text.len());
|
||||
if let Some(addr) = op.addr {
|
||||
stack.push(addr);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ip += 1;
|
||||
},
|
||||
InstructionType::PushCStr => {
|
||||
if op.addr.is_none() {
|
||||
stack.push(string_idx + crate::MEM_SZ);
|
||||
|
||||
for c in op.text.bytes() {
|
||||
mem[crate::MEM_SZ + string_idx] = u64::from(c);
|
||||
string_idx += 1;
|
||||
}
|
||||
} else {
|
||||
if let Some(addr) = op.addr {
|
||||
stack.push(addr);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ip += 1;
|
||||
},
|
||||
InstructionType::Drop => {
|
||||
stack.pop();
|
||||
ip += 1;
|
||||
},
|
||||
InstructionType::Dup => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(a);
|
||||
stack.push(a);
|
||||
ip += 1;
|
||||
},
|
||||
|
||||
InstructionType::Rot => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
let c = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(b);
|
||||
stack.push(a);
|
||||
stack.push(c);
|
||||
ip += 1;
|
||||
}
|
||||
InstructionType::Swap => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(a);
|
||||
stack.push(b);
|
||||
ip += 1;
|
||||
}
|
||||
InstructionType::Over => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(b);
|
||||
stack.push(a);
|
||||
stack.push(b);
|
||||
ip += 1;
|
||||
}
|
||||
|
||||
InstructionType::Print => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
println!("{a}");
|
||||
// let _ = io::stdout().flush();
|
||||
ip += 1;
|
||||
},
|
||||
#[allow(clippy::cast_possible_truncation)]
|
||||
InstructionType::Read8 |
|
||||
InstructionType::Read32 |
|
||||
InstructionType::Read64 => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
if a > crate::MEM_SZ + crate::STRING_SZ {
|
||||
lerror!(&op.loc, "Invalid memory address {a}");
|
||||
return Ok(1);
|
||||
}
|
||||
let byte = mem[a];
|
||||
stack.push(byte as usize);
|
||||
ip += 1;
|
||||
}
|
||||
#[allow(clippy::cast_possible_truncation)]
|
||||
InstructionType::Write8 => {
|
||||
let val = stack_pop(&mut stack, &pos)?;
|
||||
let addr = stack_pop(&mut stack, &pos)?;
|
||||
|
||||
if addr > crate::MEM_SZ {
|
||||
lerror!(&op.loc, "Invalid memory address {addr}");
|
||||
return Ok(1);
|
||||
}
|
||||
|
||||
mem[addr] = u64::from(val as u8);
|
||||
ip += 1;
|
||||
}
|
||||
#[allow(clippy::cast_possible_truncation)]
|
||||
InstructionType::Write32 => {
|
||||
let val = stack_pop(&mut stack, &pos)?;
|
||||
let addr = stack_pop(&mut stack, &pos)?;
|
||||
|
||||
if addr > crate::MEM_SZ {
|
||||
lerror!(&op.loc, "Invalid memory address {addr}");
|
||||
return Ok(1);
|
||||
}
|
||||
|
||||
mem[addr] = u64::from(val as u32);
|
||||
ip += 1;
|
||||
}
|
||||
|
||||
#[allow(clippy::cast_possible_truncation)]
|
||||
InstructionType::Write64 => {
|
||||
let val = stack_pop(&mut stack, &pos)?;
|
||||
let addr = stack_pop(&mut stack, &pos)?;
|
||||
|
||||
if addr > crate::MEM_SZ {
|
||||
lerror!(&op.loc, "Invalid memory address {addr}");
|
||||
return Ok(1);
|
||||
}
|
||||
|
||||
mem[addr] = val as u64;
|
||||
ip += 1;
|
||||
}
|
||||
|
||||
// math
|
||||
InstructionType::Plus => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(b + a);
|
||||
ip += 1;
|
||||
},
|
||||
InstructionType::Minus => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(b - a);
|
||||
ip += 1;
|
||||
},
|
||||
InstructionType::Equals => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(usize::from(b == a));
|
||||
ip += 1;
|
||||
},
|
||||
InstructionType::Gt => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(usize::from(b > a));
|
||||
ip += 1;
|
||||
},
|
||||
InstructionType::Lt => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(usize::from(b < a));
|
||||
ip += 1;
|
||||
},
|
||||
InstructionType::NotEquals => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(usize::from(b != a));
|
||||
ip += 1;
|
||||
},
|
||||
InstructionType::Ge => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(usize::from(b >= a));
|
||||
ip += 1;
|
||||
},
|
||||
InstructionType::Le => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(usize::from(b <= a));
|
||||
ip += 1;
|
||||
},
|
||||
|
||||
InstructionType::Band => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(a & b);
|
||||
ip += 1;
|
||||
}
|
||||
|
||||
InstructionType::Bor => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(a | b);
|
||||
ip += 1;
|
||||
}
|
||||
|
||||
InstructionType::Shr => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(b >> a);
|
||||
ip += 1;
|
||||
}
|
||||
|
||||
InstructionType::Shl => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(b << a);
|
||||
ip += 1;
|
||||
}
|
||||
|
||||
InstructionType::DivMod => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(b / a);
|
||||
stack.push(b % a);
|
||||
ip += 1;
|
||||
}
|
||||
InstructionType::Mul => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
let b = stack_pop(&mut stack, &pos)?;
|
||||
stack.push(b * a);
|
||||
ip += 1;
|
||||
}
|
||||
InstructionType::Syscall0 => {
|
||||
todo!();
|
||||
// ti += 1;
|
||||
},
|
||||
InstructionType::Syscall1 => {
|
||||
todo!();
|
||||
// ti += 1;
|
||||
},
|
||||
InstructionType::Syscall2 => {
|
||||
todo!();
|
||||
// ti += 1;
|
||||
},
|
||||
InstructionType::Syscall3 => {
|
||||
let rax = stack_pop(&mut stack, &pos)?;
|
||||
let rdi = stack_pop(&mut stack, &pos)?;
|
||||
let rsi = stack_pop(&mut stack, &pos)?;
|
||||
let rdx = stack_pop(&mut stack, &pos)?;
|
||||
// println!("yes");
|
||||
let ret = match rax {
|
||||
1 => syscalls::sys_write(rax, rdi, rsi, rdx, &mem),
|
||||
0 => 0, //? temp, so clippy doesnt complain
|
||||
_ => {
|
||||
error!("Syscall(3) #{} is not implemented", rax);
|
||||
return Err(eyre!("Syscall not implemented"));
|
||||
}
|
||||
};
|
||||
stack.push(ret);
|
||||
// println!("{}", stack.len());
|
||||
ip += 1;
|
||||
},
|
||||
InstructionType::Syscall4 => {
|
||||
todo!();
|
||||
// ti += 1;
|
||||
},
|
||||
InstructionType::Syscall5 => {
|
||||
todo!();
|
||||
// ti += 1;
|
||||
},
|
||||
InstructionType::Syscall6 => {
|
||||
todo!();
|
||||
// ti += 1;
|
||||
},
|
||||
InstructionType::MemUse => {
|
||||
|
||||
let m = memories.get(&op.addr.unwrap()).unwrap();
|
||||
stack.push(m.id);
|
||||
ip += 1;
|
||||
},
|
||||
InstructionType::FnCall => {
|
||||
ret_stack.push(ip);
|
||||
let f = functions.get(&op.text).unwrap();
|
||||
ip = f.id;
|
||||
}
|
||||
InstructionType::Return => {
|
||||
ip = ret_stack.pop().unwrap();
|
||||
ip += 1;
|
||||
}
|
||||
InstructionType::ConstUse => {
|
||||
let a = constants.get(&op.text).unwrap();
|
||||
|
||||
if let Some(i) = a.value_i {
|
||||
stack.push(i);
|
||||
} else if let Some(_s) = a.value_s.clone() {
|
||||
unimplemented!();
|
||||
}
|
||||
ip += 1;
|
||||
},
|
||||
InstructionType::CastBool |
|
||||
InstructionType::CastPtr |
|
||||
InstructionType::CastInt |
|
||||
InstructionType::CastVoid |
|
||||
InstructionType::TypeBool |
|
||||
InstructionType::TypePtr |
|
||||
InstructionType::TypeInt |
|
||||
InstructionType::TypeVoid |
|
||||
InstructionType::TypeAny |
|
||||
InstructionType::Returns |
|
||||
InstructionType::With => ip += 1,
|
||||
InstructionType::None => unreachable!(),
|
||||
}
|
||||
|
||||
}
|
||||
OpType::Keyword(k) => {
|
||||
match k {
|
||||
// blocks
|
||||
KeywordType::If => {
|
||||
let a = stack_pop(&mut stack, &pos)?;
|
||||
if a == 0 {
|
||||
// println!("If({ti}) => t: {:?} j: {}", tokens[token.jmp as usize].typ, token.jmp);
|
||||
ip = op.jmp;
|
||||
} else {
|
||||
ip += 1;
|
||||
}
|
||||
},
|
||||
KeywordType::Else | KeywordType::End => {
|
||||
ip = op.jmp;
|
||||
}
|
||||
KeywordType::Do => {
|
||||
let a = stack.pop().unwrap();
|
||||
if a == 0 {
|
||||
ip = op.jmp;
|
||||
} else {
|
||||
ip += 1;
|
||||
}
|
||||
}
|
||||
KeywordType::While | //* exept this one, this one should just skip over
|
||||
KeywordType::Memory |
|
||||
KeywordType::FunctionDef |
|
||||
KeywordType::FunctionDefExported |
|
||||
KeywordType::ConstantDef => {
|
||||
//? Disabled since we now pre run the whole program
|
||||
// constants.insert(op.text.clone(), Constant { loc: op.loc.clone(), name: op.text.clone(), value_i: Some(op.value), value_s: None, used: false });
|
||||
ip += 1;
|
||||
},
|
||||
KeywordType::FunctionDone => {
|
||||
if let Some(i) = ret_stack.pop() {
|
||||
ip = i + 1;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
},
|
||||
|
||||
KeywordType::FunctionThen => ip += 1,
|
||||
KeywordType::Constant |
|
||||
KeywordType::Function |
|
||||
KeywordType::Inline |
|
||||
KeywordType::Export |
|
||||
KeywordType::Include => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Ok(0)
|
||||
}
|
||||
|
||||
pub struct Defineds {
|
||||
pub memories: HashMap<usize, Memory>,
|
||||
pub functions: HashMap<String, Function>,
|
||||
pub constants: HashMap<String, Constant>
|
||||
}
|
||||
|
||||
pub fn pre_run(ops: &[Operator]) -> Defineds {
|
||||
let mut defineds = Defineds{
|
||||
memories: HashMap::new(),
|
||||
functions: HashMap::new(),
|
||||
constants: HashMap::new(),
|
||||
};
|
||||
for (ip, op) in ops.iter().enumerate() {
|
||||
|
||||
match op.typ {
|
||||
OpType::Keyword(KeywordType::Memory) => {
|
||||
defineds.memories.insert(op.addr.unwrap(), Memory { size: op.value, loc: op.loc.clone(), id: op.addr.unwrap() });
|
||||
},
|
||||
OpType::Keyword(KeywordType::FunctionDefExported) => {
|
||||
|
||||
}
|
||||
OpType::Keyword(KeywordType::FunctionDef) => {
|
||||
defineds.functions.insert(op.text.clone(), Function { loc: op.loc.clone(), name: op.text.clone(), id: ip });
|
||||
},
|
||||
OpType::Keyword(KeywordType::ConstantDef) => {
|
||||
defineds.constants.insert(op.text.clone(), Constant { loc: op.loc.clone(), name: op.text.clone(), value_i: Some(op.value), value_s: None, used: false });
|
||||
},
|
||||
_ => ()
|
||||
}
|
||||
}
|
||||
defineds
|
||||
}
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
#[allow(clippy::cast_possible_truncation)]
|
||||
pub fn sys_write(sys_n: usize, fd: usize, buff: usize, count: usize, mem: &Vec<u64> ) -> usize {
|
||||
let mem = (*mem).clone();
|
||||
// println!("{:?}", &mem[buff..(buff + count)]);
|
||||
// return 0 ;
|
||||
let s = &mem[buff..(buff + count)].iter().map(|i| {
|
||||
char::from_u32(u32::from(*i as u8)).unwrap_or('_').to_string()
|
||||
}).collect::<String>();
|
||||
|
||||
match fd {
|
||||
1 => {
|
||||
print!("{s}");
|
||||
},
|
||||
2 => {
|
||||
eprint!("{s}");
|
||||
},
|
||||
_ => panic!("Unknown file {fd}")
|
||||
};
|
||||
let _ = std::io::Write::flush(&mut std::io::stdout());
|
||||
let _ = std::io::Write::flush(&mut std::io::stderr());
|
||||
sys_n
|
||||
}
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
use crate::constants::Loc;
|
||||
|
||||
pub mod linux_x86_64;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Constant {
|
||||
pub loc: Loc,
|
||||
pub name: String,
|
||||
pub value_i: Option<usize>,
|
||||
pub value_s: Option<String>,
|
||||
pub used: bool
|
||||
// extern: bool
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Memory {
|
||||
pub size: usize,
|
||||
pub loc: Loc,
|
||||
pub id: usize
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Function {
|
||||
pub loc: Loc,
|
||||
pub name: String,
|
||||
pub id: usize
|
||||
}
|
||||
147
src/lexer.rs
147
src/lexer.rs
|
|
@ -1,147 +0,0 @@
|
|||
|
||||
use crate::{definitions::{Token, TokenType}, Args};
|
||||
|
||||
fn lex_word(s: String, tok_type: TokenType) -> (TokenType, String) {
|
||||
match s {
|
||||
s if s.parse::<u64>().is_ok() && tok_type == TokenType::Word => { // negative numbers not yet implemented
|
||||
(TokenType::Int, s)
|
||||
},
|
||||
s if tok_type == TokenType::Word => {
|
||||
(TokenType::Word, s)
|
||||
},
|
||||
s if tok_type == TokenType::String => {
|
||||
(TokenType::String, s)
|
||||
}
|
||||
s if tok_type == TokenType::CString => {
|
||||
(TokenType::CString, s)
|
||||
}
|
||||
s if tok_type == TokenType::Char => {
|
||||
(TokenType::Char, s)
|
||||
}
|
||||
_ => unreachable!()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn find_col<F>(text: &str, mut col: usize, predicate: F) -> usize where F: Fn(char, char) -> bool {
|
||||
let mut last = '\0';
|
||||
while col < text.len() && !predicate(text.chars().nth(col).unwrap(), last) {
|
||||
last = text.chars().nth(col).unwrap();
|
||||
col += 1;
|
||||
}
|
||||
|
||||
col
|
||||
}
|
||||
|
||||
|
||||
// TODO: Implement multiline strings
|
||||
fn lex_line(text: &str) -> Vec<(usize, String, TokenType)> {
|
||||
let mut tokens: Vec<(usize, String, TokenType)> = Vec::new();
|
||||
|
||||
let mut col = find_col(text, 0, |x, _| !x.is_whitespace());
|
||||
let mut col_end: usize = 0;
|
||||
while col_end < text.to_string().len() {
|
||||
if (text.len() - col) < 1 {
|
||||
return tokens;
|
||||
}
|
||||
if &text[col..=col] == "\"" {
|
||||
col_end = find_col(text, col + 1, |x, x2| x == '"' && x2 != '\\');
|
||||
let t = &text[(col + 1)..col_end];
|
||||
let t = t.replace("\\n", "\n")
|
||||
.replace("\\t", "\t")
|
||||
.replace("\\r", "\r")
|
||||
.replace("\\\'", "\'")
|
||||
.replace("\\\"", "\"")
|
||||
.replace("\\0", "\0");
|
||||
if !t.is_empty() {
|
||||
tokens.push((col, t.to_string(), TokenType::String));
|
||||
}
|
||||
col = find_col(text, col_end + 1, |x, _| !x.is_whitespace());
|
||||
|
||||
} else if &text[col..=col] == "'"{
|
||||
col_end = find_col(text, col + 1, |x, x2| x == '\'' && x2 != '\\');
|
||||
let t = &text[(col + 1)..col_end];
|
||||
let t = t.replace("\\n", "\n")
|
||||
.replace("\\t", "\t")
|
||||
.replace("\\r", "\r")
|
||||
.replace("\\\'", "\'")
|
||||
.replace("\\\"", "\"")
|
||||
.replace("\\0", "\0");
|
||||
|
||||
|
||||
if !t.is_empty() {
|
||||
tokens.push((col, t.to_string(), TokenType::Char));
|
||||
}
|
||||
col = find_col(text, col_end + 1, |x, _| !x.is_whitespace());
|
||||
|
||||
} else {
|
||||
|
||||
if &text[col..=col] == "c" && text.len() - 1 + col > 0 && &text[col+1..=col+1] == "\"" {
|
||||
col_end = find_col(text, col + 2, |x, x2| x == '"' && x2 != '\\');
|
||||
let t = &text[(col + 2)..col_end];
|
||||
let mut t = t.replace("\\n", "\n")
|
||||
.replace("\\t", "\t")
|
||||
.replace("\\r", "\r")
|
||||
.replace("\\\'", "\'")
|
||||
.replace("\\\"", "\"")
|
||||
.replace("\\0", "\0");
|
||||
|
||||
if !t.is_empty() {
|
||||
t.push('\0');
|
||||
tokens.push((col, t.to_string(), TokenType::CString));
|
||||
}
|
||||
col = find_col(text, col_end + 1, |x, _| !x.is_whitespace());
|
||||
|
||||
} else {
|
||||
col_end = find_col(text, col, |x, _| x.is_whitespace());
|
||||
let t = &text[col..col_end];
|
||||
|
||||
if t == "//" {
|
||||
return tokens;
|
||||
}
|
||||
|
||||
if !t.is_empty() {
|
||||
tokens.push((col, t.to_string(), TokenType::Word));
|
||||
}
|
||||
col = find_col(text, col_end, |x, _| !x.is_whitespace());
|
||||
}
|
||||
}
|
||||
}
|
||||
tokens
|
||||
}
|
||||
|
||||
pub fn lex(code: &str, file: &str, _args: &Args) -> Vec<Token> {
|
||||
let lines: Vec<(usize, &str)> = code
|
||||
.split(['\n', '\r'])
|
||||
.enumerate()
|
||||
.collect();
|
||||
|
||||
let lines: Vec<(usize, String)> = lines.iter().map(|i| (i.0, i.1.to_string())).collect();
|
||||
|
||||
let mut tokens: Vec<Token> = Vec::new();
|
||||
|
||||
for (row, line) in lines {
|
||||
let lt = lex_line(&line);
|
||||
for (col, tok, tok_type) in lt {
|
||||
let (tok_type, tok) = lex_word(tok, tok_type);
|
||||
let t = Token{
|
||||
file: file.to_string(),
|
||||
line: row + 1,
|
||||
col,
|
||||
text: tok,
|
||||
typ: tok_type,
|
||||
value: None,
|
||||
addr: None,
|
||||
op_typ: crate::definitions::OpType::Instruction(crate::definitions::InstructionType::None)
|
||||
};
|
||||
tokens.push(t);
|
||||
}
|
||||
}
|
||||
// println!("{}", tokens.len());
|
||||
|
||||
// for token in tokens.clone() {
|
||||
// println!("tok: {:?}", token.text);
|
||||
// }
|
||||
|
||||
|
||||
tokens
|
||||
}
|
||||
16
src/loc.c
Normal file
16
src/loc.c
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
#include "loc.h"
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
// NEEDS to be freed
|
||||
char* loc_str(loc_t* loc) {
|
||||
size_t len = ( (20*2) + // 2 max lens of u64 int as strings
|
||||
strlen(loc->file) + // file path length
|
||||
2 // 2 colons
|
||||
);
|
||||
char* buf = malloc(sizeof(char)*len);
|
||||
snprintf(buf, len, "%s:%zu:%zu", loc->file, loc->line, loc->col);
|
||||
return buf;
|
||||
}
|
||||
|
||||
|
||||
44
src/logger.c
Normal file
44
src/logger.c
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#define _LOG_COLORS
|
||||
#include "logger.h"
|
||||
#include "loc.h"
|
||||
|
||||
|
||||
void mcl_log(log_level_t level, const char *fmt, ...) {
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
char* prefix;
|
||||
switch (level) {
|
||||
case ERROR: prefix = BRIGHT FG_RED "ERROR" RESET; break;
|
||||
case WARN: prefix = BRIGHT FG_YELLOW "WARN" RESET; break;
|
||||
case HELP: prefix = BRIGHT FG_CYAN "HELP" RESET; break;
|
||||
case INFO: prefix = BRIGHT FG_GREEN "INFO" RESET; break;
|
||||
case DEBUG: prefix = BRIGHT FG_BLUE "DEBUG" RESET; break;
|
||||
}
|
||||
printf("%s: ", prefix);
|
||||
vprintf(fmt, args);
|
||||
puts("");
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
void mcl_log_loc(log_level_t level, loc_t* loc, const char *fmt, ...) {
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
char* prefix;
|
||||
switch (level) {
|
||||
case ERROR: prefix = BRIGHT FG_RED "ERROR" RESET; break;
|
||||
case WARN: prefix = BRIGHT FG_YELLOW "WARN" RESET; break;
|
||||
case HELP: prefix = BRIGHT FG_CYAN "HELP" RESET; break;
|
||||
case INFO: prefix = BRIGHT FG_GREEN "INFO" RESET; break;
|
||||
case DEBUG: prefix = BRIGHT FG_BLUE "DEBUG" RESET; break;
|
||||
}
|
||||
|
||||
printf(BRIGHT"%s"RESET":"BRIGHT"%zu"RESET":"BRIGHT"%zu"RESET": ", loc->file, loc->line, loc->col);
|
||||
|
||||
printf("%s: ", prefix);
|
||||
vprintf(fmt, args);
|
||||
puts("");
|
||||
va_end(args);
|
||||
}
|
||||
34
src/main.c
Normal file
34
src/main.c
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "cliargs.h"
|
||||
#include "dyn_arr.h"
|
||||
#include "token.h"
|
||||
#include "tokeniser.h"
|
||||
#include "parser.h"
|
||||
#include "logger.h"
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
cliargs_t* cliargs = parse_cliargs(argc, argv);
|
||||
mcl_log(DEBUG, "Output file: %s", cliargs->output);
|
||||
|
||||
MCL_DA_FOR_IN(char*, &cliargs->input, file, {
|
||||
mcl_log(DEBUG, "Input file: %s", file);
|
||||
tokeniser_t* tokeniser = tokenise(file);
|
||||
if (!tokeniser) {
|
||||
mcl_log(ERROR, "Failed to tokenise");
|
||||
return 1;
|
||||
}
|
||||
MCL_DA_FOR_IN(token_t, &tokeniser->tokens, token, {
|
||||
printf("%s:%zu:%zu: %s\n",
|
||||
token.loc.file,
|
||||
token.loc.line,
|
||||
token.loc.col,
|
||||
token_to_string(&token));
|
||||
});
|
||||
//ast_program_t* prog = parse(&tokeniser->tokens);
|
||||
|
||||
});
|
||||
return 0;
|
||||
}
|
||||
127
src/main.rs
127
src/main.rs
|
|
@ -1,127 +0,0 @@
|
|||
#![allow(clippy::wildcard_imports)]
|
||||
#![allow(clippy::too_many_lines)]
|
||||
mod definitions;
|
||||
mod util;
|
||||
mod compile;
|
||||
mod parser;
|
||||
mod lexer;
|
||||
mod preprocessor;
|
||||
mod typechecker;
|
||||
mod precompiler;
|
||||
mod config;
|
||||
mod errors;
|
||||
pub mod test;
|
||||
use config::*;
|
||||
use std::{fs, collections::HashMap};
|
||||
|
||||
use clap::Parser;
|
||||
use anyhow::{Result, bail};
|
||||
|
||||
#[derive(Parser, Debug, Clone)]
|
||||
#[command(author=env!("CARGO_PKG_AUTHORS"), version=env!("CARGO_PKG_VERSION"), about=env!("CARGO_PKG_DESCRIPTION"), long_about=env!("CARGO_PKG_DESCRIPTION"))]
|
||||
pub struct Args {
|
||||
/// Input source file
|
||||
in_file: String,
|
||||
|
||||
/// Output compiled file
|
||||
#[arg(long, short, default_value_t=String::from(DEFAULT_OUT_FILE))]
|
||||
out_file: String,
|
||||
|
||||
/// Interpert
|
||||
#[arg(long, short='s')]
|
||||
interpret: bool,
|
||||
|
||||
/// Run the compiled executable
|
||||
#[arg(long, short)]
|
||||
run: bool,
|
||||
|
||||
/// Dont print any output exept the actual running codes output
|
||||
#[arg(long, short)]
|
||||
quiet: bool,
|
||||
|
||||
/// Add an include directory [default: ["./include", "~/.mclang/include"]]
|
||||
#[arg(long, short='I')]
|
||||
include: Vec<String>,
|
||||
|
||||
/// Unsafe mode, disables typechecking
|
||||
#[arg(long="unsafe", default_value_t = false)]
|
||||
unsaf: bool,
|
||||
|
||||
/// Optimisation level, available levels: 'D': debug, '0': No optimisations
|
||||
#[arg(long, short='O', default_value_t=String::from("0"))]
|
||||
optimisation: String,
|
||||
|
||||
// disables the main function
|
||||
#[arg(long="lib")]
|
||||
lib_mode: bool
|
||||
//#[arg(long, short='F')]
|
||||
//features: Vec<String>,
|
||||
|
||||
}
|
||||
|
||||
impl Args {
|
||||
/// Get optimisation level
|
||||
/// 0 => no optimisations
|
||||
/// 1 => slight optimisations, mostly size ones
|
||||
/// # Errors
|
||||
///
|
||||
/// Throws when the opt level is not known
|
||||
pub fn get_opt_level(&self) -> Result<usize>{
|
||||
match self.optimisation.as_str() {
|
||||
"D" | "d" => Ok(0),
|
||||
"0" | "" => Ok(1),
|
||||
o => {
|
||||
error!("Unknown optimisation level {o}");
|
||||
bail!("")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn main() -> Result<()>{
|
||||
|
||||
|
||||
let args = Args::parse();
|
||||
|
||||
let Ok(code) = fs::read_to_string(&args.in_file) else {
|
||||
error!("Failed to read file {}, exiting!", &args.in_file);
|
||||
return Ok(());
|
||||
};
|
||||
|
||||
let tokens = lexer::lex(&code, args.in_file.as_str(), &args);
|
||||
|
||||
|
||||
let mut parser = parser::Parser::new(tokens, &args, None);
|
||||
let program = match parser.parse(){
|
||||
Ok(t) => t,
|
||||
Err(e) => {
|
||||
error!("Parsing failed, exiting!");
|
||||
if crate::DEV_MODE {
|
||||
return Err(e)
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
};
|
||||
|
||||
match typechecker::typecheck(program.ops.clone(), &args, None, HashMap::new(), HashMap::new()) {
|
||||
Ok(_) => (),
|
||||
Err(e) => {
|
||||
error!("Typechecking failed, exiting!");
|
||||
if crate::DEV_MODE {
|
||||
return Err(e);
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
};
|
||||
|
||||
let c =match compile::linux_x86_64::compile(&program, &args) {
|
||||
Ok(c) => c,
|
||||
Err(e) => {
|
||||
error!("Compilation failed, exiting!");
|
||||
println!("{e}");
|
||||
1
|
||||
}
|
||||
};
|
||||
|
||||
std::process::exit(c);
|
||||
}
|
||||
111
src/parser.c
Normal file
111
src/parser.c
Normal file
|
|
@ -0,0 +1,111 @@
|
|||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "parser.h"
|
||||
#include "ast.h"
|
||||
#include "token.h"
|
||||
#include "tokeniser.h"
|
||||
#include "errors.h"
|
||||
#include "dyn_arr.h"
|
||||
#include "logger.h"
|
||||
|
||||
DEFINE_DA_IMPL(ast_node, void*);
|
||||
DEFINE_DA_IMPL(func_param, ast_func_param_t);
|
||||
|
||||
token_t* expect_token(mcl_da_token_t* tks, token_t t);
|
||||
token_t* try_token(mcl_da_token_t* tks, token_t t);
|
||||
token_t* expect_token_err(mcl_da_token_t* tks, token_t t);
|
||||
ast_func_decl_t* parse_func(mcl_da_token_t* tokens, ast_ident_t name);
|
||||
|
||||
|
||||
ast_program_t* parse(mcl_da_token_t* tokens) {
|
||||
ast_program_t* prog = malloc(sizeof(ast_program_t));
|
||||
assert(prog && "Out of mem");
|
||||
|
||||
token_t* tok = NULL;
|
||||
while ((tok=mcl_da_token_pop_front(tokens)) != NULL) {
|
||||
switch(tok->type) {
|
||||
case TT_IDENT: {
|
||||
// printf("IDENT: %s\n", tok->text);
|
||||
if (!expect_token_err(tokens, (token_t){.type=TT_COLON })) return NULL;
|
||||
if (!expect_token_err(tokens, (token_t){.type=TT_COLON })) return NULL;
|
||||
token_t* type = mcl_da_token_pop_front(tokens);
|
||||
|
||||
if (type->type == TT_KW_FN) {
|
||||
ast_ident_t name = {
|
||||
.name = tok->text,
|
||||
.loc = tok->loc
|
||||
};
|
||||
mcl_da_ast_node_push(&prog->body, parse_func(tokens, name));
|
||||
} else if (type->type == TT_KW_STRUCT) {
|
||||
|
||||
} else if (type->type == TT_KW_ENUM) {
|
||||
|
||||
}
|
||||
return NULL;
|
||||
|
||||
} break;
|
||||
}
|
||||
// mcl_da_ast_node_push(prog->body, );
|
||||
}
|
||||
return prog;
|
||||
}
|
||||
|
||||
|
||||
ast_func_decl_t* parse_func(mcl_da_token_t* tokens, ast_ident_t name) {
|
||||
ast_func_decl_t* func = malloc(sizeof(ast_func_decl_t));
|
||||
// parse args
|
||||
if (!expect_token_err(tokens, (token_t){.type=TT_PAREN_L})) return NULL;
|
||||
while (!try_token(tokens, (token_t){.type=TT_PAREN_R})) {
|
||||
|
||||
// Name
|
||||
token_t* arg_name = expect_token_err(tokens,(token_t){.type=TT_IDENT});
|
||||
if (!arg_name) return NULL;
|
||||
|
||||
if (!expect_token_err(tokens, (token_t){.type=TT_COLON})) return NULL;
|
||||
|
||||
// Type
|
||||
token_t* type = expect_token_err(tokens, (token_t){.type=TT_IDENT});
|
||||
if (!type) return NULL;
|
||||
|
||||
ast_func_param_t param = {
|
||||
.name = { .name = arg_name->text, .loc = arg_name->loc },
|
||||
.type = { .name = { .name = type->text, .loc = type->loc}, .inner=NULL},
|
||||
};
|
||||
mcl_da_func_param_push(&func->params, param);
|
||||
|
||||
if (!try_token(tokens, (token_t){.type=TT_COMMA})) {
|
||||
if (!expect_token_err(tokens, (token_t){.type=TT_PAREN_R})) return NULL;
|
||||
}
|
||||
}
|
||||
// parse body
|
||||
return func;
|
||||
}
|
||||
|
||||
token_t* expect_token(mcl_da_token_t* tks, token_t t) {
|
||||
token_t* _tok_ = mcl_da_token_pop_front(tks);
|
||||
if (_tok_->type != t.type) {
|
||||
return NULL;
|
||||
}
|
||||
return _tok_;
|
||||
}
|
||||
token_t* try_token(mcl_da_token_t* tks, token_t t) {
|
||||
token_t* _tok_ = mcl_da_token_peek_front(tks);
|
||||
if (_tok_->type != t.type) {
|
||||
return NULL;
|
||||
}
|
||||
return _tok_;
|
||||
}
|
||||
token_t* expect_token_err(mcl_da_token_t* tks, token_t t) {
|
||||
token_t* _tok_ = mcl_da_token_pop_front(tks);
|
||||
if (_tok_->type != t.type) {
|
||||
mcl_log(ERROR, "Expected %s", token_to_string(&t));
|
||||
mcl_log_loc(INFO, &_tok_->loc, "Got %s", token_to_string(_tok_));
|
||||
return NULL;
|
||||
|
||||
}
|
||||
return _tok_;
|
||||
}
|
||||
|
||||
229
src/parser.rs
229
src/parser.rs
|
|
@ -1,229 +0,0 @@
|
|||
use std::ops::Deref;
|
||||
|
||||
use crate::{definitions::{Operator, OpType, Token, TokenType, Loc, KeywordType, InstructionType, InternalType, Program}, lerror, preprocessor::Preprocessor, Args};
|
||||
use anyhow::{Result, bail};
|
||||
|
||||
pub fn cross_ref(mut program: Vec<Operator>) -> Result<Vec<Operator>> {
|
||||
let mut stack: Vec<usize> = Vec::new();
|
||||
|
||||
for ip in 0..program.len() {
|
||||
let op = &program.clone()[ip];
|
||||
// println!("{op:?}");
|
||||
match op.typ {
|
||||
// OpType::Keyword(KeywordType::FunctionDef) |
|
||||
OpType::Keyword(KeywordType::If | KeywordType::While) => {
|
||||
stack.push(ip);
|
||||
}
|
||||
OpType::Keyword(KeywordType::Else) => {
|
||||
let Some(if_ip) = stack.pop() else {
|
||||
lerror!(&op.loc, "Unclosed-if else block");
|
||||
bail!("Cross referencing")
|
||||
};
|
||||
if program[if_ip].typ != OpType::Keyword(KeywordType::If) {
|
||||
lerror!(&op.clone().loc,"'else' can only close 'if' blocks");
|
||||
bail!("Bad block")
|
||||
}
|
||||
|
||||
program[if_ip].jmp = ip + 1;
|
||||
stack.push(ip);
|
||||
},
|
||||
OpType::Keyword(KeywordType::End) => {
|
||||
let Some(block_ip) = stack.pop() else {
|
||||
lerror!(&op.loc, "Unclosed if, if-else, while-do, function, memory, or constant");
|
||||
bail!("Cross referencing")
|
||||
};
|
||||
|
||||
match &program[block_ip].typ {
|
||||
OpType::Keyword(KeywordType::If | KeywordType::Else) => {
|
||||
program[block_ip].jmp = ip;
|
||||
program[ip].jmp = ip + 1;
|
||||
}
|
||||
|
||||
OpType::Keyword(KeywordType::Do) => {
|
||||
program[ip].jmp = program[block_ip].jmp;
|
||||
program[block_ip].jmp = ip + 1;
|
||||
}
|
||||
|
||||
OpType::Keyword(KeywordType::Memory | KeywordType::Constant) => (),
|
||||
|
||||
a => {
|
||||
println!("{a:?}");
|
||||
lerror!(&op.clone().loc,"'end' can only close if, if-else, while-do, function, memory, or constant blocks");
|
||||
bail!("")
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
OpType::Keyword(KeywordType::Do) => {
|
||||
let Some(block_ip) = stack.pop() else {
|
||||
lerror!(&op.loc, "Unclosed while-do block");
|
||||
bail!("Cross referencing")
|
||||
};
|
||||
|
||||
program[ip].jmp = block_ip;
|
||||
stack.push(ip);
|
||||
}
|
||||
_ => ()
|
||||
}
|
||||
|
||||
}
|
||||
if !stack.is_empty() {
|
||||
// println!("{:?}", stack);
|
||||
let i = stack.pop().expect("Empy stack");
|
||||
lerror!(&program[i].clone().loc,"Unclosed block, {:?}", program[i].clone());
|
||||
bail!("Unclosed block")
|
||||
}
|
||||
|
||||
Ok(program.clone())
|
||||
}
|
||||
|
||||
pub struct Parser<'a> {
|
||||
tokens: Vec<Token>,
|
||||
pub preprocessor: Preprocessor<'a>,
|
||||
#[allow(dead_code)]
|
||||
args: &'a Args
|
||||
}
|
||||
|
||||
impl<'a> Parser<'a> {
|
||||
pub fn new(file: Vec<Token>, args: &'a Args, p: Option<Preprocessor<'a>>) -> Self {
|
||||
let pre = if let Some(p) = p {p} else {
|
||||
Preprocessor::new(Vec::new(), args)
|
||||
};
|
||||
|
||||
Self{
|
||||
tokens: file,
|
||||
preprocessor: pre,
|
||||
args
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse(&mut self) -> Result<Program> {
|
||||
let mut tokens = Vec::new();
|
||||
|
||||
for token in &self.tokens {
|
||||
if token.text.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let pos = (token.file.clone(), token.line, token.col);
|
||||
match token.typ {
|
||||
TokenType::Word => {
|
||||
let word_type = if token.op_typ == OpType::Instruction(InstructionType::MemUse) {
|
||||
OpType::Instruction(InstructionType::MemUse)
|
||||
} else {
|
||||
lookup_word(&token.text, &pos)
|
||||
};
|
||||
|
||||
tokens.push(Operator::new(word_type, token.typ, token.value.unwrap_or(0), token.text.clone(), token.file.clone(), token.line, token.col).set_addr(token.addr.unwrap_or(0)));
|
||||
},
|
||||
TokenType::Int => {// negative numbers not yet implemented
|
||||
tokens.push(Operator::new(OpType::Instruction(InstructionType::PushInt), token.typ, token.text.parse::<usize>()?, String::new(), token.file.clone(), token.line, token.col));
|
||||
},
|
||||
TokenType::String => {
|
||||
tokens.push(Operator::new(OpType::Instruction(InstructionType::PushStr), token.typ, 0, token.text.clone(), token.file.clone(), token.line, token.col));
|
||||
},
|
||||
TokenType::CString => {
|
||||
tokens.push(Operator::new(OpType::Instruction(InstructionType::PushCStr), token.typ, 0, token.text.clone(), token.file.clone(), token.line, token.col));
|
||||
},
|
||||
TokenType::Char => {
|
||||
let c = token.text.clone();
|
||||
if c.len() != 1 {
|
||||
lerror!(&token.loc(), "Chars can only be of lenght 1, got {}", c.len());
|
||||
bail!("")
|
||||
}
|
||||
|
||||
tokens.push(Operator::new(OpType::Instruction(InstructionType::PushInt), token.typ, token.text.chars().next().unwrap() as usize, String::new(), token.file.clone(), token.line, token.col));
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
}
|
||||
self.preprocessor.program.ops = tokens;
|
||||
let mut t = self.preprocessor.preprocess()?.get_program();
|
||||
t.ops = cross_ref(t.ops)?;
|
||||
|
||||
Ok(t)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
pub fn lookup_word<P: Deref<Target = Loc>>(s: &str, _pos: P) -> OpType {
|
||||
let n = s.parse::<usize>();
|
||||
if n.is_ok() {
|
||||
return OpType::Instruction(InstructionType::PushInt);
|
||||
}
|
||||
match s {
|
||||
//stack
|
||||
"_dbg_print" => OpType::Instruction(InstructionType::Print),
|
||||
"dup" => OpType::Instruction(InstructionType::Dup),
|
||||
"drop" => OpType::Instruction(InstructionType::Drop),
|
||||
"rot" => OpType::Instruction(InstructionType::Rot),
|
||||
"over" => OpType::Instruction(InstructionType::Over),
|
||||
"swap" => OpType::Instruction(InstructionType::Swap),
|
||||
|
||||
// comp and math
|
||||
"+" => OpType::Instruction(InstructionType::Plus),
|
||||
"-" => OpType::Instruction(InstructionType::Minus),
|
||||
"=" => OpType::Instruction(InstructionType::Equals),
|
||||
"!=" => OpType::Instruction(InstructionType::NotEquals),
|
||||
">" => OpType::Instruction(InstructionType::Gt),
|
||||
"<" => OpType::Instruction(InstructionType::Lt),
|
||||
">=" => OpType::Instruction(InstructionType::Ge),
|
||||
"<=" => OpType::Instruction(InstructionType::Le),
|
||||
|
||||
"band" => OpType::Instruction(InstructionType::Band),
|
||||
"bor" => OpType::Instruction(InstructionType::Bor),
|
||||
"shr" => OpType::Instruction(InstructionType::Shr),
|
||||
"shl" => OpType::Instruction(InstructionType::Shl),
|
||||
"divmod" => OpType::Instruction(InstructionType::DivMod),
|
||||
"*" => OpType::Instruction(InstructionType::Mul),
|
||||
|
||||
|
||||
// mem
|
||||
"read8" => OpType::Instruction(InstructionType::Read8),
|
||||
"write8" => OpType::Instruction(InstructionType::Write8),
|
||||
"read32" => OpType::Instruction(InstructionType::Read32),
|
||||
"write32" => OpType::Instruction(InstructionType::Write32),
|
||||
"read64" => OpType::Instruction(InstructionType::Read64),
|
||||
"write64" => OpType::Instruction(InstructionType::Write64),
|
||||
|
||||
"syscall0" => OpType::Instruction(InstructionType::Syscall0),
|
||||
"syscall1" => OpType::Instruction(InstructionType::Syscall1),
|
||||
"syscall2" => OpType::Instruction(InstructionType::Syscall2),
|
||||
"syscall3" => OpType::Instruction(InstructionType::Syscall3),
|
||||
"syscall4" => OpType::Instruction(InstructionType::Syscall4),
|
||||
"syscall5" => OpType::Instruction(InstructionType::Syscall5),
|
||||
"syscall6" => OpType::Instruction(InstructionType::Syscall6),
|
||||
"cast(bool)" => OpType::Instruction(InstructionType::CastBool),
|
||||
"cast(ptr)" => OpType::Instruction(InstructionType::CastPtr),
|
||||
"cast(int)" => OpType::Instruction(InstructionType::CastInt),
|
||||
"cast(void)" => OpType::Instruction(InstructionType::CastVoid),
|
||||
// block
|
||||
"if" => OpType::Keyword(KeywordType::If),
|
||||
"else" => OpType::Keyword(KeywordType::Else),
|
||||
"end" => OpType::Keyword(KeywordType::End),
|
||||
"while" => OpType::Keyword(KeywordType::While),
|
||||
"do" => OpType::Keyword(KeywordType::Do),
|
||||
"include" => OpType::Keyword(KeywordType::Include),
|
||||
"memory" => OpType::Keyword(KeywordType::Memory),
|
||||
"const" => OpType::Keyword(KeywordType::Constant),
|
||||
"fn" => OpType::Keyword(KeywordType::Function),
|
||||
"then" => OpType::Keyword(KeywordType::FunctionThen),
|
||||
"done" => OpType::Keyword(KeywordType::FunctionDone),
|
||||
"inline" => OpType::Keyword(KeywordType::Inline),
|
||||
"export" => OpType::Keyword(KeywordType::Export),
|
||||
"struct" => OpType::Keyword(KeywordType::Struct),
|
||||
"return" => OpType::Instruction(InstructionType::Return),
|
||||
"returns" => OpType::Instruction(InstructionType::Returns),
|
||||
"bool" => OpType::Instruction(InstructionType::TypeBool),
|
||||
"int" => OpType::Instruction(InstructionType::TypeInt),
|
||||
"ptr" => OpType::Instruction(InstructionType::TypePtr),
|
||||
"void" => OpType::Instruction(InstructionType::TypeVoid),
|
||||
"any" => OpType::Instruction(InstructionType::TypeAny),
|
||||
"with" => OpType::Instruction(InstructionType::With),
|
||||
|
||||
"->" => OpType::Internal(InternalType::Arrow),
|
||||
|
||||
_ => OpType::Instruction(InstructionType::None)
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,147 +0,0 @@
|
|||
|
||||
use anyhow::{Result, bail};
|
||||
|
||||
use crate::{definitions::{ OpType, InstructionType, Loc, Operator}, lerror};
|
||||
|
||||
fn stack_pop(stack: &mut Vec<usize>, loc: &Loc) -> Result<usize> {
|
||||
if let Some(i) = stack.pop() { Ok(i) } else {
|
||||
lerror!(&loc.clone(), "Stack underflow");
|
||||
bail!("Stack underflow")
|
||||
}
|
||||
}
|
||||
|
||||
pub fn precompile(tokens: &Vec<Operator>) -> Result<Vec<usize>>{
|
||||
|
||||
let mut stack: Vec<usize> = Vec::new();
|
||||
for token in tokens.iter() {
|
||||
match token.typ.clone() {
|
||||
OpType::Instruction(i) => {
|
||||
let loc = token.loc.clone();
|
||||
match i {
|
||||
InstructionType::PushInt => {
|
||||
stack.push(token.value);
|
||||
},
|
||||
InstructionType::Plus => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(b + a);
|
||||
},
|
||||
InstructionType::Minus => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(b - a);
|
||||
},
|
||||
InstructionType::Equals => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(usize::from(b == a));
|
||||
},
|
||||
InstructionType::Gt => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(usize::from(b > a));
|
||||
},
|
||||
InstructionType::Lt => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(usize::from(b < a));
|
||||
},
|
||||
InstructionType::NotEquals => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(usize::from(b != a));
|
||||
},
|
||||
InstructionType::Ge => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(usize::from(b >= a));
|
||||
},
|
||||
InstructionType::Le => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(usize::from(b <= a));
|
||||
},
|
||||
|
||||
InstructionType::Band => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(a & b);
|
||||
}
|
||||
|
||||
InstructionType::Bor => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(a | b);
|
||||
}
|
||||
|
||||
InstructionType::Shr => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(b >> a);
|
||||
}
|
||||
|
||||
InstructionType::Shl => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(b << a);
|
||||
}
|
||||
|
||||
InstructionType::DivMod => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(b / a);
|
||||
stack.push(b % a);
|
||||
}
|
||||
InstructionType::Mul => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(b * a);
|
||||
}
|
||||
InstructionType::Drop => {
|
||||
stack.pop();
|
||||
},
|
||||
InstructionType::Dup => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(a);
|
||||
stack.push(a);
|
||||
},
|
||||
|
||||
InstructionType::Rot => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
let c = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(b);
|
||||
stack.push(a);
|
||||
stack.push(c);
|
||||
}
|
||||
InstructionType::Swap => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(a);
|
||||
stack.push(b);
|
||||
}
|
||||
InstructionType::Over => {
|
||||
let a = stack_pop(&mut stack, &loc)?;
|
||||
let b = stack_pop(&mut stack, &loc)?;
|
||||
stack.push(b);
|
||||
stack.push(a);
|
||||
stack.push(b);
|
||||
}
|
||||
_ => {
|
||||
lerror!(&token.loc, "Unsupported precompiler instruction {:?}", i);
|
||||
dbg!(tokens);
|
||||
bail!("");
|
||||
}
|
||||
}
|
||||
}
|
||||
OpType::Keyword(_) => {
|
||||
lerror!(&token.loc, "Unsupported precompiler keyword {:?}", token.typ);
|
||||
dbg!(tokens);
|
||||
bail!("");
|
||||
}
|
||||
OpType::Internal(t) => panic!("{t:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
Ok(stack)
|
||||
}
|
||||
|
|
@ -1,754 +0,0 @@
|
|||
use std::collections::HashMap;
|
||||
use std::path::{PathBuf, Path};
|
||||
|
||||
|
||||
use anyhow::{Result, bail};
|
||||
|
||||
use crate::definitions::*;
|
||||
use crate::lexer::lex;
|
||||
use crate::precompiler::precompile;
|
||||
use crate::{lerror, Args, warn, linfo, parser};
|
||||
use crate::parser::lookup_word;
|
||||
|
||||
|
||||
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Preprocessor<'a> {
|
||||
pub program: Program,
|
||||
in_function: Option<String>,
|
||||
args: &'a Args,
|
||||
f_inline: bool,
|
||||
f_export: bool,
|
||||
}
|
||||
|
||||
|
||||
impl<'a> Preprocessor<'a> {
|
||||
pub fn new(prog: Vec<Operator>, args: &'a Args) -> Self {
|
||||
Self {
|
||||
args,
|
||||
program: Program {
|
||||
ops: prog,
|
||||
functions: HashMap::new(),
|
||||
memories: HashMap::new(),
|
||||
constants: HashMap::new(),
|
||||
struct_defs: HashMap::new(),
|
||||
struct_allocs: HashMap::new()
|
||||
},
|
||||
in_function: None,
|
||||
f_inline: false,
|
||||
f_export: false,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
pub fn preprocess(&mut self) -> Result<&mut Preprocessor<'a>>{
|
||||
// println!("pre: has do tokens: {:?}", self.program.iter().map(|t| if t.typ == OpType::Keyword(KeywordType::Do) {Some(t)} else {None} ).collect::<Vec<Option<&Operator>>>());
|
||||
|
||||
|
||||
let mut program: Vec<Operator> = Vec::new();
|
||||
|
||||
let mut rtokens = self.program.ops.clone();
|
||||
rtokens.reverse();
|
||||
while !rtokens.is_empty() {
|
||||
let mut op = rtokens.pop().unwrap();
|
||||
// println!("{token:?}");
|
||||
let op_type = op.typ.clone();
|
||||
match op_type {
|
||||
OpType::Keyword(KeywordType::Include) => self.handle_include(&mut rtokens, &mut op)?,
|
||||
OpType::Keyword(KeywordType::Memory) => self.handle_memory(&mut rtokens, &mut op, &mut program)?,
|
||||
OpType::Keyword(KeywordType::Function) => self.handle_function(&mut rtokens, &mut op, &mut program)?,
|
||||
OpType::Keyword(KeywordType::Constant) => self.handle_constant(&mut rtokens, &mut op, &mut program)?,
|
||||
OpType::Keyword(KeywordType::Struct) => self.handle_struct(&mut rtokens, &mut op, &mut program)?,
|
||||
OpType::Keyword(KeywordType::Inline) => {
|
||||
if self.f_export {
|
||||
lerror!(&op.loc, "Function is already marked as exported, function cannot be inline and exported at the same time");
|
||||
bail!("");
|
||||
} else if self.f_inline {
|
||||
lerror!(&op.loc, "Function is already marked as inline, remove this inline Keyword");
|
||||
bail!("");
|
||||
} else {
|
||||
self.f_inline = true;
|
||||
}
|
||||
}
|
||||
|
||||
OpType::Keyword(KeywordType::Export) => {
|
||||
if !crate::config::ENABLE_EXPORTED_FUNCTIONS {
|
||||
lerror!(&op.loc, "Experimental feature Exported functions not enabled");
|
||||
bail!("");
|
||||
}
|
||||
if self.f_inline {
|
||||
lerror!(&op.loc, "Function is already marked as inline, function cannot be inline and exported at the same time");
|
||||
bail!("");
|
||||
} else if self.f_export {
|
||||
lerror!(&op.loc, "Function is already marked as extern, remove this extern Keyword");
|
||||
bail!("");
|
||||
} else {
|
||||
self.f_export = true;
|
||||
}
|
||||
}
|
||||
|
||||
_ => {
|
||||
program.push(op);
|
||||
}
|
||||
}
|
||||
}
|
||||
self.program.ops = program;
|
||||
// println!("has do tokens: {:?}", self.program.iter().map(|t| if t.typ == OpType::Keyword(KeywordType::Do) {Some(t)} else {None} ).collect::<Vec<Option<&Operator>>>());
|
||||
//* Feel free to fix this horrifying shit
|
||||
//* i wanna kms
|
||||
let mut times = 0;
|
||||
// dbg!(program.clone());
|
||||
while self.program.ops.iter().map(|f| {
|
||||
if f.tok_typ == TokenType::Word {
|
||||
match f.typ {
|
||||
OpType::Instruction(InstructionType::FnCall) |
|
||||
OpType::Instruction(InstructionType::MemUse) |
|
||||
OpType::Instruction(InstructionType::StructUse) |
|
||||
OpType::Keyword(KeywordType::FunctionDef) |
|
||||
OpType::Keyword(KeywordType::FunctionDefExported)|
|
||||
OpType::Keyword(KeywordType::ConstantDef) |
|
||||
OpType::Internal(InternalType::StructAlloc{..}) |
|
||||
OpType::Instruction(InstructionType::ConstUse) => OpType::Instruction(InstructionType::PushInt),
|
||||
_ => {
|
||||
lookup_word(&f.text, &f.loc)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
OpType::Instruction(InstructionType::PushInt) // i hate myself, this is a randomly picked optype so its happy and works
|
||||
}
|
||||
|
||||
}).collect::<Vec<OpType>>().contains(&OpType::Instruction(InstructionType::None)){
|
||||
|
||||
if times >= 50 {
|
||||
warn!("File import depth maxed out, if the program crashes try reducing the import depth, good luck youll need it");
|
||||
break
|
||||
}
|
||||
self.expand()?;
|
||||
times += 1;
|
||||
}
|
||||
Ok(self)
|
||||
}
|
||||
|
||||
|
||||
fn handle_include(&mut self, rtokens: &mut Vec<Operator>, op: &mut Operator) -> Result<()> {
|
||||
if rtokens.is_empty() {
|
||||
lerror!(&op.loc, "Include path not found, expected {} but found nothing", TokenType::String.human());
|
||||
bail!("");
|
||||
}
|
||||
|
||||
let include_path = rtokens.pop().unwrap();
|
||||
|
||||
if include_path.tok_typ != TokenType::String {
|
||||
lerror!(&include_path.loc, "Bad include path, expected {} but found {}", TokenType::String.human(), include_path.typ.human());
|
||||
bail!("");
|
||||
}
|
||||
|
||||
let mut in_paths = self.args.include.clone();
|
||||
in_paths.append(&mut crate::DEFAULT_INCLUDES.to_vec().clone().iter().map(|f| (*f).to_string()).collect::<Vec<String>>());
|
||||
|
||||
let mut include_code = String::new();
|
||||
let mut pth = PathBuf::new();
|
||||
if include_path.text.chars().next().unwrap() == '.' {
|
||||
let p = Path::new(include_path.loc.0.as_str());
|
||||
let p = p.parent().unwrap();
|
||||
let p = p.join(&include_path.text);
|
||||
pth = p.clone();
|
||||
include_code = std::fs::read_to_string(p)?;
|
||||
} else {
|
||||
for path in in_paths {
|
||||
let p = PathBuf::from(path);
|
||||
let p = p.join(&include_path.text);
|
||||
pth = p.clone();
|
||||
|
||||
if p.exists() {
|
||||
include_code = std::fs::read_to_string(p)?;
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
if include_code.is_empty() {
|
||||
lerror!(&include_path.loc, "Include file in path '{}' was not found or is empty", include_path.text);
|
||||
bail!("");
|
||||
}
|
||||
let a = pth.to_str().unwrap().to_string();
|
||||
let code = lex(&include_code, a.as_str(), self.args);
|
||||
let mut p = parser::Parser::new(code, self.args, Some(self.clone()));
|
||||
let mut code = p.parse()?;
|
||||
|
||||
self.set_constants(p.preprocessor.get_constants());
|
||||
self.set_functions(p.preprocessor.get_functions());
|
||||
self.set_memories(p.preprocessor.get_memories());
|
||||
code.ops.reverse();
|
||||
rtokens.append(&mut code.ops);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn handle_memory(&mut self, rtokens: &mut Vec<Operator>, op: &mut Operator, program: &mut Vec<Operator>) -> Result<()> {
|
||||
if rtokens.is_empty() {
|
||||
lerror!(&op.loc, "Memory name not found, expected {} but found nothing", TokenType::String.human());
|
||||
bail!("");
|
||||
}
|
||||
|
||||
let name = rtokens.pop().unwrap();
|
||||
|
||||
self.is_word_available(&name, KeywordType::Memory)?;
|
||||
|
||||
let mut code: Vec<Operator> = Vec::new();
|
||||
|
||||
let mut depth = 0;
|
||||
while !rtokens.is_empty() {
|
||||
let t = rtokens.pop().unwrap();
|
||||
let typ = t.typ.clone();
|
||||
if typ == OpType::Keyword(KeywordType::End) && depth == 0 {
|
||||
break;
|
||||
} else if typ == OpType::Keyword(KeywordType::End) && depth != 0 {
|
||||
depth -= 1;
|
||||
code.push(t);
|
||||
} else if typ == OpType::Keyword(KeywordType::If) || typ == OpType::Keyword(KeywordType::Do) {
|
||||
code.push(t);
|
||||
depth += 1;
|
||||
} else {
|
||||
code.push(t);
|
||||
}
|
||||
}
|
||||
let res = precompile(&code)?;
|
||||
|
||||
|
||||
if res.len() != 1 {
|
||||
lerror!(&op.loc, "Expected 1 number, got {:?}", res);
|
||||
bail!("");
|
||||
}
|
||||
op.value = res[0];
|
||||
op.addr = Some(self.program.memories.len());
|
||||
program.push(op.clone());
|
||||
|
||||
self.program.memories.insert(name.text, Memory { loc: op.loc.clone(), id: self.program.memories.len() });
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn handle_function(&mut self, rtokens: &mut Vec<Operator>, op: &mut Operator, program: &mut Vec<Operator>) -> Result<()> {
|
||||
if rtokens.is_empty() {
|
||||
lerror!(&op.loc, "Function name not found, expected {} but found nothing", TokenType::Word.human());
|
||||
bail!("");
|
||||
}
|
||||
|
||||
let mut name = rtokens.pop().unwrap();
|
||||
|
||||
if let '0'..='9' = name.text.chars().next().unwrap() {
|
||||
lerror!(&name.loc, "Function name starts with a number which is not allowed");
|
||||
bail!("");
|
||||
}
|
||||
|
||||
// let mut should_warn = false;
|
||||
for c in name.text.clone().chars() {
|
||||
match c {
|
||||
'a'..='z' |
|
||||
'A'..='Z' |
|
||||
'0'..='9' |
|
||||
'-' | '_' => (),
|
||||
'(' | ')' => {
|
||||
name.text = name.text.clone().replace('(', "__OP_PAREN__").replace(')', "__CL_PAREN__");
|
||||
}
|
||||
_ => {
|
||||
lerror!(&name.loc, "Function name contains '{c}', which is unsupported");
|
||||
bail!("");
|
||||
}
|
||||
}
|
||||
}
|
||||
// if should_warn {
|
||||
//TODO: add -W option in cli args to enable more warnings
|
||||
//lwarn!(&function_name.loc, "Function name contains '(' or ')', this character is not supported but will be replaced with '__OP_PAREN__' or '__CL_PAREN__' respectively ");
|
||||
// }
|
||||
|
||||
self.is_word_available(&name, KeywordType::Function)?;
|
||||
|
||||
|
||||
if self.f_inline {
|
||||
self.f_inline = false;
|
||||
let mut prog: Vec<Operator> = Vec::new();
|
||||
let mut depth = -1;
|
||||
while !rtokens.is_empty() {
|
||||
let op = rtokens.pop().unwrap();
|
||||
|
||||
match op.typ.clone() {
|
||||
OpType::Instruction(i) => {
|
||||
match i {
|
||||
InstructionType::TypeAny |
|
||||
InstructionType::TypeBool |
|
||||
InstructionType::TypeInt |
|
||||
InstructionType::TypePtr |
|
||||
InstructionType::With |
|
||||
InstructionType::Returns |
|
||||
InstructionType::TypeVoid => {
|
||||
if depth >= 0 {
|
||||
prog.push(op);
|
||||
}
|
||||
},
|
||||
_ => prog.push(op)
|
||||
}
|
||||
}
|
||||
OpType::Keyword(k) => {
|
||||
match k {
|
||||
KeywordType::Inline |
|
||||
KeywordType::Include => {
|
||||
todo!("make error")
|
||||
},
|
||||
KeywordType::FunctionThen => {
|
||||
if depth >= 0 {
|
||||
prog.push(op);
|
||||
}
|
||||
depth += 1;
|
||||
},
|
||||
KeywordType::FunctionDone => {
|
||||
if depth == 0 {
|
||||
break;
|
||||
}
|
||||
|
||||
depth -= 1;
|
||||
},
|
||||
_ => prog.push(op)
|
||||
}
|
||||
}
|
||||
_ => prog.push(op)
|
||||
}
|
||||
}
|
||||
let mut pre = self.clone();
|
||||
pre.program.ops = prog;
|
||||
if name.text.chars().next().unwrap() == '.' {
|
||||
pre.in_function = Some(name.text[1..].to_string());
|
||||
}
|
||||
pre.preprocess()?;
|
||||
prog = pre.get_ops();
|
||||
|
||||
self.program.functions.insert(name.text.clone(), Function{
|
||||
loc: name.loc.clone(),
|
||||
name: name.text.clone(),
|
||||
inline: true,
|
||||
tokens: Some(prog)
|
||||
});
|
||||
|
||||
} else if self.f_export {
|
||||
self.f_export = false;
|
||||
self.program.functions.insert(name.text.clone(), Function{
|
||||
loc: name.loc.clone(),
|
||||
name: name.text.clone(),
|
||||
inline: false,
|
||||
tokens: None
|
||||
});
|
||||
let mut a: Vec<Operator> = Vec::new();
|
||||
let mut fn_def = op.clone();
|
||||
a.push(rtokens.pop().unwrap());
|
||||
let mut ret = false;
|
||||
while !rtokens.is_empty() {
|
||||
let op = rtokens.pop().unwrap();
|
||||
// println!("{:?}",op);
|
||||
a.push(op.clone());
|
||||
if op.typ == OpType::Instruction(InstructionType::Returns) {
|
||||
ret = true;
|
||||
}
|
||||
|
||||
if op.typ == OpType::Keyword(KeywordType::FunctionThen) {
|
||||
break;
|
||||
}
|
||||
|
||||
if op.typ == OpType::Instruction(InstructionType::TypeBool) ||
|
||||
op.typ == OpType::Instruction(InstructionType::TypeInt) ||
|
||||
op.typ == OpType::Instruction(InstructionType::TypePtr) {
|
||||
|
||||
if ret {
|
||||
fn_def.types.1 += 1;
|
||||
} else {
|
||||
fn_def.types.0 += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn_def.typ = OpType::Keyword(KeywordType::FunctionDefExported);
|
||||
fn_def.text = name.text;
|
||||
// fn_def.set_types(args, rets);
|
||||
// println!("{:?}", fn_def.types);
|
||||
program.push(fn_def);
|
||||
program.append(&mut a);
|
||||
|
||||
|
||||
} else {
|
||||
|
||||
self.program.functions.insert(name.text.clone(), Function{
|
||||
loc: name.loc.clone(),
|
||||
name: name.text.clone(),
|
||||
inline: false,
|
||||
tokens: None
|
||||
});
|
||||
|
||||
let mut fn_def = op.clone();
|
||||
fn_def.typ = OpType::Keyword(KeywordType::FunctionDef);
|
||||
fn_def.text = name.text;
|
||||
// println!("{:?}", token);
|
||||
program.push(fn_def);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn handle_constant(&mut self, rtokens: &mut Vec<Operator>, op: &mut Operator, program: &mut Vec<Operator>) -> Result<()> {
|
||||
let Some(mut name) = rtokens.pop() else {
|
||||
lerror!(&op.loc, "Constant name not found, expected {} but found nothing", TokenType::Word.human());
|
||||
bail!("");
|
||||
};
|
||||
|
||||
|
||||
if let '0'..='9' | '.' = name.text.chars().next().unwrap() {
|
||||
lerror!(&name.loc, "Constant name starts with a number or dot which is not allowed");
|
||||
bail!("");
|
||||
}
|
||||
|
||||
for c in name.text.clone().chars() {
|
||||
match c {
|
||||
'a'..='z' |
|
||||
'A'..='Z' |
|
||||
'0'..='9' |
|
||||
'-' | '_' => (),
|
||||
'(' | ')' => {
|
||||
// should_warn = true;
|
||||
name.text = name.text.clone().replace('(', "__OP_PAREN__").replace(')', "__CL_PAREN__");
|
||||
}
|
||||
_ => {
|
||||
lerror!(&name.loc, "Constant name contains '{c}', which is unsupported");
|
||||
bail!("");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// if should_warn {
|
||||
//TODO: add -W option in cli args to enable more warnings
|
||||
//lwarn!(&name.loc, "Constant name contains '(' or ')', this character is not supported but will be replaced with '__OP_PAREN__' or '__CL_PAREN__' respectively ");
|
||||
// }
|
||||
|
||||
self.is_word_available(&name, KeywordType::Constant)?;
|
||||
|
||||
|
||||
self.program.constants.insert(name.text.clone(), Constant{
|
||||
loc: name.loc.clone(),
|
||||
name: name.text.clone(),
|
||||
});
|
||||
|
||||
// println!("{:?}", self.program.constants);
|
||||
|
||||
let mut const_def = op.clone();
|
||||
const_def.typ = OpType::Keyword(KeywordType::ConstantDef);
|
||||
const_def.text = name.text;
|
||||
|
||||
let item = rtokens.pop().unwrap();
|
||||
if item.tok_typ == TokenType::Int {
|
||||
const_def.value = item.value;
|
||||
} else {
|
||||
lerror!(&op.loc, "For now only {:?} is allowed in constants", TokenType::Int);
|
||||
bail!("");
|
||||
}
|
||||
|
||||
let posibly_end = rtokens.pop();
|
||||
// println!("end: {posibly_end:?}");
|
||||
if posibly_end.is_none() || posibly_end.unwrap().typ != OpType::Keyword(KeywordType::End) {
|
||||
lerror!(&op.loc, "Constant was not closed with an 'end' instruction, expected 'end' but found nothing");
|
||||
bail!("");
|
||||
}
|
||||
// token.value =
|
||||
|
||||
program.push(const_def);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn handle_struct(&mut self, rtokens: &mut Vec<Operator>, op: &mut Operator, program: &mut Vec<Operator>) -> Result<()> {
|
||||
let Some(name) = rtokens.pop() else {
|
||||
lerror!(&op.loc, "Struct name not found, expected {} but found nothing", TokenType::Word.human());
|
||||
bail!("");
|
||||
};
|
||||
|
||||
if let '0'..='9' | '.' = name.text.chars().next().unwrap() {
|
||||
lerror!(&name.loc, "Struct name starts with a number or dot which is not allowed");
|
||||
bail!("");
|
||||
}
|
||||
|
||||
self.is_word_available(&name, KeywordType::Struct)?;
|
||||
|
||||
if let Some(kw_do) = rtokens.pop() {
|
||||
if kw_do.typ != OpType::Keyword(KeywordType::Do) {
|
||||
lerror!(&name.loc, "Expected keyword 'do' but found {:?}", kw_do.typ);
|
||||
bail!("");
|
||||
}
|
||||
} else {
|
||||
lerror!(&name.loc, "Expected keyword 'do' but found nothing");
|
||||
bail!("");
|
||||
}
|
||||
|
||||
let mut structure = StructDef{
|
||||
loc: name.loc,
|
||||
name: name.text,
|
||||
fields: vec![],
|
||||
};
|
||||
|
||||
loop {
|
||||
let fl_name = rtokens.pop().unwrap();
|
||||
|
||||
if fl_name.typ == OpType::Keyword(KeywordType::End) {
|
||||
break;
|
||||
}
|
||||
|
||||
if let '0'..='9' = fl_name.text.chars().next().unwrap() {
|
||||
lerror!(&fl_name.loc, "Struct field name starts with a number which is not allowed");
|
||||
bail!("");
|
||||
}
|
||||
|
||||
// let mut should_warn = false;
|
||||
for c in fl_name.text.clone().chars() {
|
||||
match c {
|
||||
'a'..='z' |
|
||||
'A'..='Z' |
|
||||
'0'..='9' |
|
||||
'_' => (),
|
||||
_ => {
|
||||
lerror!(&fl_name.loc, "Struct field name contains '{c}', which is unsupported");
|
||||
bail!("");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(arrow) = rtokens.pop() {
|
||||
if arrow.typ != OpType::Internal(InternalType::Arrow) {
|
||||
lerror!(&arrow.loc, "Expected '->' but found {:?}", arrow.typ);
|
||||
bail!("");
|
||||
}
|
||||
} else {
|
||||
lerror!(&fl_name.loc, "Expected '->' but found nothing");
|
||||
bail!("");
|
||||
}
|
||||
|
||||
|
||||
let Some(typ) = rtokens.pop() else {
|
||||
lerror!(&fl_name.loc, "Expected a type but found nothing");
|
||||
bail!("");
|
||||
};
|
||||
|
||||
let Ok(typ) = Types::from_string(&typ.text) else {
|
||||
lerror!(&typ.loc, "Expected a type but found {:?}", typ.text);
|
||||
bail!("");
|
||||
};
|
||||
|
||||
structure.fields.push((fl_name.text, typ));
|
||||
|
||||
}
|
||||
|
||||
self.program.struct_defs.insert(structure.name.clone(), structure.clone());
|
||||
|
||||
if let Some(def_name) = rtokens.pop() {
|
||||
if def_name.typ == OpType::Instruction(InstructionType::None){
|
||||
let mut def = def_name.clone();
|
||||
|
||||
def.typ = OpType::Internal(InternalType::StructAlloc {
|
||||
name: structure.name.clone()
|
||||
});
|
||||
self.program.struct_allocs.insert(def_name.text, structure.name);
|
||||
program.push(def);
|
||||
|
||||
} else {
|
||||
rtokens.push(def_name);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn expand(&mut self) -> Result<()> {
|
||||
let mut program: Vec<Operator> = Vec::new();
|
||||
// println!("{:?}", self.program.functions);
|
||||
let mut rtokens = self.program.ops.clone();
|
||||
rtokens.reverse();
|
||||
|
||||
'main_loop: while !rtokens.is_empty() {
|
||||
let op = rtokens.pop().unwrap();
|
||||
let op_type = op.typ.clone();
|
||||
if op.tok_typ == TokenType::Word {
|
||||
match op_type {
|
||||
OpType::Instruction(InstructionType::None) => {
|
||||
let m = self.program.functions.get(&op.text.clone().replace('(', "__OP_PAREN__").replace(')', "__CL_PAREN__"));
|
||||
let mem = self.program.memories.get(&op.text);
|
||||
let cons = self.program.constants.get(&op.text.clone().replace('(', "__OP_PAREN__").replace(')', "__CL_PAREN__"));
|
||||
|
||||
|
||||
|
||||
if let Some(m) = m {
|
||||
if m.inline {
|
||||
program.append(&mut m.tokens.clone().unwrap());
|
||||
} else {
|
||||
let mut t = op.clone();
|
||||
t.typ = OpType::Instruction(InstructionType::FnCall);
|
||||
t.text = m.name.clone();
|
||||
program.push(t.clone());
|
||||
}
|
||||
|
||||
// println!("##### {:?}", t);
|
||||
} else if let Some(mem) = mem {
|
||||
let mut t = op.clone();
|
||||
t.addr = Some(mem.id);
|
||||
t.typ = OpType::Instruction(InstructionType::MemUse);
|
||||
program.push(t);
|
||||
} else if let Some(cons) = cons {
|
||||
let mut t = op.clone();
|
||||
t.text = cons.name.clone();
|
||||
t.typ = OpType::Instruction(InstructionType::ConstUse);
|
||||
program.push(t);
|
||||
} else {
|
||||
let mut t = op.clone();
|
||||
let parts = op.text.split('.').map(|f| f.to_string()).collect::<Vec<String>>();
|
||||
let alc = self.program.struct_allocs.get(&parts[0]);
|
||||
if let Some(alc) = alc {
|
||||
if let Some(def) = self.program.struct_defs.get(alc) {
|
||||
// if def.fields.iter().for_each(|f| f.0 == parts[1])
|
||||
println!("{:?}", def.fields);
|
||||
if def.fields.iter().find(|f| f.0 == parts[1]).is_some() || parts.len() < 2{
|
||||
t.typ = OpType::Instruction(InstructionType::StructUse);
|
||||
program.push(t);
|
||||
continue 'main_loop;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
lerror!(&op.loc, "Preprocess: Unknown word '{}'", op.text.clone());
|
||||
bail!("");
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
program.push(op.clone());
|
||||
}
|
||||
}
|
||||
} else {
|
||||
program.push(op.clone());
|
||||
}
|
||||
|
||||
// if op.typ == OpType::Keyword(KeywordType::Do) {
|
||||
// println!("expand: {:?}", op);
|
||||
// program.push(op.clone());
|
||||
// }
|
||||
|
||||
}
|
||||
// println!("expand: has do tokens: {:?}", program.iter().map(|t| if t.typ == OpType::Keyword(KeywordType::Do) {Some(t)} else {None} ).collect::<Vec<Option<&Operator>>>());
|
||||
|
||||
self.program.ops = program;
|
||||
// println!("{:#?}", self.program);
|
||||
// println!("{:?}", self.program.last().unwrap());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
|
||||
pub fn get_ops(&mut self) -> Vec<Operator> {
|
||||
self.program.ops.clone()
|
||||
}
|
||||
pub fn is_word_available(&self, word: &Operator, typ: KeywordType) -> Result<bool> {
|
||||
|
||||
match typ {
|
||||
KeywordType::Memory |
|
||||
KeywordType::Constant |
|
||||
KeywordType::Struct |
|
||||
KeywordType::Function => (),
|
||||
_ => panic!()
|
||||
}
|
||||
|
||||
if word.tok_typ != TokenType::Word {
|
||||
lerror!(&word.loc, "Bad {typ:?}, expected {} but found {}", TokenType::Word.human(), word.typ.human());
|
||||
if crate::DEV_MODE {println!("{word:?}")}
|
||||
bail!("");
|
||||
}
|
||||
|
||||
let w = lookup_word(&word.text, &word.loc);
|
||||
if w != OpType::Instruction(InstructionType::None) {
|
||||
lerror!(&word.loc, "Bad {typ:?}, {typ:?} definition cannot be builtin word, got {:?}", word.text);
|
||||
if crate::DEV_MODE {println!("{word:?}")}
|
||||
bail!("");
|
||||
}
|
||||
|
||||
let m = self.program.memories.get(&word.text);
|
||||
if let Some(m) = m {
|
||||
if typ == KeywordType::Memory {
|
||||
lerror!(&word.loc, "Memories cannot be redefined, got {}", word.text);
|
||||
linfo!(&m.loc, "first definition here");
|
||||
if crate::DEV_MODE {println!("{word:?}")}
|
||||
bail!("");
|
||||
}
|
||||
lerror!(&word.loc, "{typ:?} cannot replace memory, got {}", word.text);
|
||||
linfo!(&m.loc, "first definition here");
|
||||
if crate::DEV_MODE {println!("{word:?}")}
|
||||
bail!("");
|
||||
}
|
||||
let f = self.program.functions.get(&word.text);
|
||||
if let Some(f) = f {
|
||||
if typ == KeywordType::Function {
|
||||
lerror!(&word.loc, "Functions cannot be redefined, got {}", word.text);
|
||||
linfo!(&f.loc, "first definition here");
|
||||
if crate::DEV_MODE {println!("{word:?}")}
|
||||
bail!("");
|
||||
}
|
||||
lerror!(&word.loc, "{typ:?} cannot replace function, got {}", word.text);
|
||||
linfo!(&f.loc, "first definition here");
|
||||
if crate::DEV_MODE {println!("{word:?}")}
|
||||
bail!("");
|
||||
}
|
||||
let c = self.program.constants.get(&word.text);
|
||||
if let Some(c) = c {
|
||||
if typ == KeywordType::Constant {
|
||||
lerror!(&word.loc, "Constants cannot be redefined, got {}", word.text);
|
||||
linfo!(&c.loc, "first definition here");
|
||||
if crate::DEV_MODE {println!("{word:?}")}
|
||||
bail!("");
|
||||
}
|
||||
lerror!(&word.loc, "{typ:?} cannot replace constant, got {}", word.text);
|
||||
linfo!(&c.loc, "first definition here");
|
||||
if crate::DEV_MODE {println!("{word:?}")}
|
||||
bail!("");
|
||||
}
|
||||
|
||||
let s = self.program.struct_defs.get(&word.text);
|
||||
if let Some(s) = s {
|
||||
if typ == KeywordType::Constant {
|
||||
lerror!(&word.loc, "Structs cannot be redefined, got {}", word.text);
|
||||
linfo!(&s.loc, "first definition here");
|
||||
if crate::DEV_MODE {println!("{word:?}")}
|
||||
bail!("");
|
||||
}
|
||||
lerror!(&word.loc, "{typ:?} cannot replace struct, got {}", word.text);
|
||||
linfo!(&s.loc, "first definition here");
|
||||
if crate::DEV_MODE {println!("{word:?}")}
|
||||
bail!("");
|
||||
}
|
||||
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
pub fn set_functions(&mut self, f: Functions) {
|
||||
self.program.functions = f;
|
||||
}
|
||||
pub fn set_constants(&mut self, f: Constants) {
|
||||
self.program.constants = f;
|
||||
}
|
||||
pub fn set_memories(&mut self, f: Memories) {
|
||||
self.program.memories = f;
|
||||
}
|
||||
|
||||
pub fn get_functions(&mut self) -> Functions {
|
||||
self.program.functions.clone()
|
||||
}
|
||||
pub fn get_constants(&mut self) -> Constants {
|
||||
self.program.constants.clone()
|
||||
}
|
||||
pub fn get_memories(&mut self) -> Memories{
|
||||
self.program.memories.clone()
|
||||
}
|
||||
|
||||
pub fn get_program(&mut self) -> Program {
|
||||
self.program.clone()
|
||||
}
|
||||
}
|
||||
125
src/token.c
Normal file
125
src/token.c
Normal file
|
|
@ -0,0 +1,125 @@
|
|||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "token.h"
|
||||
|
||||
char* escape_str(char* str);
|
||||
|
||||
char* token_to_string(token_t* t) {
|
||||
char* buf = {0};
|
||||
int len = 0;
|
||||
switch(t->type) {
|
||||
case TT_IDENT:
|
||||
// printf("IDENT\n");
|
||||
len = strlen(t->text)+10;
|
||||
buf = malloc(len);
|
||||
snprintf(buf, len, "IDENT(\"%s\")", escape_str(t->text));
|
||||
return buf;
|
||||
case TT_STR:
|
||||
// printf("STR\n");
|
||||
len = strlen(t->text)+10;
|
||||
buf = malloc(len);
|
||||
snprintf(buf, len, "STR(\"%s\")", t->text);
|
||||
buf = escape_str(t->text);
|
||||
return buf;
|
||||
case TT_CHR:
|
||||
// printf("CHR\n");
|
||||
buf = malloc(10);
|
||||
snprintf(buf, 10, "CHAR('%c')", *t->text);
|
||||
return buf;
|
||||
case TT_CURLY_R:
|
||||
return "}";
|
||||
case TT_CURLY_L:
|
||||
return "{";
|
||||
case TT_BRACK_R:
|
||||
return "]";
|
||||
case TT_BRACK_L:
|
||||
return "[";
|
||||
case TT_PAREN_R:
|
||||
return ")";
|
||||
case TT_PAREN_L:
|
||||
return "(";
|
||||
case TT_COLON:
|
||||
return ":";
|
||||
case TT_SEMI:
|
||||
return ";";
|
||||
case TT_COMMA:
|
||||
return ",";
|
||||
case TT_DOT:
|
||||
return ".";
|
||||
case TT_AMP:
|
||||
return "&";
|
||||
case TT_STAR:
|
||||
return "*";
|
||||
case TT_PLUS:
|
||||
return "+";
|
||||
case TT_DASH:
|
||||
return "-";
|
||||
case TT_FSLASH:
|
||||
return "/";
|
||||
case TT_BAR:
|
||||
return "|";
|
||||
case TT_EQ:
|
||||
return "=";
|
||||
case TT_LT:
|
||||
return "<";
|
||||
case TT_GT:
|
||||
return ">";
|
||||
case TT_KW_FN:
|
||||
return "KEYWORD(fn)";
|
||||
case TT_KW_RETURN:
|
||||
return "KEYWORD(return)";
|
||||
case TT_KW_IF:
|
||||
return "KEYWORD(if)";
|
||||
case TT_KW_ELSE:
|
||||
return "KEYWORD(else)";
|
||||
case TT_KW_FOR:
|
||||
return "KEYWORD(for)";
|
||||
case TT_KW_WHILE:
|
||||
return "KEYWORD(while)";
|
||||
case TT_KW_STRUCT:
|
||||
return "KEYWORD(struct)";
|
||||
case TT_KW_ENUM:
|
||||
return "KEYWORD(enum)";
|
||||
case TT_KW_BREAK:
|
||||
return "KEYWORD(break)";
|
||||
case TT_KW_CONTINUE:
|
||||
return "KEYWORD(continue)";
|
||||
}
|
||||
}
|
||||
|
||||
char* escape_str(char* str) {
|
||||
// First, determine the length of the new string
|
||||
size_t new_length = 0;
|
||||
for (const char* p = str; *p != '\0'; ++p) {
|
||||
if (*p == '\n' || *p == '\r') {
|
||||
new_length += 2; // Each '\n' or '\r' becomes two characters: '\\' and 'n' or 'r'
|
||||
} else {
|
||||
new_length += 1;
|
||||
}
|
||||
}
|
||||
|
||||
// Allocate memory for the new string
|
||||
char* new_str = (char*)malloc(new_length + 1); // +1 for the null terminator
|
||||
if (new_str == NULL) {
|
||||
fprintf(stderr, "Memory allocation failed\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
// Replace '\n' with "\\n" and '\r' with "\\r"
|
||||
char* q = new_str;
|
||||
for (const char* p = str; *p != '\0'; ++p) {
|
||||
if (*p == '\n') {
|
||||
*q++ = '\\';
|
||||
*q++ = 'n';
|
||||
} else if (*p == '\r') {
|
||||
*q++ = '\\';
|
||||
*q++ = 'r';
|
||||
} else {
|
||||
*q++ = *p;
|
||||
}
|
||||
}
|
||||
*q = '\0'; // Null-terminate the new string
|
||||
|
||||
return new_str;
|
||||
}
|
||||
255
src/tokeniser.c
Normal file
255
src/tokeniser.c
Normal file
|
|
@ -0,0 +1,255 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "tokeniser.h"
|
||||
#include "dyn_arr.h"
|
||||
#include "logger.h"
|
||||
#include "token.h"
|
||||
|
||||
DEFINE_DA_IMPL(token, token_t)
|
||||
|
||||
#define TZ_TOK_PUSH(_loc, _type, _text) mcl_da_token_push(&tz->tokens, (token_t){.loc = (_loc), .type = (_type), .text=(_text)})
|
||||
|
||||
static struct {
|
||||
char* k;
|
||||
token_type_t v;
|
||||
} KEYWORDS[] = {
|
||||
{"fn", TT_KW_FN },
|
||||
{"return", TT_KW_RETURN},
|
||||
{"for", TT_KW_FOR},
|
||||
{"if", TT_KW_IF},
|
||||
{"else", TT_KW_ELSE},
|
||||
{"enum", TT_KW_ENUM},
|
||||
{"struct", TT_KW_STRUCT},
|
||||
{"while", TT_KW_WHILE},
|
||||
{"break", TT_KW_BREAK},
|
||||
{"continue", TT_KW_CONTINUE}
|
||||
};
|
||||
|
||||
tokeniser_t* tokenise(char* file) {
|
||||
tokeniser_t* tz = malloc(sizeof(tokeniser_t));
|
||||
tz->loc.file = file;
|
||||
tz->loc.line = 1;
|
||||
tz->loc.col = 1;
|
||||
FILE* f = fopen(file, "r");
|
||||
if (!f) {
|
||||
printf("Could not open file %s\n", file);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
char c;
|
||||
while ((c = fgetc(f)) != EOF) {
|
||||
switch(c) {
|
||||
case '\t':
|
||||
case '\r':
|
||||
case ' ':{
|
||||
tz->loc.col += 1;
|
||||
} break;
|
||||
|
||||
case '\n': {
|
||||
tz->loc.col = 1;
|
||||
tz->loc.line++;
|
||||
} break;
|
||||
|
||||
case '"': {
|
||||
loc_t loc = tz->loc;
|
||||
int size = 256;
|
||||
int i = 0;
|
||||
char* buf = malloc(size * sizeof(char));
|
||||
while ((c = fgetc(f)) != EOF) {
|
||||
tz->loc.col++;
|
||||
if (size <= strlen(buf) - 1) {
|
||||
buf = realloc(buf, size *= 2);
|
||||
}
|
||||
if (c == '\n') {
|
||||
mcl_log_loc(ERROR, &tz->loc, "No newlines in strings");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (c == '"') break;
|
||||
if (c == '\\') {
|
||||
switch (c = fgetc(f)) {
|
||||
case 'n': c = '\n'; break;
|
||||
case '\\': break;
|
||||
}
|
||||
}
|
||||
|
||||
buf[i++] = c;
|
||||
}
|
||||
TZ_TOK_PUSH(loc, TT_STR, buf);
|
||||
} break;
|
||||
|
||||
case '\'': {
|
||||
loc_t loc = tz->loc;
|
||||
bool escape = false;
|
||||
char c = fgetc(f);
|
||||
tz->loc.col += 1;
|
||||
char* buf = malloc(1 * sizeof(char));
|
||||
if (c == '\\') {
|
||||
c = fgetc(f);
|
||||
tz->loc.col += 1;
|
||||
switch (c) {
|
||||
case 'n': *buf = '\n'; break;
|
||||
default:
|
||||
mcl_log_loc(ERROR, &tz->loc, "Unknown escape: \\%c\n", c);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
} else {
|
||||
tz->loc.col += 1;
|
||||
*buf = c;
|
||||
}
|
||||
|
||||
c = fgetc(f);
|
||||
if (c != '\'') {
|
||||
mcl_log_loc(ERROR, &tz->loc, "Expected \"'\" found \"%c\"", c);
|
||||
return NULL;
|
||||
}
|
||||
TZ_TOK_PUSH(loc, TT_CHR, buf);
|
||||
|
||||
}
|
||||
|
||||
|
||||
case 'a': case 'A':
|
||||
case 'b': case 'B':
|
||||
case 'c': case 'C':
|
||||
case 'd': case 'D':
|
||||
case 'e': case 'E':
|
||||
case 'f': case 'F':
|
||||
case 'g': case 'G':
|
||||
case 'h': case 'H':
|
||||
case 'i': case 'I':
|
||||
case 'j': case 'J':
|
||||
case 'k': case 'K':
|
||||
case 'l': case 'L':
|
||||
case 'm': case 'M':
|
||||
case 'n': case 'N':
|
||||
case 'o': case 'O':
|
||||
case 'p': case 'P':
|
||||
case 'q': case 'Q':
|
||||
case 'r': case 'R':
|
||||
case 's': case 'S':
|
||||
case 't': case 'T':
|
||||
case 'u': case 'U':
|
||||
case 'v': case 'V':
|
||||
case 'w': case 'W':
|
||||
case 'y': case 'Y':
|
||||
case 'z': case 'Z':
|
||||
case '_': {
|
||||
loc_t loc = tz->loc;
|
||||
int size = 256;
|
||||
int i = 1;
|
||||
char* buf = malloc(size * sizeof(char));
|
||||
buf[0] = c;
|
||||
while ((c = fgetc(f)) != EOF) {
|
||||
if (!( (c >= 'A' && c <= 'Z') ||
|
||||
(c >= 'a' && c <= 'z') ||
|
||||
(c >= '0' && c <= '9') ||
|
||||
(c == '_')
|
||||
)) {
|
||||
tz->loc.col++;
|
||||
ungetc(c, f);
|
||||
break;
|
||||
};
|
||||
if (size <= strlen(buf) - 1) {
|
||||
buf = realloc(buf, size *= 2);
|
||||
}
|
||||
|
||||
tz->loc.col++;
|
||||
buf[i++] = c;
|
||||
}
|
||||
bool found = false;
|
||||
for (int i = 0; i < sizeof(KEYWORDS)/sizeof(KEYWORDS[0]); i++) {
|
||||
if (strcmp(buf, KEYWORDS[i].k) == 0) {
|
||||
TZ_TOK_PUSH(loc, KEYWORDS[i].v, NULL);
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found) TZ_TOK_PUSH(loc, TT_IDENT, buf);
|
||||
|
||||
} break;
|
||||
|
||||
case '}': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_CURLY_R, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case '{': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_CURLY_L, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case ']': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_BRACK_R, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case '[': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_BRACK_L, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case ')': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_PAREN_R, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case '(': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_PAREN_L, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case ':': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_COLON, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case ';': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_SEMI, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case ',': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_CURLY_R, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case '.': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_CURLY_R, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case '&': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_CURLY_R, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case '*': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_CURLY_R, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case '+': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_CURLY_R, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case '-': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_CURLY_R, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case '/': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_CURLY_R, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case '|': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_CURLY_R, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case '=': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_CURLY_R, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case '<': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_CURLY_R, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
case '>': {
|
||||
TZ_TOK_PUSH(tz->loc, TT_CURLY_R, NULL);
|
||||
tz->loc.col++;
|
||||
} break;
|
||||
}
|
||||
}
|
||||
return tz;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,408 +0,0 @@
|
|||
use std::collections::HashMap;
|
||||
|
||||
use crate::{definitions::{Operator, Types, OpType, KeywordType, InstructionType, Loc}, Args, lerror, warn};
|
||||
use anyhow::{Result, bail};
|
||||
|
||||
#[allow(dead_code)]
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Function {
|
||||
loc: Loc,
|
||||
args: Vec<Types>,
|
||||
returns: Vec<Types>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Constant {
|
||||
#[allow(dead_code)]
|
||||
loc: Loc,
|
||||
types: Vec<Types>,
|
||||
}
|
||||
|
||||
impl Function {
|
||||
#[allow(dead_code)]
|
||||
pub fn default() -> Self {
|
||||
Self {
|
||||
args: Vec::new(),
|
||||
returns: Vec::new(),
|
||||
loc: (String::new(), 0, 0)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type Functions = HashMap<String, Function>;
|
||||
type Constants = HashMap<String, Constant>;
|
||||
|
||||
pub fn typecheck(ops: Vec<Operator>, args: &Args, init_types: Option<Vec<Types>>, funcs: HashMap<String, Function>, consts: HashMap<String, Constant>) -> Result<(Vec<Types>, Functions, Constants)>{
|
||||
if args.unsaf {
|
||||
if !args.quiet {
|
||||
warn!("Unsafe mode enabled, disabling typechecker, goodluck");
|
||||
}
|
||||
return Ok((Vec::new(), HashMap::new(), HashMap::new()));
|
||||
}
|
||||
|
||||
let mut functions: HashMap<String, Function> = funcs;
|
||||
let mut constants: HashMap<String, Constant> = consts;
|
||||
// let mut in_function: (String, Function, Loc) = (String::new(), Function::default(), (String::new(), 0, 0));
|
||||
let mut stack: Vec<Types> = if let Some(i) = init_types {i} else {Vec::new()};
|
||||
let mut stack_snapshots: Vec<Vec<Types>> = Vec::new();
|
||||
let mut rtokens = ops;
|
||||
rtokens.reverse();
|
||||
// println!("{:#?}", ops);
|
||||
while !rtokens.is_empty() {
|
||||
let op = rtokens.pop().unwrap();
|
||||
// println!("{:?}", stack.clone());
|
||||
// println!("{:?}", op);
|
||||
// println!("{}", ops.len());
|
||||
match op.typ.clone() {
|
||||
OpType::Keyword(keyword) => {
|
||||
match keyword {
|
||||
KeywordType::If |
|
||||
KeywordType::Do => {
|
||||
stack_pop(&mut stack, &op, &[Types::Bool])?;
|
||||
},
|
||||
|
||||
KeywordType::FunctionDefExported |
|
||||
KeywordType::FunctionDef => {
|
||||
let name = op.text.clone();
|
||||
// println!("{:?}", name);
|
||||
if let Some(p) = rtokens.pop() {
|
||||
if p.typ != OpType::Instruction(InstructionType::With){
|
||||
lerror!(&op.loc, "Expected {:?}, got {:?}", OpType::Instruction(InstructionType::With), p.typ);
|
||||
bail!("");
|
||||
}
|
||||
|
||||
} else {
|
||||
lerror!(&op.loc, "Expected {:?}, got nothing", OpType::Instruction(InstructionType::With));
|
||||
bail!("");
|
||||
}
|
||||
|
||||
let mut p = rtokens.pop();
|
||||
let mut func = Function {
|
||||
args: Vec::new(),
|
||||
returns: Vec::new(),
|
||||
loc: op.loc
|
||||
};
|
||||
let mut return_args = false;
|
||||
while p.as_ref().is_some() {
|
||||
let op = p.as_ref().unwrap();
|
||||
if op.typ == OpType::Instruction(InstructionType::TypeBool) ||
|
||||
op.typ == OpType::Instruction(InstructionType::TypeInt) ||
|
||||
op.typ == OpType::Instruction(InstructionType::TypePtr) ||
|
||||
op.typ == OpType::Instruction(InstructionType::TypeAny) ||
|
||||
op.typ == OpType::Instruction(InstructionType::TypeVoid) {
|
||||
let t = if op.typ == OpType::Instruction(InstructionType::TypeInt) {
|
||||
Types::U64
|
||||
} else if op.typ == OpType::Instruction(InstructionType::TypeBool) {
|
||||
Types::Bool
|
||||
} else if op.typ == OpType::Instruction(InstructionType::TypePtr) {
|
||||
Types::Ptr
|
||||
} else if op.typ == OpType::Instruction(InstructionType::TypeVoid) {
|
||||
if return_args {
|
||||
func.returns = vec![Types::Void];
|
||||
} else {
|
||||
func.args = vec![Types::Void];
|
||||
return_args = true;
|
||||
continue;
|
||||
}
|
||||
Types::Void
|
||||
} else if op.typ == OpType::Instruction(InstructionType::TypeAny) {
|
||||
Types::Any
|
||||
} else {
|
||||
panic!()
|
||||
};
|
||||
|
||||
if return_args {
|
||||
func.returns.push(t);
|
||||
} else {
|
||||
func.args.push(t);
|
||||
}
|
||||
}
|
||||
|
||||
if op.typ == OpType::Instruction(InstructionType::Returns) {
|
||||
return_args = true;
|
||||
}
|
||||
|
||||
if op.typ == OpType::Keyword(KeywordType::FunctionThen) {
|
||||
break;
|
||||
}
|
||||
p = rtokens.pop();
|
||||
};
|
||||
|
||||
|
||||
let mut code: Vec<Operator> = Vec::new();
|
||||
|
||||
while !rtokens.is_empty() {
|
||||
let op = rtokens.pop().unwrap();
|
||||
|
||||
if op.typ == OpType::Keyword(KeywordType::FunctionDone) {
|
||||
break;
|
||||
}
|
||||
code.push(op);
|
||||
}
|
||||
let ts = if func.args.clone() == vec![Types::Void] {
|
||||
Vec::new()
|
||||
} else {
|
||||
func.args.clone()
|
||||
};
|
||||
|
||||
if ts.contains(&Types::Void) {
|
||||
continue;
|
||||
}
|
||||
functions.insert(name.clone(), func.clone());
|
||||
let (ret_typs, _, _) = typecheck(code, args, Some(ts.clone()), functions.clone(), constants.clone())?;
|
||||
if ret_typs != func.returns && !func.returns.contains(&Types::Void){
|
||||
lerror!(&func.loc, "Expected {:?}, but got {:?}", func.returns, ret_typs);
|
||||
bail!("");
|
||||
}
|
||||
|
||||
if !func.args.contains(&Types::Void) {
|
||||
stack.append(&mut func.args);
|
||||
}
|
||||
stack_snapshots.push(stack.clone());
|
||||
}
|
||||
|
||||
KeywordType::Else |
|
||||
KeywordType::End |
|
||||
KeywordType::While |
|
||||
KeywordType::Include |
|
||||
KeywordType::Constant |
|
||||
KeywordType::Memory => (),
|
||||
KeywordType::ConstantDef => {
|
||||
// println!("defined constant");
|
||||
constants.insert(op.text, Constant { loc: op.loc.clone(), types: vec![Types::U64] });
|
||||
|
||||
},
|
||||
KeywordType::FunctionThen |
|
||||
KeywordType::FunctionDone |
|
||||
KeywordType::Inline |
|
||||
KeywordType::Export |
|
||||
KeywordType::Function => {
|
||||
println!("{:?}", op);
|
||||
unreachable!()
|
||||
},
|
||||
KeywordType::Struct => todo!(),
|
||||
}
|
||||
},
|
||||
OpType::Instruction(instruction) => {
|
||||
match instruction {
|
||||
InstructionType::PushInt => {
|
||||
stack.push(Types::U64);
|
||||
},
|
||||
InstructionType::PushStr => {
|
||||
stack.push(Types::U64);
|
||||
stack.push(Types::Ptr);
|
||||
},
|
||||
InstructionType::PushCStr => {
|
||||
stack.push(Types::U64);
|
||||
stack.push(Types::Ptr);
|
||||
},
|
||||
InstructionType::Drop => {
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
},
|
||||
InstructionType::Print => {
|
||||
stack_pop(&mut stack, &op, &[Types::U64])?;
|
||||
},
|
||||
InstructionType::Dup => {
|
||||
let a = stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack.push(a);
|
||||
},
|
||||
InstructionType::Rot => {
|
||||
let a = stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
let b = stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
let c = stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack.push(b);
|
||||
stack.push(a);
|
||||
stack.push(c);
|
||||
},
|
||||
InstructionType::Over => {
|
||||
let a = stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
let b = stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack.push(b.clone());
|
||||
stack.push(a);
|
||||
stack.push(b);
|
||||
},
|
||||
InstructionType::Swap => {
|
||||
let a = stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
let b = stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack.push(a);
|
||||
stack.push(b);
|
||||
},
|
||||
InstructionType::Minus |
|
||||
InstructionType::Plus |
|
||||
InstructionType::Band |
|
||||
InstructionType::Bor |
|
||||
InstructionType::Shr |
|
||||
InstructionType::Shl |
|
||||
InstructionType::Mul => {
|
||||
stack_pop(&mut stack, &op, &[Types::U64])?;
|
||||
stack_pop(&mut stack, &op, &[Types::U64])?;
|
||||
stack.push(Types::U64);
|
||||
},
|
||||
InstructionType::Equals |
|
||||
InstructionType::Gt |
|
||||
InstructionType::Lt |
|
||||
InstructionType::Ge |
|
||||
InstructionType::Le |
|
||||
InstructionType::NotEquals => {
|
||||
stack_pop(&mut stack, &op, &[Types::U64])?;
|
||||
stack_pop(&mut stack, &op, &[Types::U64])?;
|
||||
stack.push(Types::Bool);
|
||||
},
|
||||
InstructionType::DivMod => {
|
||||
stack_pop(&mut stack, &op, &[Types::U64])?;
|
||||
stack_pop(&mut stack, &op, &[Types::U64])?;
|
||||
stack.push(Types::U64);
|
||||
stack.push(Types::U64);
|
||||
},
|
||||
InstructionType::Read8 |
|
||||
InstructionType::Read32 |
|
||||
InstructionType::Read64 => {
|
||||
stack_pop(&mut stack, &op, &[Types::Ptr])?;
|
||||
stack.push(Types::U64);
|
||||
},
|
||||
InstructionType::Write8 |
|
||||
InstructionType::Write32 |
|
||||
InstructionType::Write64 => {
|
||||
stack_pop(&mut stack, &op, &[Types::U64])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Ptr])?;
|
||||
},
|
||||
InstructionType::Syscall0 => {
|
||||
stack_pop(&mut stack, &op, &[Types::U64])?;
|
||||
stack.push(Types::U64);
|
||||
},
|
||||
InstructionType::Syscall1 => {
|
||||
stack_pop(&mut stack, &op, &[Types::U64])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack.push(Types::U64);
|
||||
},
|
||||
InstructionType::Syscall2 => {
|
||||
stack_pop(&mut stack, &op, &[Types::U64])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack.push(Types::U64);
|
||||
},
|
||||
InstructionType::Syscall3 => {
|
||||
stack_pop(&mut stack, &op, &[Types::U64])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack.push(Types::U64);
|
||||
},
|
||||
InstructionType::Syscall4 => {
|
||||
stack_pop(&mut stack, &op, &[Types::U64])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack.push(Types::U64);
|
||||
},
|
||||
InstructionType::Syscall5 => {
|
||||
stack_pop(&mut stack, &op, &[Types::U64])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack.push(Types::U64);
|
||||
},
|
||||
InstructionType::Syscall6 => {
|
||||
stack_pop(&mut stack, &op, &[Types::U64])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack.push(Types::U64);
|
||||
},
|
||||
InstructionType::CastBool => {
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack.push(Types::Bool);
|
||||
},
|
||||
InstructionType::CastPtr => {
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack.push(Types::Ptr);
|
||||
},
|
||||
InstructionType::CastInt => {
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack.push(Types::U64);
|
||||
},
|
||||
InstructionType::CastVoid => {
|
||||
stack_pop(&mut stack, &op, &[Types::Any])?;
|
||||
stack.push(Types::Any);
|
||||
},
|
||||
InstructionType::MemUse => {
|
||||
stack.push(Types::Ptr);
|
||||
},
|
||||
InstructionType::FnCall => {
|
||||
stack_snapshots.push(stack.clone());
|
||||
|
||||
let f = if let Some(f) = functions.get(&op.text) {f} else {
|
||||
lerror!(&op.loc, "Could not find function {}", op.text);
|
||||
bail!("");
|
||||
};
|
||||
|
||||
// in_function = (op.text.clone(), f.clone(), op.loc.clone());
|
||||
|
||||
let mut s = stack.clone();
|
||||
let mut a = f.args.clone();
|
||||
// s.reverse();
|
||||
a.reverse();
|
||||
|
||||
for t in a{
|
||||
if let Some(s2) = s.pop(){
|
||||
if t != s2 {
|
||||
lerror!(&op.loc, "Expected {:?}, but got {:?}", t, s2);
|
||||
bail!("");
|
||||
}
|
||||
} else {
|
||||
lerror!(&op.loc, "Expected {:?}, but got nothing", t);
|
||||
bail!("");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
InstructionType::Return |
|
||||
InstructionType::None |
|
||||
InstructionType::TypeBool |
|
||||
InstructionType::TypePtr |
|
||||
InstructionType::TypeInt |
|
||||
InstructionType::TypeVoid |
|
||||
InstructionType::TypeAny |
|
||||
InstructionType::Returns |
|
||||
InstructionType::With => (),
|
||||
InstructionType::ConstUse => {
|
||||
// println!("{constants:?}");
|
||||
let mut c = constants.get(&op.text).unwrap().clone();
|
||||
stack.append(&mut c.types);
|
||||
},
|
||||
InstructionType::StructUse => todo!(),
|
||||
}
|
||||
},
|
||||
OpType::Internal(t) => panic!("{t:?}"),
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
Ok((stack, functions, constants))
|
||||
}
|
||||
|
||||
|
||||
|
||||
fn stack_pop(v: &mut Vec<Types>, op: &Operator, t: &[Types]) -> Result<Types> {
|
||||
if v.is_empty() {
|
||||
lerror!(&op.loc, "Expected {:?}, but got nothing", t);
|
||||
bail!("");
|
||||
}
|
||||
let r = v.pop().unwrap();
|
||||
|
||||
if !t.contains(&r) && t[0] != Types::Any {
|
||||
lerror!(&op.loc, "Expected {:?}, but got {:?}", t, r);
|
||||
bail!("");
|
||||
}
|
||||
|
||||
Ok(r)
|
||||
}
|
||||
392
src/types.rs
392
src/types.rs
|
|
@ -1,392 +0,0 @@
|
|||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
use eyre::bail;
|
||||
|
||||
|
||||
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum InstructionType {
|
||||
|
||||
// stack
|
||||
PushInt,
|
||||
PushStr,
|
||||
PushCStr,
|
||||
Drop,
|
||||
Print,
|
||||
Dup,
|
||||
Rot, // a b c => b c a
|
||||
Over, // a b => a b a
|
||||
Swap, // a b => b a
|
||||
|
||||
// math
|
||||
Minus,
|
||||
Plus,
|
||||
Equals,
|
||||
Gt,
|
||||
Lt,
|
||||
Ge,
|
||||
Le,
|
||||
NotEquals,
|
||||
Band, // &
|
||||
Bor, // |
|
||||
Shr, // >>
|
||||
Shl, // <<
|
||||
DivMod, // /
|
||||
Mul,
|
||||
|
||||
|
||||
// mem
|
||||
Read8,
|
||||
Write8,
|
||||
Read32,
|
||||
Write32,
|
||||
Read64,
|
||||
Write64,
|
||||
|
||||
// syscalls
|
||||
Syscall0,
|
||||
Syscall1,
|
||||
Syscall2,
|
||||
Syscall3,
|
||||
Syscall4,
|
||||
Syscall5,
|
||||
Syscall6,
|
||||
|
||||
CastBool,
|
||||
CastPtr,
|
||||
CastInt,
|
||||
CastVoid,
|
||||
|
||||
// typing
|
||||
TypeBool,
|
||||
TypePtr,
|
||||
TypeInt,
|
||||
TypeVoid,
|
||||
// TypeStr,
|
||||
TypeAny,
|
||||
Returns,
|
||||
With,
|
||||
|
||||
FnCall,
|
||||
MemUse,
|
||||
ConstUse,
|
||||
|
||||
Return,
|
||||
None // Used for macros and any other non built in word definitions
|
||||
|
||||
}
|
||||
#[derive(Debug, Clone, Copy, PartialEq)]
|
||||
pub enum KeywordType {
|
||||
If,
|
||||
Else,
|
||||
End,
|
||||
While,
|
||||
Do,
|
||||
Include,
|
||||
Memory,
|
||||
Constant,
|
||||
ConstantDef,
|
||||
Function,
|
||||
FunctionDef,
|
||||
FunctionDefExported,
|
||||
FunctionThen,
|
||||
FunctionDone,
|
||||
Inline,
|
||||
Export,
|
||||
Struct,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq)]
|
||||
pub enum InternalType {
|
||||
Arrow
|
||||
}
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum OpType {
|
||||
Keyword(KeywordType),
|
||||
Instruction(InstructionType),
|
||||
Internal(InternalType)
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Operator{
|
||||
pub typ: OpType,
|
||||
pub tok_typ: TokenType,
|
||||
pub value: usize,
|
||||
pub text: String, //? only used for OpType::PushStr
|
||||
pub addr: Option<usize>, //? only used for OpType::PushStr
|
||||
pub jmp: usize,
|
||||
pub loc: Loc,
|
||||
pub types: (usize, usize)
|
||||
}
|
||||
|
||||
impl Operator {
|
||||
pub fn new(typ: OpType, tok_typ: TokenType, value: usize, text: String, file: String, row: usize, col: usize) -> Self {
|
||||
Self {
|
||||
typ,
|
||||
value,
|
||||
jmp: 0,
|
||||
addr: None,
|
||||
text,
|
||||
loc: (file, row, col),
|
||||
tok_typ,
|
||||
types: (0, 0)
|
||||
}
|
||||
}
|
||||
pub fn set_addr(&mut self, addr: usize) -> Self {
|
||||
self.addr = Some(addr);
|
||||
(*self).clone()
|
||||
}
|
||||
|
||||
// pub fn set_types(&mut self, args: usize, rets: usize) -> Self {
|
||||
// self.types = (args, rets);
|
||||
// (*self).clone()
|
||||
// }
|
||||
|
||||
}
|
||||
|
||||
impl OpType {
|
||||
pub fn human(&self) -> String {
|
||||
match (*self).clone() {
|
||||
OpType::Instruction(instruction) => {
|
||||
match instruction {
|
||||
|
||||
InstructionType::PushInt => "Number",
|
||||
InstructionType::PushStr => "String",
|
||||
InstructionType::PushCStr => "CString",
|
||||
InstructionType::Print => "_dbg_print",
|
||||
InstructionType::Dup => "dup",
|
||||
InstructionType::Drop => "drop",
|
||||
InstructionType::Rot => "rot",
|
||||
InstructionType::Over => "over",
|
||||
InstructionType::Swap => "swap",
|
||||
InstructionType::Plus => "+",
|
||||
InstructionType::Minus => "-",
|
||||
InstructionType::Equals => "=",
|
||||
InstructionType::Gt => ">",
|
||||
InstructionType::Lt => "<",
|
||||
InstructionType::NotEquals => "!=",
|
||||
InstructionType::Le => "<=",
|
||||
InstructionType::Ge => ">=",
|
||||
InstructionType::Band => "band",
|
||||
InstructionType::Bor => "bor",
|
||||
InstructionType::Shr => "shr",
|
||||
InstructionType::Shl => "shl",
|
||||
InstructionType::DivMod => "divmod",
|
||||
InstructionType::Mul => "*",
|
||||
InstructionType::Read8 => "read8",
|
||||
InstructionType::Write8 => "write8",
|
||||
InstructionType::Read32 => "read32",
|
||||
InstructionType::Write32 => "write32",
|
||||
InstructionType::Read64 => "read64",
|
||||
InstructionType::Write64 => "write64",
|
||||
InstructionType::Syscall0 => "syscall0",
|
||||
InstructionType::Syscall1 => "syscall1",
|
||||
InstructionType::Syscall2 => "syscall2",
|
||||
InstructionType::Syscall3 => "syscall3",
|
||||
InstructionType::Syscall4 => "syscall4",
|
||||
InstructionType::Syscall5 => "syscall5",
|
||||
InstructionType::Syscall6 => "syscall6",
|
||||
InstructionType::CastBool => "cast(bool",
|
||||
InstructionType::CastPtr => "cast(ptr)",
|
||||
InstructionType::CastInt => "cast(int)",
|
||||
InstructionType::CastVoid => "cast(void)",
|
||||
InstructionType::None => "None",
|
||||
InstructionType::MemUse => "Memory use (internal)",
|
||||
InstructionType::FnCall => "Function Call (Internal)",
|
||||
InstructionType::ConstUse => "Constant Use (Internal)",
|
||||
InstructionType::Return => "return",
|
||||
InstructionType::TypeBool => "bool",
|
||||
InstructionType::TypePtr => "ptr",
|
||||
InstructionType::TypeInt => "int",
|
||||
InstructionType::TypeVoid => "void",
|
||||
InstructionType::Returns => "returns",
|
||||
InstructionType::With => "with",
|
||||
InstructionType::TypeAny => "any",
|
||||
}
|
||||
}
|
||||
OpType::Keyword(keyword) => {
|
||||
match keyword {
|
||||
KeywordType::If => "if",
|
||||
KeywordType::Else => "else",
|
||||
KeywordType::End => "end",
|
||||
KeywordType::While => "while",
|
||||
KeywordType::Do => "do",
|
||||
KeywordType::Include => "include",
|
||||
KeywordType::Memory => "memory",
|
||||
KeywordType::Function => "fn",
|
||||
KeywordType::Constant => "const",
|
||||
KeywordType::FunctionThen => "then",
|
||||
KeywordType::FunctionDone => "done",
|
||||
KeywordType::ConstantDef => "constant Definition (internal)",
|
||||
KeywordType::FunctionDef => "function definition (internal)",
|
||||
KeywordType::FunctionDefExported => "extern function definition (internal)",
|
||||
KeywordType::Inline => "inline",
|
||||
KeywordType::Export => "export",
|
||||
KeywordType::Struct => "struct",
|
||||
}
|
||||
}
|
||||
OpType::Internal(t) => panic!("{t:?}"),
|
||||
|
||||
}.to_string()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Token {
|
||||
pub file: String,
|
||||
pub line: usize,
|
||||
pub col: usize,
|
||||
pub text: String,
|
||||
pub typ: TokenType,
|
||||
pub value: Option<usize>, //* only used for Memories
|
||||
pub addr: Option<usize>, //* only used for Memories
|
||||
pub op_typ: OpType //* only used for Memories
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Copy)]
|
||||
pub enum TokenType {
|
||||
Word,
|
||||
Int,
|
||||
String,
|
||||
CString,
|
||||
Char
|
||||
}
|
||||
|
||||
impl Token {
|
||||
pub fn loc(&self) -> Loc {
|
||||
(
|
||||
self.file.clone(),
|
||||
self.line,
|
||||
self.col
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl TokenType {
|
||||
pub fn human(self) -> String {
|
||||
match self {
|
||||
TokenType::Word => "Word",
|
||||
TokenType::Int => "Int",
|
||||
TokenType::String => "String",
|
||||
TokenType::CString => "CString",
|
||||
TokenType::Char => "Char"
|
||||
}.to_string()
|
||||
}
|
||||
}
|
||||
|
||||
pub type Loc = (String, usize, usize);
|
||||
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
pub enum Types {
|
||||
Any,
|
||||
Bool,
|
||||
Ptr,
|
||||
Void,
|
||||
U8,
|
||||
U16,
|
||||
U32,
|
||||
U64,
|
||||
I8,
|
||||
I16,
|
||||
I32,
|
||||
I64,
|
||||
Custom{
|
||||
size: u64 // in bytes
|
||||
},
|
||||
// todo: add signed numbers since we dont have them yet lol
|
||||
}
|
||||
|
||||
impl Types {
|
||||
pub fn get_size(&self) -> u64 {
|
||||
match *self {
|
||||
Types::Any => 0, // any cant be a known size
|
||||
Types::Void => 0,
|
||||
Types::Bool => 1,
|
||||
Types::U8 |
|
||||
Types::I8 => 1,
|
||||
Types::U16 |
|
||||
Types::I16 => 2,
|
||||
Types::U32 |
|
||||
Types::I32 => 4,
|
||||
Types::Ptr |
|
||||
Types::U64 |
|
||||
Types::I64 => 8,
|
||||
Types::Custom { size } => size,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl TryInto<Types> for &str {
|
||||
type Error = color_eyre::eyre::Error;
|
||||
|
||||
fn try_into(self) -> Result<Types, Self::Error> {
|
||||
match self {
|
||||
"Any" => Ok(Types::Any),
|
||||
"Void" => Ok(Types::Void),
|
||||
"Bool" => Ok(Types::Bool),
|
||||
"U8" => Ok(Types::U8),
|
||||
"I8" => Ok(Types::I8),
|
||||
"U16" => Ok(Types::U16),
|
||||
"I16" => Ok(Types::I16),
|
||||
"U32" => Ok(Types::U32),
|
||||
"I32" => Ok(Types::I32),
|
||||
"Ptr" => Ok(Types::Ptr),
|
||||
"U64" => Ok(Types::U64),
|
||||
"I64" => Ok(Types::I64),
|
||||
_ => bail!("Unknown type {self}")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl TryInto<Types> for String {
|
||||
type Error = color_eyre::eyre::Error;
|
||||
|
||||
fn try_into(self) -> Result<Types, Self::Error> {
|
||||
self.into()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Function {
|
||||
pub loc: Loc,
|
||||
pub name: String,
|
||||
pub inline: bool,
|
||||
pub tokens: Option<Vec<Operator>>
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Constant {
|
||||
pub loc: Loc,
|
||||
pub name: String
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Memory {
|
||||
pub loc: Loc,
|
||||
pub id: usize
|
||||
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct StructDef {
|
||||
pub loc: Loc,
|
||||
pub name: String,
|
||||
pub fields: HashSet<(String, Types)>
|
||||
}
|
||||
|
||||
pub type Functions = HashMap<String, Function>;
|
||||
pub type Memories = HashMap<String, Memory>;
|
||||
pub type Constants = HashMap<String, Constant>;
|
||||
pub type StructDefs = HashMap<String, StructDef>;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Program {
|
||||
pub ops: Vec<Operator>,
|
||||
pub functions: Functions,
|
||||
pub memories: Memories,
|
||||
pub constants: Constants,
|
||||
pub struct_defs: StructDefs
|
||||
}
|
||||
|
|
@ -1,29 +0,0 @@
|
|||
|
||||
|
||||
pub struct Loc {
|
||||
pub ln: usize,
|
||||
pub col: usize,
|
||||
pub file: String
|
||||
}
|
||||
|
||||
impl Loc {
|
||||
pub fn new(file: String, ln: usize, col: usize) -> Self {
|
||||
Self {
|
||||
ln,
|
||||
col,
|
||||
file,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ToString for Loc {
|
||||
fn to_string(&self) -> String {
|
||||
format!("{}:{}:{}", self.file, self.ln, self.col)
|
||||
}
|
||||
}
|
||||
|
||||
impl Into<String> for Loc {
|
||||
fn into(self) -> String {
|
||||
self.to_string()
|
||||
}
|
||||
}
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
mod loc;
|
||||
|
||||
|
||||
pub use loc::*;
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
|
||||
|
||||
pub mod common;
|
||||
pub mod token;
|
||||
|
|
@ -1,65 +0,0 @@
|
|||
use super::common::Loc;
|
||||
|
||||
|
||||
|
||||
|
||||
struct Token {
|
||||
loc: Loc,
|
||||
typ: TokenType,
|
||||
val: TokenValue
|
||||
}
|
||||
|
||||
pub enum TokenValue {
|
||||
Int(usize),
|
||||
Str(String)
|
||||
}
|
||||
|
||||
pub enum TokenType {
|
||||
DbgPrint,
|
||||
Keyword(TokenKeyword),
|
||||
Syscall(u8),
|
||||
|
||||
//? Literal
|
||||
PushInt,
|
||||
PushStr,
|
||||
|
||||
//? Stack manipulation
|
||||
Dup,
|
||||
Rot, // a b c => b c a
|
||||
Over, // a b => a b a
|
||||
Swap, // a b => b a
|
||||
|
||||
//? Math
|
||||
Plus,
|
||||
Minus,
|
||||
Mul,
|
||||
Div,
|
||||
Mod,
|
||||
|
||||
//? Logical
|
||||
And,
|
||||
Or,
|
||||
Eq,
|
||||
Gt,
|
||||
Lt,
|
||||
Ge,
|
||||
Le,
|
||||
Ne,
|
||||
|
||||
//? Bitwise
|
||||
Shr,
|
||||
Shl,
|
||||
Bor,
|
||||
Band,
|
||||
}
|
||||
|
||||
pub enum TokenKeyword {
|
||||
Function,
|
||||
If,
|
||||
Else,
|
||||
End,
|
||||
Done,
|
||||
Macro,
|
||||
While,
|
||||
Do
|
||||
}
|
||||
117
src/util.rs
117
src/util.rs
|
|
@ -1,117 +0,0 @@
|
|||
// use color_eyre::Result;
|
||||
|
||||
pub mod color {
|
||||
#![allow(dead_code)]
|
||||
pub const NONE: &str = "\x1b[0m";
|
||||
pub const RESET: &str = "\x1b[0m";
|
||||
pub const BRIGHT: &str = "\x1b[1m";
|
||||
pub const DIM: &str = "\x1b[2m";
|
||||
pub const UNDERSCORE: &str = "\x1b[4m";
|
||||
pub const BLINK: &str = "\x1b[5m";
|
||||
pub const REVERSE: &str = "\x1b[7m";
|
||||
pub const HIDDEN: &str = "\x1b[8m";
|
||||
pub const FG_BLACK: &str = "\x1b[30m";
|
||||
pub const FG_RED: &str = "\x1b[31m";
|
||||
pub const FG_GREEN: &str = "\x1b[32m";
|
||||
pub const FG_YELLOW: &str = "\x1b[33m";
|
||||
pub const FG_BLUE: &str = "\x1b[34m";
|
||||
pub const FG_MAGENTA: &str = "\x1b[35m";
|
||||
pub const FG_CYAN: &str = "\x1b[36m";
|
||||
pub const FG_WHITE: &str = "\x1b[37m";
|
||||
pub const BG_BLACK: &str = "\x1b[40m";
|
||||
pub const BG_RED: &str = "\x1b[41m";
|
||||
pub const BG_GREEN: &str = "\x1b[42m";
|
||||
pub const BG_YELLOW: &str = "\x1b[43m";
|
||||
pub const BG_BLUE: &str = "\x1b[44m";
|
||||
pub const BG_MAGENTA: &str = "\x1b[45m";
|
||||
pub const BG_CYAN: &str = "\x1b[46m";
|
||||
pub const BG_WHITE: &str = "\x1b[47m";
|
||||
}
|
||||
|
||||
pub mod logger {
|
||||
#![allow(dead_code)]
|
||||
use std::ops::Deref;
|
||||
|
||||
use crate::{util::color, definitions::Loc};
|
||||
|
||||
pub fn error(msg: &str) {
|
||||
println!("{red}error{r}: {msg}", red=color::FG_RED, r=color::RESET);
|
||||
}
|
||||
|
||||
pub fn warn(msg: &str) {
|
||||
println!("{yellow}warn{r}: {msg}", yellow=color::FG_YELLOW, r=color::RESET);
|
||||
}
|
||||
|
||||
pub fn info(msg: &str) {
|
||||
println!("{green}info{r}: {msg}", green=color::FG_GREEN, r=color::RESET);
|
||||
}
|
||||
|
||||
pub fn note(msg: &str) {
|
||||
println!("{blue}note{r}: {msg}", blue=color::FG_BLUE, r=color::RESET);
|
||||
}
|
||||
|
||||
|
||||
pub fn lerror<P: Deref<Target = Loc>>(loc: P, msg: &str) {
|
||||
println!("{f}:{r}:{c} {red}error{rs}: {msg}", red=color::FG_RED, rs=color::RESET, f=loc.0, r=loc.1, c=loc.2);
|
||||
}
|
||||
|
||||
pub fn lwarn<P: Deref<Target = Loc>>(loc: P, msg: &str) {
|
||||
println!("{f}:{r}:{c} {yellow}warn{rs}: {msg}", yellow=color::FG_YELLOW, rs=color::RESET, f=loc.0, r=loc.1, c=loc.2);
|
||||
}
|
||||
|
||||
pub fn linfo<P: Deref<Target = Loc>>(loc: P, msg: &str) {
|
||||
println!("{f}:{r}:{c} {green}info{rs}: {msg}", green=color::FG_GREEN, rs=color::RESET, f=loc.0, r=loc.1, c=loc.2);
|
||||
}
|
||||
|
||||
pub fn lnote<P: Deref<Target = Loc>>(loc: P, msg: &str) {
|
||||
println!("{f}:{r}:{c} {blue}note{rs}: {msg}", blue=color::FG_BLUE, rs=color::RESET, f=loc.0, r=loc.1, c=loc.2);
|
||||
}
|
||||
|
||||
pub fn help(msg: &str) {
|
||||
println!("{blue}help{r}: {msg}", blue=color::FG_CYAN, r=color::RESET);
|
||||
}
|
||||
|
||||
pub fn code_block(code: &str) -> String {
|
||||
let mut ret = String::new();
|
||||
let lines = code.lines();
|
||||
|
||||
for (i, line) in lines.enumerate() {
|
||||
use std::fmt::Write;
|
||||
writeln!(ret, "{}{} | {}{}",color::FG_BLUE, i + 1, line, color::RESET).unwrap();
|
||||
}
|
||||
ret
|
||||
}
|
||||
pub mod macros {
|
||||
#[macro_export] macro_rules! error { ($($arg:tt)*) => { $crate::util::logger::error(std::format_args!($($arg)*).to_string().as_str()) }; }
|
||||
#[macro_export] macro_rules! warn { ($($arg:tt)*) => { $crate::util::logger::warn( std::format_args!($($arg)*).to_string().as_str()) }; }
|
||||
#[macro_export] macro_rules! info { ($($arg:tt)*) => { $crate::util::logger::info( std::format_args!($($arg)*).to_string().as_str()) }; }
|
||||
#[macro_export] macro_rules! note { ($($arg:tt)*) => { $crate::util::logger::note( std::format_args!($($arg)*).to_string().as_str()) }; }
|
||||
|
||||
#[macro_export] macro_rules! lerror { ($dst:expr, $($arg:tt)*) => { $crate::util::logger::lerror($dst, std::format_args!($($arg)*).to_string().as_str()) }; }
|
||||
#[macro_export] macro_rules! lwarn { ($dst:expr, $($arg:tt)*) => { $crate::util::logger::lwarn($dst, std::format_args!($($arg)*).to_string().as_str()) }; }
|
||||
#[macro_export] macro_rules! linfo { ($dst:expr, $($arg:tt)*) => { $crate::util::logger::linfo($dst, std::format_args!($($arg)*).to_string().as_str()) }; }
|
||||
#[macro_export] macro_rules! lnote { ($dst:expr, $($arg:tt)*) => { $crate::util::logger::lnote($dst, std::format_args!($($arg)*).to_string().as_str()) }; }
|
||||
|
||||
#[macro_export] macro_rules! help { ($($arg:tt)*) => { $crate::util::logger::help( std::format_args!($($arg)*).to_string().as_str()) }; }
|
||||
#[macro_export] macro_rules! code_block { ($($arg:tt)*) => { $crate::util::logger::code_block( std::format_args!($($arg)*).to_string().as_str()) }; }
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// pub trait StringExtra{
|
||||
// fn find_idx(&self, pat: char, start: u32) -> Result<u32, ()>;
|
||||
// }
|
||||
// impl StringExtra for String {
|
||||
// fn find_idx(&self, pat: char, start: u32) -> Result<u32, ()> {
|
||||
// let mut col = start;
|
||||
|
||||
// for c in (*self).chars() {
|
||||
// if c == pat {
|
||||
// return Ok(col);
|
||||
// }
|
||||
// col += 1;
|
||||
// }
|
||||
// Err(())
|
||||
|
||||
// }
|
||||
// }
|
||||
13
test.mcl
13
test.mcl
|
|
@ -1,13 +1,6 @@
|
|||
include "std.mcl"
|
||||
|
||||
|
||||
fn main with int ptr returns void then
|
||||
// p l
|
||||
"Hello!\n" puts
|
||||
|
||||
// memory fd 4 end
|
||||
|
||||
// c"./test.mcl" FS_O_SYNC 0 fopen
|
||||
// dup _dbg_print
|
||||
// fd swap write32
|
||||
done
|
||||
main :: fn(argc: i32, argv: string -> i32 {
|
||||
println!("Hello world!\n");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1 +0,0 @@
|
|||
gftdesd5ryutfgyhibugtf6r4
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
34 35 + print
|
||||
|
||||
800 380 - print
|
||||
|
||||
10 5 * print
|
||||
|
||||
40 5 / print
|
||||
4
tools/.gitignore
vendored
4
tools/.gitignore
vendored
|
|
@ -1,4 +0,0 @@
|
|||
/*
|
||||
!/.gitignore
|
||||
!/*.c
|
||||
!/build_tools.sh
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
#!/usr/bin/bash
|
||||
|
||||
gcc intcnv.c -o intcnv
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
#include<stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
if (argc < 3) {
|
||||
printf("Usage: intcnv i32 134\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
const char* typ = argv[1];
|
||||
__uint64_t num = atoi(argv[2]);
|
||||
|
||||
if (strcmp(typ, "u8") == 0) {
|
||||
__uint8_t num2 = (__uint8_t)num;
|
||||
printf("%d\n", num2);
|
||||
}
|
||||
if (strcmp(typ, "i8") == 0) {
|
||||
__int8_t num2 = (__int8_t)num;
|
||||
printf("%d\n", num2);
|
||||
}
|
||||
if (strcmp(typ, "u16") == 0) {
|
||||
__uint16_t num2 = (__uint16_t)num;
|
||||
printf("%d\n", num2);
|
||||
}
|
||||
if (strcmp(typ, "i16") == 0) {
|
||||
__int16_t num2 = (__int16_t)num;
|
||||
printf("%d\n", num2);
|
||||
}
|
||||
if (strcmp(typ, "u32") == 0) {
|
||||
__uint32_t num2 = (__uint32_t)num;
|
||||
printf("%d\n", num2);
|
||||
}
|
||||
if (strcmp(typ, "i32") == 0) {
|
||||
__int32_t num2 = (__int32_t)num;
|
||||
printf("%d\n", num2);
|
||||
}
|
||||
if (strcmp(typ, "u64") == 0) {
|
||||
__uint64_t num2 = (__uint64_t)num;
|
||||
printf("%d\n", num2);
|
||||
}
|
||||
if (strcmp(typ, "i64") == 0) {
|
||||
__int64_t num2 = (__int64_t)num;
|
||||
printf("%d\n", num2);
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user